क्रोमियम न केवल एक ब्राउज़र है, बल्कि एक अच्छा ढांचा भी है

अधिकांश लोगों को इस तथ्य के लिए उपयोग किया जाता है कि क्रोमियम एक ब्राउज़र और अन्य ब्राउज़र का आधार है। कुछ समय पहले तक, मैंने भी ऐसा सोचा था, लेकिन, कुछ महीनों के लिए इस विषय का अध्ययन करने के बाद, मुझे एक और अद्भुत दुनिया की खोज शुरू हुई। क्रोमियम एक विशाल पारिस्थितिकी तंत्र है जिसमें सब कुछ है: एक निर्भरता प्रणाली, एक क्रॉस-प्लेटफॉर्म बिल्ड सिस्टम और लगभग सभी अवसरों के लिए घटक। तो क्यों नहीं इस सारी शक्ति का उपयोग करके अपने स्वयं के एप्लिकेशन बनाने की कोशिश करें?

कैसे यह करने के लिए शुरू करने पर एक छोटा सा गाइड केत के तहत।

पर्यावरण की तैयारी

लेख में मैं उबंटू 18.04 का उपयोग करूंगा, अन्य ओएस के लिए प्रक्रिया प्रलेखन में पाई जा सकती है:

• लिनक्स
  
• विंडोज
  
• मैक
  

निम्नलिखित चरणों में Git और Python की आवश्यकता होती है। यदि वे स्थापित नहीं हैं, तो उन्हें कमांड का उपयोग करके स्थापित किया जाना चाहिए:

sudo apt install git python 

डिपो_टूल सेट करना

depot_tools क्रोमियम डेवलपमेंट टूलकिट है। इसे स्थापित करने के लिए, आपको प्रदर्शन करना होगा:

 git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git 

और पथ पर्यावरण चर में पथ जोड़ें:

 export PATH="$PATH:/path/to/depot_tools" 

महत्वपूर्ण: अगर आपके घर फ़ोल्डर में depot_tools डाउनलोड किए गए थे, तो PATH चर में ~ का उपयोग न करें, अन्यथा समस्याएं हो सकती हैं। आपको $HOME चर का उपयोग करना चाहिए:

 export PATH="$PATH:${HOME}/depot_tools" 

कोड पुनर्प्राप्ति

सबसे पहले आपको स्रोत के लिए एक फ़ोल्डर बनाने की आवश्यकता है। उदाहरण के लिए, होम निर्देशिका में (लगभग 30 जीबी खाली स्थान की आवश्यकता है):

 mkdir ~/chromium && cd ~/chromium 

उसके बाद, आप depot_tools से depot_tools उपयोगिता का उपयोग करके स्रोत डाउनलोड कर सकते हैं:

 fetch --nohooks --no-history chromium 

अब आप चाय / कॉफी के लिए जा सकते हैं, क्योंकि प्रक्रिया तेज नहीं है। प्रयोगों के लिए, किसी इतिहास की आवश्यकता नहीं होती है, इसलिए --no-history ध्वज का उपयोग नहीं किया जाता है। कहानी और भी लंबी होगी।

निर्भरता स्थापना

सभी स्रोत src फ़ोल्डर में हैं, इस पर जाएं:

 cd src 

अब आपको स्क्रिप्ट का उपयोग करके सभी निर्भरताएं डालनी होंगी:

 ./build/install-build-deps.sh 

और हुक चलाएं:

 gclient runhooks 

इससे पर्यावरण की तैयारी पूरी होती है।

सिस्टम बनाएं

क्रोमियम के लिए निंजा का उपयोग मुख्य असेंबली प्रणाली के रूप में किया जाता है, और GN उपयोगिता का उपयोग .ninja फाइलें उत्पन्न करने के लिए किया जाता है।

इन उपकरणों का उपयोग करने के तरीके को समझने के लिए, मैं एक परीक्षण उपयोगिता उदाहरण बनाने का प्रस्ताव करता हूं। ऐसा करने के लिए, src फ़ोल्डर में एक example सबफ़ोल्डर बनाएँ:

 mkdir example 

