Chromium扩展（Extension）加载过程分析

发表于 5年以前 | 总阅读数：2607 次

Chromium在启动的时候，会根据当前用户的Profile创建一个Extension Service。Extension Service在创建过程中，会加载当前已经安装的所有Extension，并且将它们注册在一个Extension Registry中。以后通过这个Extension Registry，就可以得到当前可用的Extension的信息了。本文接下来就分析Extension的加载过程。

《Android系统源代码情景分析》一书正在进击的程序员网（http://0xcc0xcd.com）中连载，点击进入！

Chromium的启动，指的实际上是Chromium的Browser进程的启动。关于Chromium的多进程架构，可以参考前面Chromium多进程架构简要介绍和学习计划这个系列的文章。Chromium的Browser进程在启动之后，会创建一系列的Startup Task。每一个Startup Task都会负责初始化相应的模块。上述的Extension Service就是在一个Startup Task中创建的，如图1所示：

图1 Extension的加载过程

Extension Service在创建的过程中，会通过一个Installed Loader加载当前已经安装的所有Extension，并且将那些设置为Enabled的Extension注册到Extension Registry中，从而得到一个当前可用的Extension列表。

接下来，我们就从Chromium的Browser进程的启动开始，分析它加载Extension的过程。

在前面Chromium硬件加速渲染的OpenGL上下文绘图表面创建过程分析一文中，我们以Content Shell APK为例，分析了Browser进程的启动过程。在这个启动过程中，会创建一个BrowserStartupController对象，并且调用这个BrowserStartupController对象的成员函数startBrowserProcessesAsync异步启动和初始化Chromium的Content模块，如下所示：

public class BrowserStartupController {
        ......

        public void startBrowserProcessesAsync(final StartupCallback callback)
                throws ProcessInitException {
            ......

            // Browser process has not been fully started yet, so we defer executing the callback.
            mAsyncStartupCallbacks.add(callback);
            ......

            if (!mHasStartedInitializingBrowserProcess) {
                ......

                prepareToStartBrowserProcess(MAX_RENDERERS_LIMIT);
                ......

                if (contentStart() > 0) {
                    // Failed. The callbacks may not have run, so run them.
                    enqueueCallbackExecution(STARTUP_FAILURE, NOT_ALREADY_STARTED);
                }
            }
        }

        ......
    }

这个函数定义在文件external/chromium_org/content/public/android/java/src/org/chromium/content/browser/BrowserStartupController.java中。

在Browser进程的Content模块还没有启动过的情况下，BrowserStartupController类的成员变量mHasStartedInitializingBrowserProcess的值会等于false。在这种情况下，BrowserStartupController类的成员函数startBrowserProcessesAsync会做两件事情：

1. 调用成员函数prepareToStartBrowserProcess在VM中加载libcontent_shell_content_view.so。

2. 调用成员函数contentStart启动和初始化Content模块。

从Dalvik虚拟机JNI方法的注册过程分析这篇文章可以知道，VM在加载so的过程中，将会调用它导出的一个名称为JNI_OnLoad的函数。对libcontent_shell_content_view.so来说，它导出的JNI_OnLoad函数的实现如下所示：

// This is called by the VM when the shared library is first loaded.
    JNI_EXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
      ......

      content::SetContentMainDelegate(new content::ShellMainDelegate());
      return JNI_VERSION_1_4;
    }

这个函数定义在文件external/chromium_org/content/shell/android/shell_library_loader.cc中。

函数JNI_OnLoad将会创建一个ShellMainDelegate对象，并且调用函数SetContentMainDelegate将它保存在一个全局变量g_content_main_delegate中，如下所示：

namespace {
    ......

    LazyInstance<scoped_ptr<contentmaindelegate> > g_content_main_delegate =
        LAZY_INSTANCE_INITIALIZER;
    }  // namespace

    void SetContentMainDelegate(ContentMainDelegate* delegate) {
      DCHECK(!g_content_main_delegate.Get().get());
      g_content_main_delegate.Get().reset(delegate);
    }

这个函数定义在文件external/chromium_org/content/app/android/content_main.cc中。

这一步执行完成后，回到前面分析的BrowserStartupController类的成员函数startBrowserProcessesAsync中，它接下来将会调用另外一个成员函数contentStart启动和初始化Content模块，如下所示：

public class BrowserStartupController {
        ......

        int contentStart() {
            return ContentMain.start();
        }

        ......
    }

这个函数定义在文件external/chromium_org/content/public/android/java/src/org/chromium/content/browser/BrowserStartupController.java中。

