Chrome n'est pas seulement un navigateur, mais aussi un bon framework

La plupart des gens sont habitués au fait que Chromium est à la fois un navigateur et la base d'autres navigateurs. Jusqu'à récemment, je le pensais aussi, mais en étudiant ce sujet pendant quelques mois, j'ai commencé à découvrir un autre monde merveilleux. Le chrome est un immense écosystème dans lequel il y a tout: un système de dépendance, un système de construction multiplateforme et des composants pour presque toutes les occasions. Alors pourquoi ne pas essayer de créer vos propres applications en utilisant toute cette puissance?

Sous kat, un petit guide sur la façon de commencer à le faire.

Préparation de l'environnement

Dans l'article que j'utiliserai Ubuntu 18.04, la procédure pour les autres OS peut être trouvée dans la documentation:

• Linux
  
• Windows
  
• Mac
  

Les étapes suivantes nécessitent Git et Python. S'ils ne sont pas installés, ils doivent être installés à l'aide de la commande:

sudo apt install git python 

Définition de depot_tools

depot_tools est une boîte à outils de développement Chromium. Pour l'installer, vous devez effectuer:

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

Et ajoutez le chemin d'accès à la variable d'environnement PATH:

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

Important: si depot_tools été téléchargé dans votre dossier personnel, n'utilisez pas ~ dans la variable PATH , sinon des problèmes pourraient survenir. Vous devez utiliser la variable $HOME :

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

Récupération de code

Vous devez d'abord créer un dossier pour la source. Par exemple, dans le répertoire personnel (environ 30 Go d'espace libre sont nécessaires):

 mkdir ~/chromium && cd ~/chromium 

Après cela, vous pouvez télécharger les sources à l'aide de l'utilitaire de depot_tools partir de depot_tools :

 fetch --nohooks --no-history chromium 

Vous pouvez maintenant opter pour du thé / café, car la procédure n'est pas rapide. Pour les expériences, aucun historique n'est nécessaire, donc l'indicateur --no-history est utilisé. L'histoire sera encore plus longue.

Installation de dépendance

Toutes les sources sont dans le dossier src , allez-y:

 cd src 

Maintenant, vous devez mettre toutes les dépendances à l'aide du script:

 ./build/install-build-deps.sh 

Et exécutez les crochets:

 gclient runhooks 

Ceci termine la préparation de l'environnement.

Système de construction

Ninja est utilisé comme système d'assemblage principal pour Chromium, et l'utilitaire GN est utilisé pour générer des fichiers .ninja .

Pour comprendre comment utiliser ces outils, je propose de créer un exemple d'utilitaire de test. Pour ce faire, créez un example sous-dossier dans le dossier src :

 mkdir example 

Ensuite, dans le dossier src/example , créez le fichier BUILD.gn , qui contient:

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

BUILD.gn compose d'une cible ( example exécutable) et d'une liste de fichiers nécessaires à la construction de la cible.

L'étape suivante consiste à créer le fichier example.cc lui-même. Pour commencer, je propose de faire une application classique "Hello world":

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

Le code source peut être trouvé sur GitHub .

Pour que GN découvre le nouveau projet, dans le fichier BUILD.gn situé dans src , ajoutez la ligne "//example" dans la section deps :

 ... 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", ] ... 

Maintenant, vous devez retourner dans le dossier src et générer le projet à l'aide de la commande:

 gn gen out/Default 

GN vous permet également de préparer un projet pour l'un des IDE pris en charge:

• éclipse
  
• vs
  
• vs2013
  
• vs2015
  
• vs2017
  
• vs2019
  
• xcode
  
• qtcreator
  
• json
  

Plus d'informations peuvent être obtenues en utilisant la commande:

 gn help gen 

Par exemple, pour travailler avec l' example projet dans QtCreator, vous devez exécuter la commande:

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

Après cela, vous pouvez ouvrir le projet dans QtCreator:

 qtcreator out/Default/qtcreator_project/all.creator 

La dernière étape consiste à construire le projet à l'aide de Ninja:

 autoninja -C out/Default example 

Cette brève introduction au système d'assemblage peut être complétée.

L'application peut être lancée à l'aide de la commande:

 ./out/Default/example 

Et voyez Hello world. En fait, vous pouvez écrire un article séparé sur le système d'assemblage dans Chromium. Peut-être pas un.

Travailler avec la ligne de commande

Comme premier exemple d'utilisation de la base de code Chromium comme framework, je suggère de jouer avec la ligne de commande.

Tâche: afficher tous les arguments passés à l'application dans le style Chromium.
Pour travailler avec la ligne de commande, vous devez inclure le fichier d'en-tête dans example.cc:

 #include "base/command_line.h" 

Et nous ne devons pas non plus oublier d'ajouter une dépendance au projet de base dans BUILD.gn . BUILD.gn devrait ressembler à ceci:

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

Maintenant, tout ce dont vous avez besoin sera connecté à l' example .

Pour travailler avec la ligne de commande, Chromium fournit un singleton base::CommandLine . Pour obtenir un lien vers celui-ci, vous devez utiliser la base::CommandLine::ForCurrentProcess statique base::CommandLine::ForCurrentProcess , mais vous devez d'abord l'initialiser à l'aide de la méthode base::CommandLine::Init :

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

Tous les arguments passés à l'application sur la ligne de commande et commençant par un - renvoyés en tant que base::SwitchMap (essentiellement map<string, string> ) à l'aide de la méthode GetSwitches . Tous les autres arguments sont renvoyés en tant que base::StringVector (essentiellement vectr<strig> ). Cette connaissance est suffisante pour implémenter le code de la tâche:

 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; } 