फिर, src/example folder में, BUILD.gn फ़ाइल बनाएँ, जिसमें निम्न शामिल हैं:

 executable("example") { sources = [ "example.cc", ] } 

BUILD.gn में एक लक्ष्य ( example निष्पादन योग्य) और उन फ़ाइलों की एक सूची होती है जिन्हें लक्ष्य बनाने के लिए आवश्यक होता है।

अगला कदम example.cc फ़ाइल को स्वयं बनाना है। शुरू करने के लिए, मैं एक क्लासिक एप्लिकेशन "हैलो वर्ल्ड" बनाने का प्रस्ताव करता हूं:

 #include <iostream> int main(int argc, char **argv) { std::cout << "Hello world" << std::endl; return 0; } 

स्रोत कोड GitHub पर पाया जा सकता है ।

नए प्रोजेक्ट के बारे में जानने के लिए GN, src में स्थित BUILD.gn फाइल में, BUILD.gn सेक्शन में लाइन "//example" जोड़ें:

 ... group("gn_all") { testonly = true deps = [ ":gn_visibility", "//base:base_perftests", "//base:base_unittests", "//base/util:base_util_unittests", "//chrome/installer", "//chrome/updater", "//net:net_unittests", "//services:services_unittests", "//services/service_manager/public/cpp", "//skia:skia_unittests", "//sql:sql_unittests", "//third_party/flatbuffers:flatbuffers_unittests", "//tools/binary_size:binary_size_trybot_py", "//tools/ipc_fuzzer:ipc_fuzzer_all", "//tools/metrics:metrics_metadata", "//ui/base:ui_base_unittests", "//ui/gfx:gfx_unittests", "//url:url_unittests", # ↓↓↓↓↓↓↓↓ "//example", ] ... 

अब आपको src फ़ोल्डर में लौटने और कमांड का उपयोग करके प्रोजेक्ट उत्पन्न करने की आवश्यकता है:

 gn gen out/Default 

GN आपको समर्थित आईडीई में से एक के लिए एक परियोजना तैयार करने की अनुमति देता है:

• ग्रहण
  
• बनाम
  
• vs2013
  
• vs2015
  
• vs2017
  
• vs2019
  
• xcode
  
• qtcreator
  
• json
  

आदेश का उपयोग करके अधिक जानकारी प्राप्त की जा सकती है:

 gn help gen 

उदाहरण के लिए, QtCreator में example परियोजना के साथ काम करने के example , आपको कमांड चलाने की आवश्यकता है:

 gn gen --ide=qtcreator --root-target=example out/Default 

उसके बाद, आप QtCreator में प्रोजेक्ट खोल सकते हैं:

 qtcreator out/Default/qtcreator_project/all.creator 

अंतिम कदम निंजा का उपयोग कर परियोजना का निर्माण करना है:

 autoninja -C out/Default example 

विधानसभा प्रणाली का यह संक्षिप्त परिचय पूरा हो सकता है।

कमांड का उपयोग करके एप्लिकेशन लॉन्च किया जा सकता है:

 ./out/Default/example 

और नमस्ते दुनिया को देखें। वास्तव में, आप क्रोमियम में असेंबली सिस्टम के बारे में एक अलग लेख लिख सकते हैं। शायद एक भी नहीं।

कमांड लाइन के साथ काम करें

क्रोमियम कोड बेस को एक फ्रेमवर्क के रूप में उपयोग करने के पहले उदाहरण के रूप में, मैं कमांड लाइन के साथ खेलने का सुझाव देता हूं।

कार्य: क्रोमियम शैली में आवेदन करने के लिए पारित सभी तर्क प्रदर्शित करते हैं।
कमांड लाइन के साथ काम करने के लिए, आपको हेडर फ़ाइल को example.cc में शामिल करना होगा:

 #include "base/command_line.h" 

और हमें BUILD.gn में base परियोजना पर निर्भरता जोड़ना भी नहीं भूलना चाहिए। BUILD.gn इस तरह दिखना चाहिए:

 executable("example") { sources = [ "example.cc", ] deps = [ "//base", ] } 

अब आपकी ज़रूरत की हर चीज़ example जुड़ी होगी।

कमांड लाइन के साथ काम करने के लिए, क्रोमियम एक सिंगलटन base::CommandLine कमांडलाइन प्रदान करता है। इसका लिंक पाने के लिए, आपको स्थैतिक base::CommandLine::ForCurrentProcess का उपयोग करने की आवश्यकता है base::CommandLine::ForCurrentProcess , लेकिन पहले आपको base::CommandLine::Init का उपयोग करके इसे प्रारंभ करने की आवश्यकता है base::CommandLine::Init विधि:

 base::CommandLine::Init(argc, argv); auto *cmd_line = base::CommandLine::ForCurrentProcess(); 

कमांड लाइन पर आवेदन करने के लिए और शुरू होने वाले सभी तर्क base::SwitchMap रूप - लौटाए - base::SwitchMap GetSwitches विधि का उपयोग करके GetSwitches (अनिवार्य रूप से map<string, string> )। अन्य सभी तर्क base::StringVector रूप में दिए गए हैं base::StringVector (अनिवार्य रूप से vectr<strig> )। यह ज्ञान कार्य के लिए कोड लागू करने के लिए पर्याप्त है:

 for (const auto &sw : cmd_line->GetSwitches()) { std::cout << "Switch " << sw.first << ": " << sw.second << std::endl; } for (const auto &arg: cmd_line->GetArgs()) { std::cout << "Arg " << arg << std::endl; } 

पूरा संस्करण GitHub पर पाया जा सकता है ।

एप्लिकेशन बनाने और चलाने के लिए आपको चलाने की आवश्यकता है:

 autoninja -C out/Default example ./out/Default/example arg1 --sw1=val1 --sw2 arg2 

स्क्रीन प्रदर्शित करेगा:

 Switch sw1: val1 Switch sw2: Arg arg1 Arg arg2 

नेटवर्किंग

आज के लिए दूसरे और अंतिम उदाहरण के रूप में, मैं क्रोमियम के नेटवर्क भाग के साथ काम करने का प्रस्ताव करता हूं।

कार्य: तर्क के रूप में पारित यूआरएल की सामग्री को प्रदर्शित करें ।

क्रोमियम नेटवर्क सबसिस्टम

नेटवर्क सबसिस्टम काफी बड़ा और जटिल है। HTTP, HTTPS, FTP और अन्य डेटा संसाधनों के अनुरोधों के लिए प्रवेश बिंदु URLRequest , जो पहले से ही निर्धारित करता है कि किस क्लाइंट का उपयोग करना है। एक सरल आरेख इस तरह दिखता है:



पूर्ण संस्करण प्रलेखन में पाया जा सकता है।

URLRequest बनाने के लिए URLRequest आपको URLRequestContext उपयोग करना चाहिए। एक संदर्भ बनाना एक जटिल प्रक्रिया है, इसलिए URLRequestContextBuilder का उपयोग करने की अनुशंसा की जाती है। यह डिफ़ॉल्ट मानों के साथ सभी आवश्यक चर को इनिशियलाइज़ करेगा, लेकिन यदि वांछित है, तो उन्हें अपने स्वयं के लिए बदला जा सकता है, उदाहरण के लिए:

 net::URLRequestContextBuilder context_builder; context_builder.DisableHttpCache(); context_builder.SetSpdyAndQuicEnabled(true /* http2 */, false /* quic */); context_builder.SetCookieStore(nullptr); 

बहु सूत्रण

क्रोमियम नेटवर्क स्टैक को बहु-थ्रेडेड वातावरण में काम करने के लिए डिज़ाइन किया गया है, इसलिए आप इस विषय को छोड़ नहीं सकते। क्रोमियम में मल्टीथ्रेडिंग के साथ काम करने वाली मूल वस्तुएँ हैं:

• टास्क - क्रोमियम में निष्पादित करने के लिए एक कार्य, यह base::Callback का एक फ़ंक्शन है base::Callback , जो base::Bind का उपयोग करके बनाया जा सकता है।
  
• कार्य कतार - निष्पादित करने के लिए कार्य कतार।
  
• भौतिक धागा - ऑपरेटिंग सिस्टम थ्रेड पर एक क्रॉस-प्लेटफ़ॉर्म आवरण ( pthread पर POSIX या CreateThread() पर pthread )। base::PlatformThread में लागू किया गया base::PlatformThread क्लास, सीधे उपयोग न करें।
  
• आधार :: थ्रेड - एक वास्तविक धागा जो एक समर्पित कार्य कतार से संदेशों को अंतहीन रूप से संसाधित करता है; उन्हें सीधे बनाने की अनुशंसा नहीं की जाती है।
  
• थ्रेड पूल - एक सामान्य कार्य कतार के साथ थ्रेड पूल। base::ThreadPool में लागू किया गया base::ThreadPool वर्ग। एक नियम के रूप में, एक उदाहरण बनाएं। base/task/post_task.h से कार्यों का उपयोग करके इसे कार्य पर भेजा जाता है।
  
• अनुक्रम या आभासी धागा - एक आभासी धागा जो वास्तविक धागे का उपयोग करता है और उनके बीच स्विच कर सकता है।
  
• टास्क रनर - कार्यों को सेट करने के लिए एक इंटरफ़ेस, base::TaskRunner में लागू किया गया base::TaskRunner ।
  
• अनुक्रमित कार्य धावक - कार्यों की स्थापना के लिए एक इंटरफ़ेस, जो यह सुनिश्चित करता है कि कार्यों को उसी क्रम में निष्पादित किया जाएगा जिसमें वे पहुंचे थे। base::SequencedTaskRunner में लागू किया गया base::SequencedTaskRunner वर्ग।
  
• सिंगल-थ्रेड टास्क रनर - पिछले एक के समान, लेकिन गारंटी देता है कि सभी कार्य एक ओएस थ्रेड में किए जाएंगे। base::SingleThreadTaskRunner में लागू किया गया base::SingleThreadTaskRunner ।
  

कार्यान्वयन

कुछ क्रोमियम घटकों को base::AtExitManager की उपस्थिति की आवश्यकता होती है base::AtExitManager - यह एक ऐसा वर्ग है जो आपको उन कार्यों को पंजीकृत करने की अनुमति देता है जो आवेदन समाप्त होने पर निष्पादित किए जाने चाहिए। इसका उपयोग करना बहुत सरल है, आपको स्टैक पर एक ऑब्जेक्ट बनाने की आवश्यकता है:

 base::AtExitManager exit_manager; 

जब exit_manager दायरे से बाहर हो जाता है, तो सभी पंजीकृत कॉलबैक निष्पादित हो जाएंगे।

अब आपको नेटवर्क सबसिस्टम के लिए सभी आवश्यक मल्टीथ्रेडिंग घटकों की उपलब्धता का ध्यान रखना होगा। ऐसा करने के लिए, नेटवर्क संदेशों को संसाधित करने के लिए टाइप करें, टाइप करें Message loop टाइप करें टाइप करें TYPE_IO और मुख्य प्रोग्राम लूप - Run loop लूप:

 base::ThreadPool::CreateAndStartWithDefaultParams("downloader"); base::MessageLoop msg_loop(base::MessageLoop::TYPE_IO); base::RunLoop run_loop; 

अगला, Context builder लिए Context builder का उपयोग करें:

 auto ctx = net::URLRequestContextBuilder().Build(); 

अनुरोध भेजने के लिए, आपको ctx ऑब्जेक्ट की CreateRequest विधि का उपयोग करके CreateRequest ऑब्जेक्ट बनाना होगा। निम्नलिखित पैरामीटर पारित किए जाते हैं:

• यूआरएल, प्रकार के साथ स्ट्रिंग GURL;
  
• प्राथमिकता;
  
• प्रतिनिधि जो घटनाओं को संभालता है।
  

एक प्रतिनिधि एक वर्ग है जो net::URLRequest::Delegate इंटरफ़ेस लागू net::URLRequest::Delegate है। इस कार्य के लिए, यह इस तरह दिख सकता है:

 class MyDelegate : public net::URLRequest::Delegate { public: explicit MyDelegate(base::Closure quit_closure) : quit_closure_(std::move(quit_closure)), buf_(base::MakeRefCounted<net::IOBuffer>(BUF_SZ)) {} void OnReceivedRedirect(net::URLRequest *request, const net::RedirectInfo &redirect_info, bool *defer_redirect) override { std::cerr << "redirect to " << redirect_info.new_url << std::endl; } void OnAuthRequired(net::URLRequest* request, const net::AuthChallengeInfo& auth_info) override { std::cerr << "auth req" << std::endl; } void OnCertificateRequested(net::URLRequest *request, net::SSLCertRequestInfo *cert_request_info) override { std::cerr << "cert req" << std::endl; } void OnSSLCertificateError(net::URLRequest* request, int net_error, const net::SSLInfo& ssl_info, bool fatal) override { std::cerr << "cert err" << std::endl; } void OnResponseStarted(net::URLRequest *request, int net_error) override { std::cerr << "resp started" << std::endl; while (true) { auto n = request->Read(buf_.get(), BUF_SZ); std::cerr << "resp read " << n << std::endl; if (n == net::ERR_IO_PENDING) return; if (n <= 0) { OnReadCompleted(request, n); return; } std::cout << std::string(buf_->data(), n) << std::endl; } } void OnReadCompleted(net::URLRequest *request, int bytes_read) override { std::cerr << "completed" << std::endl; quit_closure_.Run(); } private: base::Closure quit_closure_; scoped_refptr<net::IOBuffer> buf_; }; 

सभी मुख्य तर्क OnResponseStarted ईवेंट OnResponseStarted : जब तक कोई त्रुटि नहीं होती है या पढ़ने के लिए कुछ भी नहीं होता है तब तक प्रतिक्रिया की सामग्री को घटाया जाता है। चूंकि प्रतिक्रिया को पढ़ने के बाद आपको आवेदन पूरा करने की आवश्यकता होती है, प्रतिनिधि के पास उस फ़ंक्शन तक पहुंच होनी चाहिए जो मुख्य Run loop को बाधित करेगा, इस मामले में base::Closure का एक कॉल base::Closure प्रकार का उपयोग किया जाता है।

अब सब कुछ अनुरोध भेजने के लिए तैयार है:

 MyDelegate delegate(run_loop.QuitClosure()); auto req = ctx->CreateRequest(GURL(args[0]), net::RequestPriority::DEFAULT_PRIORITY, &delegate); req->Start(); 

प्रसंस्करण शुरू करने के अनुरोध के लिए, आपको Run loop चलाने की आवश्यकता है:

 run_loop.Run(); 

पूरा संस्करण GitHub पर पाया जा सकता है ।

एप्लिकेशन बनाने और चलाने के लिए आपको चलाने की आवश्यकता है:

 autoninja -C out/Default example out/Default/example "https://example.com/" 

अन्त

वास्तव में, क्रोमियम में आप कई उपयोगी क्यूब्स और ईंटें पा सकते हैं जिनसे आप एप्लिकेशन बना सकते हैं। यह लगातार विकसित हो रहा है, जो एक तरफ, एक प्लस है, और दूसरी तरफ, एपीआई में नियमित बदलाव आपको आराम नहीं देते हैं। उदाहरण के लिए, नवीनतम रिलीज़ में, base::TaskScheduler को base::ThreadPool में बदल दिया गया base::TaskScheduler , सौभाग्य से, एपीआई को बदले बिना।

पुनश्च हम अपनी टीम में एक प्रमुख C ++ प्रोग्रामर की तलाश कर रहे हैं! यदि आप अपने आप में ताकत महसूस करते हैं, तो हमारी इच्छाओं का वर्णन यहां किया गया है: team.mail.ru/vacancy/4641/ । एक "उत्तर" बटन भी है।