BrowserStartupController类的成员函数contentStart调用ContentMain类的静态成员函数start在Browser进程中启动和初始化Content模块。在前面Chromium的Render进程启动过程分析一文中，我们已经分析过ContentMain类的静态成员函数start的实现了。它最终会调用到C++层的一个函数Start启动和初始化Content模块，如下所示：

namespace {
    LazyInstance<scoped_ptr<ContentMainRunner> > g_content_runner =
        LAZY_INSTANCE_INITIALIZER;

    ......
    }  // namespace

    ......

    static jint Start(JNIEnv* env, jclass clazz) {
      ......

      if (!g_content_runner.Get().get()) {
        ContentMainParams params(g_content_main_delegate.Get().get());
        g_content_runner.Get().reset(ContentMainRunner::Create());
        g_content_runner.Get()->Initialize(params);
      }
      return g_content_runner.Get()->Run();
    }

这个函数定义在文件external/chromium_org/content/app/android/content_main.cc中。

函数Start首先判断一个全局变量g_content_runner是否已经指向了一个ContentMainRunner对象。如果还没有指向，那么就会调用ContentMainRunner类的静态成员函数Create创建一个ContentMainRunner对象，如下所示：

ContentMainRunner* ContentMainRunner::Create() {
      return new ContentMainRunnerImpl();
    }

这个函数定义在文件external/chromium_org/content/app/content_main_runner.cc中。

从这里可以看到，ContentMainRunner类的静态成员函数Create创建的实际上是一个ContentMainRunnerImpl对象。这个ContentMainRunnerImpl对象返回给前面分析的函数Start之后，就会保存在全局变量g_content_runner中。

函数Start获得了新创建的ContentMainRunnerImpl对象之后，会调用它的成员函数Initialize，并且将全局变量g_content_main_delegate指向的ShellMainDelegate对象封装在一个类型为ContentMainParams的参数中传递给它，让它执行初始化工作。

ContentMainRunnerImpl类的成员函数Initialize的实现如下所示：

class ContentMainRunnerImpl : public ContentMainRunner {
     public:
      ......

      virtual int Initialize(const ContentMainParams& params) OVERRIDE {
        ......

        delegate_ = params.delegate;

        ......
      }

      ......

     private:
      ......

      ContentMainDelegate* delegate_;

      ......
    };

这个函数定义在文件external/chromium_org/content/app/content_main_runner.cc中。

ContentMainRunnerImpl类的成员函数Initialize将封装在参数params中的一个ShellMainDelegate对象保存在成员变量delegate_中，也就是ContentMainRunnerImpl类的成员变量delegate_指向了一个ShellMainDelegate对象。

回到前面分析的函数Start中，它最后调用前面创建的ContentMainRunnerImpl对象的成员函数Run启动和初始化Content模块，如下所示：

class ContentMainRunnerImpl : public ContentMainRunner {
     public:
      ......

      virtual int Run() OVERRIDE {
        ......
        const CommandLine& command_line = *CommandLine::ForCurrentProcess();
        std::string process_type =
              command_line.GetSwitchValueASCII(switches::kProcessType);

        MainFunctionParams main_params(command_line);
        ......

    #if !defined(OS_IOS)
        return RunNamedProcessTypeMain(process_type, main_params, delegate_);
    #else
        return 1;
    #endif
      }

      ......
    };

这个函数定义在文件external/chromium_org/content/app/content_main_runner.cc中。

ContentMainRunnerImpl类的成员函数Run首先检查当前进程是否指定了switches::kProcessType启动选项。如果指定了，那么就会获取它的值。获取到的值保存在本地变量process_type中，表示当前进程的类型。Browser进程没有指定switches::kProcessType启动选项，因此本地变量process_type的值将为空，表示当前进程是Browser进程。

ContentMainRunnerImpl类的成员函数Run接下来调用函数RunNamedProcessTypeMain启动和初始化Content模块，如下所示：