La version complète peut être trouvée sur GitHub .

Pour créer et exécuter l'application, vous devez exécuter:

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

L'écran affichera:

 Switch sw1: val1 Switch sw2: Arg arg1 Arg arg2 

Réseautage

Comme deuxième et dernier exemple pour aujourd'hui, je propose de travailler avec la partie réseau de Chromium.

Tâche: afficher le contenu de l'URL passée en argument .

Sous-système de réseau Chrome

Le sous-système réseau est assez grand et complexe. Le point d'entrée pour les demandes HTTP, HTTPS, FTP et autres ressources de données est URLRequest , qui détermine déjà quel client utiliser. Un diagramme simplifié ressemble à ceci:



La version complète se trouve dans la documentation .

Pour créer une URLRequest vous devez utiliser une URLRequestContext . La création d'un contexte est une opération assez compliquée, il est donc recommandé d'utiliser URLRequestContextBuilder . Il initialisera toutes les variables nécessaires avec des valeurs par défaut, mais, si vous le souhaitez, elles peuvent être modifiées pour les leurs, par exemple:

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

Multithreading

La pile réseau Chromium est conçue pour fonctionner dans un environnement multi-thread, vous ne pouvez donc pas ignorer cette rubrique. Les objets de base pour travailler avec le multithreading dans Chromium sont:

• Tâche - une tâche à exécuter, dans Chromium, c'est une fonction de type base::Callback , qui peut être créée en utilisant base::Bind .
  
• File d'attente des tâches - la file d'attente des tâches à exécuter.
  
• pthread physique - un wrapper multiplateforme sur le thread du système d'exploitation ( pthread sur POSIX ou CreateThread() sur Windows). Implémenté dans la classe base::PlatformThread , ne l'utilisez pas directement.
  
• base :: Thread - un vrai thread qui traite les messages d'une file d'attente de tâches dédiée à l'infini; Il n'est pas recommandé de les créer directement.
  
• Pool de threads - pool de threads avec une file d'attente de tâches commune. Implémenté dans la classe base::ThreadPool . En règle générale, créez une instance. Les tâches lui sont envoyées à l'aide des fonctions de base/task/post_task.h .
  
• Séquence ou thread virtuel - un thread virtuel qui utilise de vrais threads et peut basculer entre eux.
  
• base::TaskRunner tâches - une interface pour définir des tâches, implémentée dans la base::TaskRunner .
  
• Gestionnaire de tâches séquencé - une interface pour définir des tâches, qui garantit que les tâches seront exécutées dans le même ordre dans lequel elles sont arrivées. Implémenté dans la classe base::SequencedTaskRunner .
  
• Exécuteur de tâches à un seul thread - similaire au précédent, mais garantit que toutes les tâches seront exécutées dans un seul thread du système d'exploitation. Implémenté dans la base::SingleThreadTaskRunner .
  

Implémentation

Certains composants Chromium nécessitent la présence de base::AtExitManager - il s'agit d'une classe qui vous permet d'enregistrer les opérations qui doivent être effectuées à la fin de l'application. Son utilisation est très simple, vous devez créer un objet sur la pile:

 base::AtExitManager exit_manager; 

Lorsque exit_manager sort de la portée, tous les rappels enregistrés seront exécutés.

Vous devez maintenant vous assurer de la disponibilité de tous les composants multithreads nécessaires pour le sous-système réseau. Pour ce faire, créez un Thread pool , une Message loop de type TYPE_IO pour le traitement des messages réseau et une Message loop d' TYPE_IO - la boucle du programme principal:

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

Ensuite, utilisez le Context builder pour créer un Context :

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

Pour envoyer une demande, vous devez créer un objet URLRequest à l'aide de la méthode CreateRequest de l'objet ctx . Les paramètres suivants sont transmis:

• URL, chaîne de type GURL;
  
• priorité;
  
• délégué qui gère les événements.
  

Un délégué est une classe qui implémente l'interface net::URLRequest::Delegate . Pour cette tâche, cela peut ressembler à ceci:

 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_; }; 

Toute la logique principale est dans le OnResponseStarted événement OnResponseStarted : le contenu de la réponse est soustrait jusqu'à ce qu'une erreur se produise ou qu'il n'y ait rien à lire. Étant donné qu'après avoir lu la réponse, vous devez terminer l'application, le délégué doit avoir accès à la fonction qui interrompra la Run loop principale, dans ce cas, un rappel du type base::Closure est utilisé.

Maintenant, tout est prêt pour envoyer la demande:

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

Pour que la demande démarre le traitement, exécutez la Run loop :

 run_loop.Run(); 

La version complète peut être trouvée sur GitHub .

Pour créer et exécuter l'application, vous devez exécuter:

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

Finale

En fait, dans Chromium, vous pouvez trouver de nombreux cubes et briques utiles à partir desquels vous pouvez créer des applications. Il est en constante évolution, ce qui, d'une part, est un plus, et d'autre part, les changements réguliers de l'API ne vous permettent pas de vous détendre. Par exemple, dans la dernière version, base::TaskScheduler s'est transformé en base::ThreadPool , heureusement, sans changer l'API.

PS Nous recherchons un programmeur C ++ leader dans notre équipe! Si vous ressentez la force en vous-même, nos souhaits sont décrits ici: team.mail.ru/vacancy/4641/ . Il y a également un bouton «Répondre».