int RunNamedProcessTypeMain(
        const std::string& process_type,
        const MainFunctionParams& main_function_params,
        ContentMainDelegate* delegate) {
      static const MainFunction kMainFunctions[] = {
    #if !defined(CHROME_MULTIPLE_DLL_CHILD)
        { "",                            BrowserMain },
    #endif
    #if !defined(CHROME_MULTIPLE_DLL_BROWSER)
    #if defined(ENABLE_PLUGINS)
    #if !defined(OS_LINUX)
        { switches::kPluginProcess,      PluginMain },
    #endif
        { switches::kWorkerProcess,      WorkerMain },
        { switches::kPpapiPluginProcess, PpapiPluginMain },
        { switches::kPpapiBrokerProcess, PpapiBrokerMain },
    #endif  // ENABLE_PLUGINS
        { switches::kUtilityProcess,     UtilityMain },
        { switches::kRendererProcess,    RendererMain },
        { switches::kGpuProcess,         GpuMain },
    #endif  // !CHROME_MULTIPLE_DLL_BROWSER
      };

      ......

      for (size_t i = 0; i < arraysize(kMainFunctions); ++i) {
        if (process_type == kMainFunctions[i].name) {
          if (delegate) {
            int exit_code = delegate->RunProcess(process_type,
                main_function_params);
    #if defined(OS_ANDROID)
            // In Android's browser process, the negative exit code doesn't mean the
            // default behavior should be used as the UI message loop is managed by
            // the Java and the browser process's default behavior is always
            // overridden.
            if (process_type.empty())
              return exit_code;
    #endif
            if (exit_code >= 0)
              return exit_code;
          }
          return kMainFunctions[i].function(main_function_params);
        }
      }

      ......

      return 1;
    }

这个函数定义在文件external/chromium_org/content/app/content_main_runner.cc中。

函数RunNamedProcessTypeMain在内部定义了一个静态数组kMainFunctions，它会根据参数process_type的值在这个数组中找到对应的函数执行，也就是不同的进程执行不同的函数来启动和初始化Content模块。

从前面Chromium的Render进程启动过程分析、Chromium的GPU进程启动过程分析和Chromium的Plugin进程启动过程分析这三篇文章可以知道，Render进程、GPU进程和Plugin进程分别通过调用函数RendererMain、GpuMain和PluginMain启动和初始化Content模块。

对于Browser进程来说，情况有点特殊，它并没有调用函数BrowserMain来启动和初始化Content模块。这是因为当参数process_type的值等于空时，函数RunNamedProcessTypeMain调用完成另外一个参数delegate指向的一个ShellMainDelegate对象的成员函数RunProcess后，就会直接直接返回，从而不会执行函数BrowserMain。

这意味着Browser进程是通过调用ShellMainDelegate类的成员函数RunProcess来启动和初始化Content模块的，如下所示：

int ShellMainDelegate::RunProcess(
        const std::string& process_type,
        const MainFunctionParams& main_function_params) {
      ......

      browser_runner_.reset(BrowserMainRunner::Create());
      return ShellBrowserMain(main_function_params, browser_runner_);
    }

这个函数定义在文件external/chromium_org/content/shell/app/shell_main_delegate.cc中。

ShellMainDelegate类的成员函数RunProcess首先调用BrowserMainRunner类的静态成员函数Create创建一个BrowserMainRunnerImpl对象，如下所示：

BrowserMainRunner* BrowserMainRunner::Create() {
      return new BrowserMainRunnerImpl();
    }

这个函数定义在文件external/chromium_org/content/browser/browser_main_runner.cc中。

创建出来的BrowserMainRunnerImpl对象将会保存在ShellMainDelegate类的成员变量browser_runner_中，并且这个BrowserMainRunnerImpl对象会传递给另外一个函数ShellBrowserMain进行处理，如下所示：

// Main routine for running as the Browser process.
    int ShellBrowserMain(
        const content::MainFunctionParams& parameters,
        const scoped_ptr<content::BrowserMainRunner>& main_runner) {
      ......

      int exit_code = main_runner->Initialize(parameters);
      ......

      if (exit_code >= 0)
        return exit_code;

      ......

      return exit_code;
    }

这个函数定义在文件external/chromium_org/content/shell/browser/shell_browser_main.cc中。

函数ShellBrowserMain主要是调用参数main_runner指向的一个BrowserMainRunnerImpl对象的成员函数Initialize在Browser进程中初始化Content模块。BrowserMainRunnerImpl类的成员函数Initialize的返回值将会大于等于0，这时候函数ShellBrowserMain就会沿着调用路径一直返回到Java层去了，从而使得当前线程（Browser进程的主线程）在Java层进入到消息循环中去。

以上就是Content Shell APK的Browser进程的启动流程。Chrome APK的Browser进程的启动流程也是类似的，它们最后都会通过调用BrowserMainRunnerImpl类的成员函数Initialize初始化Content模块。为了方便描述，接下来我们就将以Chrome APK为例，继续分析BrowserMainRunnerImpl类的成员函数Initialize的实现，从中就可以看到Extension的加载过程。

BrowserMainRunnerImpl类的成员函数Initialize的实现如下所示：

class BrowserMainRunnerImpl : public BrowserMainRunner {
     public:
      ......

      virtual int Initialize(const MainFunctionParams& parameters) OVERRIDE {
        ......

        if (!initialization_started_) {
          initialization_started_ = true;
          ......

          main_loop_.reset(new BrowserMainLoop(parameters));

          main_loop_->Init();

          ......
        }

        main_loop_->CreateStartupTasks();
        int result_code = main_loop_->GetResultCode();
        if (result_code > 0)
          return result_code;

        // Return -1 to indicate no early termination.
        return -1;
      }

      ......
    };

这个函数定义在文件external/chromium_org/content/browser/browser_main_runner.cc中。

BrowserMainRunnerImpl类的成员函数Initialize首先检查成员变量initialization_started_的值是否不等于true。如果不等于true，那么就说明Browser进程还没有执行过初始化操作。在这种情况下，BrowserMainRunnerImpl类的成员函数Initialize接下来就会创建一个BrowserMainLoop对象，并且调用这个BrowserMainLoop对象的成员函数Init执行初始化工作，如下所示：

void BrowserMainLoop::Init() {
      ......
      parts_.reset(
          GetContentClient()->browser()->CreateBrowserMainParts(parameters_));
    }

这个函数定义在文件external/chromium_org/content/browser/browser_main_loop.cc中。

BrowserMainLoop对象的成员函数Init的主要任务是创建一个BrowserMainParts对象，并且保存在成员变量parts_中。后面会通过这个BrowserMainParts对象执行一些初始化工作。

为了创建这个BrowserMainParts对象，BrowserMainLoop对象的成员函数Init首先调用函数GetContentClient获得一个ContentClient对象。对于Chrome APK来说，这个ContentClient对象的实际类型为ChromeContentClient，也就是这里调用函数GetContentClient获得的是一个ChromeContentClient对象。

有了这个ChromeContentClient对象之后，就可以调用它的成员函数browser获得一个ChromeContentBrowserClient对象。有了这个ChromeContentBrowserClient对象，就可以调用它的成员函数CreateBrowserMainParts创建一个BrowserMainParts对象了，如下所示：

content::BrowserMainParts* ChromeContentBrowserClient::CreateBrowserMainParts(
        const content::MainFunctionParams& parameters) {
      ChromeBrowserMainParts* main_parts;
      // Construct the Main browser parts based on the OS type.
    #if defined(OS_WIN)
      main_parts = new ChromeBrowserMainPartsWin(parameters);
    #elif defined(OS_MACOSX)
      main_parts = new ChromeBrowserMainPartsMac(parameters);
    #elif defined(OS_CHROMEOS)
      main_parts = new chromeos::ChromeBrowserMainPartsChromeos(parameters);
    #elif defined(OS_LINUX)
      main_parts = new ChromeBrowserMainPartsLinux(parameters);
    #elif defined(OS_ANDROID)
      main_parts = new ChromeBrowserMainPartsAndroid(parameters);
    #elif defined(OS_POSIX)
      main_parts = new ChromeBrowserMainPartsPosix(parameters);
    #else
      NOTREACHED();
      main_parts = new ChromeBrowserMainParts(parameters);
    #endif

      ......

      return main_parts;
    }

这个函数定义在文件external/chromium_org/chrome/browser/chrome_content_browser_client.cc中。

从这里可以看到，在Android平台上，ChromeContentBrowserClient类的成员函数CreateBrowserMainParts创建的是一个ChromeBrowserMainPartsAndroid对象。这个ChromeBrowserMainPartsAndroid对象是从ChromeBrowserMainParts类继承下来的。

这一步执行完成之后，BrowserMainLoop对象的成员函数Init就创建了一个ChromeBrowserMainPartsAndroid对象，并且保存在成员变量parts_中。回到前面分析的BrowserMainRunnerImpl类的成员函数Initialize中，它最后会调用前面已经初始化好的BrowserMainLoop对象的成员函数CreateStartupTasks创建一系列Startup Tasks，用来初始化Content模块。这其中就包含了一个类型为PreMainMessageLoopRun的Startup Task，也就是在Browser进程的主线程进入消息循环前执行的Startup Task，如下所示：

void BrowserMainLoop::CreateStartupTasks() {
      .....

      // First time through, we really want to create all the tasks
      if (!startup_task_runner_.get()) {
    #if defined(OS_ANDROID)
        startup_task_runner_ = make_scoped_ptr(new StartupTaskRunner(
            base::Bind(&BrowserStartupComplete),
            base::MessageLoop::current()->message_loop_proxy()));
    #else
        startup_task_runner_ = make_scoped_ptr(new StartupTaskRunner(
            base::Callback<void(int)>(),
            base::MessageLoop::current()->message_loop_proxy()));
    #endif
        ......

        StartupTask pre_main_message_loop_run = base::Bind(
            &BrowserMainLoop::PreMainMessageLoopRun, base::Unretained(this));
        startup_task_runner_->AddTask(pre_main_message_loop_run);

        ......
      }
    #if defined(OS_ANDROID)
      if (!BrowserMayStartAsynchronously()) {
        // A second request for asynchronous startup can be ignored, so
        // StartupRunningTasksAsync is only called first time through. If, however,
        // this is a request for synchronous startup then it must override any
        // previous call for async startup, so we call RunAllTasksNow()
        // unconditionally.
        startup_task_runner_->RunAllTasksNow();
      }
    #else
      startup_task_runner_->RunAllTasksNow();
    #endif
    }

这个函数定义在文件external/chromium_org/content/browser/browser_main_loop.cc中。

BrowserMainLoop类的成员函数CreateStartupTasks首先会检查成员变量startup_task_runner_是否还没有指向一个StartupTaskRunner对象。如果没有指向，那么就会创建一个StartupTaskRunner对象让它指向。这个StartupTaskRunner对象可以用来向当前线程（Browser进程的主线程）的消息队列发送消息，从而可以执行指定的Startup Task。

类型为PreMainMessageLoopRun的Startup Task绑定了BrowserMainLoop类的成员函数PreMainMessageLoopRun。这意味着接下来BrowserMainLoop类的成员函数PreMainMessageLoopRun会在Browser进程的主线程执行，如下所示：

int BrowserMainLoop::PreMainMessageLoopRun() {
      if (parts_) {
        ......
        parts_->PreMainMessageLoopRun();
      }

      ......
      return result_code_;
    }

这个函数定义在文件external/chromium_org/content/browser/browser_main_loop.cc中。

从前面的分析可以知道，BrowserMainLoop类的成员变量parts_指向的是一个ChromeBrowserMainPartsAndroid对象。BrowserMainLoop类的成员函数PreMainMessageLoopRun调用这个ChromeBrowserMainPartsAndroid对象的成员函数PreMainMessageLoopRun执行Browser进程在PreMainMessageLoopRun阶段的初始化工作。

ChromeBrowserMainPartsAndroid类的成员函数PreMainMessageLoopRun是从父类ChromeBrowserMainParts继承下来的，它的实现如下所示：

void ChromeBrowserMainParts::PreMainMessageLoopRun() {
      ......

      result_code_ = PreMainMessageLoopRunImpl();

      ......
    }

这个函数定义在文件external/chromium_org/chrome/browser/chrome_browser_main.cc中。

ChromeBrowserMainParts类的成员函数PreMainMessageLoopRun调用另外一个成员函数PreMainMessageLoopRunImpl执行Browser进程在PreMainMessageLoopRun阶段的初始化工作，如下所示：

int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
      ......

      profile_ = CreatePrimaryProfile(parameters(),
                                      user_data_dir_,
                                      parsed_command_line());
      ......

      return result_code_;
    }

这个函数定义在文件external/chromium_org/chrome/browser/chrome_browser_main.cc中。

ChromeBrowserMainParts类的成员函数PreMainMessageLoopRunImpl执行了一系列的初始化工作。其中的一个初始化工作是为当前登录的用户创建Profile。这是通过调用函数CreatePrimaryProfile实现的。在创建Profile的过程中，就会加载为当前登录的用户安装的Extension。

接下来我们就继续分析函数CreatePrimaryProfile的实现，如下所示：

Profile* CreatePrimaryProfile(const content::MainFunctionParams& parameters,
                                  const base::FilePath& user_data_dir,
                                  const CommandLine& parsed_command_line) {
      ......

      Profile* profile = NULL;
    #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
      ......
      profile = ProfileManager::GetActiveUserProfile();
    #else
      ......
    #endif
      if (profile) {
        ......
        return profile;
      }

      ......

      return NULL;
    }

这个函数定义在文件external/chromium_org/chrome/browser/chrome_browser_main.cc中。

在Android平台上，函数CreatePrimaryProfile调用ProfileManager类的静态成员函数GetActiveUserProfile获得当前用户的Profile，如下所示：

Profile* ProfileManager::GetActiveUserProfile() {
      ProfileManager* profile_manager = g_browser_process->profile_manager();
      ......
      Profile* profile =
          profile_manager->GetActiveUserOrOffTheRecordProfileFromPath(
              profile_manager->user_data_dir());
      ......
      return profile;
    }