chromium启动流程(一)-browser进程启动流程

前面通过一些列文章，我们了解清楚了chromium的线程模型和ipc通信框架ipcz。 接下来我们分析一下chromium的启动流程。
本篇以browser进程启动为例进行分析。

chromium的启动入口在chrome/app/chrome_exe_main_aura.cc中。

这里面Aura是Chromium项目中用于窗口管理的底层框架。它负责管理用户界面的窗口和其他图形元素。Aura提供了一个跨平台的框架，用于构建Chromium浏览器的用户界面组件。
Aura框架被引入以取代Chromium项目中早期使用的称为“views”的窗口系统。Aura提供更好的性能和更大的灵活性，更容易支持多个平台。
值得注意的是，软件项目可能随时间发展而发生变化，因此自我在2022年1月进行更新以来，Chromium和Aura可能已经有了变化或更新。如果有重大变化或新的发布，请查阅官方的Chromium项目文档或发布说明以获取最新信息。

整理流程

废话不多说我们直接看代码

int main(int argc, const char** argv) {
  return ChromeMain(argc, argv);
}

函数直接调用ChromeMain函数。
chrome/app/chrome_main.cc

int ChromeMain(int argc, const char** argv) {
  int64_t exe_entry_point_ticks = 0;
,,,,,,

  ChromeMainDelegate chrome_main_delegate(
      base::TimeTicks::FromInternalValue(exe_entry_point_ticks));
  content::ContentMainParams params(&chrome_main_delegate);

#if BUILDFLAG(IS_WIN)
 ......
#else
  params.argc = argc;
  params.argv = argv;
  base::CommandLine::Init(params.argc, params.argv);
#endif  // BUILDFLAG(IS_WIN)
  base::CommandLine::Init(0, nullptr);
  [[maybe_unused]] base::CommandLine* command_line(
      base::CommandLine::ForCurrentProcess());
......

  // Chrome-specific process modes.
  if (headless::IsHeadlessMode()) {
    ......
  }
......

  int rv = content::ContentMain(std::move(params));

  if (chrome::IsNormalResultCode(static_cast<chrome::ResultCode>(rv)))
    return content::RESULT_CODE_NORMAL_EXIT;
  return rv;
}

函数主要准备参数， 并且处理Headless模式启动，我们不多分析，准备好参数之后调用ContentMain函数。
content/app/content_main.cc

int NO_STACK_PROTECTOR ContentMain(ContentMainParams params) {
  auto runner = ContentMainRunner::Create();
  return RunContentProcess(std::move(params), runner.get());
}

函数先创建ContentMainRunner类，实例为ContentMainRunnerImpl。
ContentMain函数调用RunContentProcess 函数。继续往下看
content/app/content_main.cc

178 int NO_STACK_PROTECTOR
179 RunContentProcess(ContentMainParams params,
180                   ContentMainRunner* content_main_runner) {
181   base::FeatureList::FailOnFeatureAccessWithoutFeatureList();
      ......
        // 初始化CommandLine
238     base::CommandLine::Init(argc, argv);
239 
240 #if BUILDFLAG(IS_POSIX)
        // 初始化文件描述符表
241     PopulateFileDescriptorStoreFromFdTable();
242 #endif
       ...... 
247 #endif  // !BUILDFLAG(IS_ANDROID)
248 
       ......

300     ui::RegisterPathProvider();
        // 初始化content_main_runner
301     exit_code = content_main_runner->Initialize(std::move(params));
302 
303     if (exit_code >= 0) {
304       return exit_code;
305     }
306 
       ......

324   if (IsSubprocess())
325     CommonSubprocessInit();
326   exit_code = content_main_runner->Run();
327 
      ......
335 
336   return exit_code;
337 }

ContentMainRunnerImpl 主要用于启动浏览器， 301 行先初始化，326行调用ContentMainRunnerImpl.Run() 方法启动浏览器。
我们先看ContentMainRunnerImpl的初始化函数。

784 int ContentMainRunnerImpl::Initialize(ContentMainParams params) {
 785   // ContentMainDelegate is used by this class, not forwarded to embedders.
       ......
 821 
 822   is_initialized_ = true;
       ......
 847 
       // 创建ContentClient
 848   if (!GetContentClient())
 849     ContentClientCreator::Create(delegate_);
       ......
 878   
       // 初始化ContentClient
 879   ContentClientInitializer::Set(process_type, delegate_);
 880 
       ......
       // 加载V8引擎快照 
 953   LoadV8SnapshotIfNeeded(command_line, process_type);
 954 
      ......
1034   // Return -1 to indicate no early termination.
1035   return -1;
1036 }

848创建ContentClient实例子。在Chromium项目中，ContentClient 是一个接口类，它定义了与内容（Content）相关的一些回调和功能。具体来说，ContentClient 提供了一个接口，允许浏览器的不同部分（比如渲染进程）与内容相关的操作进行通信。
889行初始化ContentClient。我们看先ContentClient的初始化。

class ContentClientInitializer {
 public:
  static void Set(const std::string& process_type,
                  ContentMainDelegate* delegate) {
    ContentClient* content_client = GetContentClient();
    if (process_type.empty())
      content_client->browser_ = delegate->CreateContentBrowserClient();

    base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
    if (process_type == switches::kGpuProcess ||
        cmd->HasSwitch(switches::kSingleProcess) ||
        (process_type.empty() && cmd->HasSwitch(switches::kInProcessGPU)))
      content_client->gpu_ = delegate->CreateContentGpuClient();

    if (process_type == switches::kRendererProcess ||
        cmd->HasSwitch(switches::kSingleProcess))
      content_client->renderer_ = delegate->CreateContentRendererClient();

    if (process_type == switches::kUtilityProcess ||
        cmd->HasSwitch(switches::kSingleProcess))
      content_client->utility_ = delegate->CreateContentUtilityClient();
  }
};

函数主要初始化了如下成员变量

• browser_: 创建类型为ChromeContentBrowserClient， 用于和browser 进程交互。（只有browser进程里面有）
• gpu_：创建类型为ChromeContentGpuClient。只存在与gpu进程中。
• chrome_content_utility_client_：创建类型为ChromeContentUtilityClient。只存在Utility进程中。
• renderer_：创建类型为ChromeContentRendererClient。 只存在render进程中。

接下来我们继续看启动流程ContentMainRunnerImpl.Run().

1046 // This function must be marked with NO_STACK_PROTECTOR or it may crash on
1047 // return, see the --change-stack-guard-on-fork command line flag.
1048 int NO_STACK_PROTECTOR ContentMainRunnerImpl::Run() {
       ......
1052   const base::CommandLine* command_line =
1053       base::CommandLine::ForCurrentProcess();
       // 获取进程类型
1054   std::string process_type =
1055       command_line->GetSwitchValueASCII(switches::kProcessType);
1056 
       // 等待调试器
1057   if (command_line->HasSwitch(switches::kWaitForDebugger)) {
1058     DVLOG(1) << "Start WaitForDebugger1";
1059     base::debug::WaitForDebugger(600, true);
1060     DVLOG(1) << "End WaitForDebugger1";
1061   }
1062 
        ......
1067   // Run this logic on all child processes.
1068   if (!process_type.empty()) { 
          // process_type 不为空，表示非browser进程
1069     if (process_type != switches::kZygoteProcess) {
             // 非browser进程，非zygote进程做的一些初始化工作
             ......
1086     }
1087 
1088 #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
1089     // If dynamic Mojo Core is being used, ensure that it's loaded very early in
1090     // the child/zygote process, before any sandbox is initialized. The library
1091     // is not fully initialized with IPC support until a ChildProcess is later
1092     // constructed, as initialization spawns a background thread which would be
1093     // unsafe here.
         // 加载mojo库
1094     if (IsMojoCoreSharedLibraryEnabled()) {
1095       CHECK_EQ(mojo::LoadCoreLibrary(GetMojoCoreSharedLibraryPath()),
1096                MOJO_RESULT_OK);
1097     }
1098 #endif  // BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
1099   }
1100 
       // 准备启动参数
1101   MainFunctionParams main_params(command_line);
1102   main_params.ui_task = std::move(content_main_params_->ui_task);
1103   main_params.created_main_parts_closure =
1104       std::move(content_main_params_->created_main_parts_closure);
1105   main_params.needs_startup_tracing_after_mojo_init =
1106       needs_startup_tracing_after_mojo_init_;
      ......

1123 
1124   if (process_type.empty()) // 启动浏览器进程
1125     return RunBrowser(std::move(main_params), start_minimal_browser);
1126 
       // 启动其他进程
1127   return RunOtherNamedProcessTypeMain(process_type, std::move(main_params),
1128                                       delegate_);
1129 }

1054-1055行代码根据启动参数获取进程启动类型。
1057-1061行代码 如果启动参数里面有–wait-for-debugger，则等待调试器。
1068-1099行如果不是browser进程做一些初始化操作，这里不详细分析。
1125 行如果启动的进程类型为browser，则调用RunBrowser启动浏览器。
1127-1128行启动其他类型的进程。

我们这篇文章分析浏览器类型进程启动。 所以看下RunBrowser函数。

1131 int ContentMainRunnerImpl::RunBrowser(MainFunctionParams main_params,
1132                                       bool start_minimal_browser) {
         ......
         // 创建BrowserTaskExecutor， 用于管理ui线程和io线程
1182     BrowserTaskExecutor::Create();
1183 
         ......
1204     if (has_thread_pool) {
1205       // The FeatureList needs to create before starting the ThreadPool.
           // 启动线程池
1206       StartBrowserThreadPool();
1207     }
1208 
        ......
1271   return RunBrowserProcessMain(std::move(main_params), delegate_);
1272 }

函数做了一些初始化工作，包括创建BrowserTaskExceutor 用于管理io线程和ui线程的调度。 启动线程池，然后调用RunBrowserProcessMain函数进一步启动。

int RunBrowserProcessMain(MainFunctionParams main_function_params,
                          ContentMainDelegate* delegate) {
 .......
  return BrowserMain(std::move(absl::get<MainFunctionParams>(exit_code)));
}

RunBrowserProcessMain 函数比较简单，直接调用了BrowserMain函数。

content/browser/browser_main.cc

// Main routine for running as the Browser process.
int BrowserMain(MainFunctionParams parameters) {
 ......

  base::CurrentProcess::GetInstance().SetProcessType(
      base::CurrentProcessType::PROCESS_BROWSER);
  ......
  std::unique_ptr<BrowserMainRunnerImpl> main_runner(
      BrowserMainRunnerImpl::Create());

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

  exit_code = main_runner->Run();
......

  return exit_code;
}

函数先创建BrowserMainRunnerImpl实例，然后执行它的Initialize函数进行初始化，最后调用它的Run方法进入到Looper消息循环。我们先看Initialize方法。
content/browser/browser_main_runner_impl.cc

71 int BrowserMainRunnerImpl::Initialize(MainFunctionParams parameters) {
        ......
        // 初始化Skia 相关Grphic 功能
 83     SkGraphics::Init();
 84 
        .....
 94 
        // 创建通知服务
 95     notification_service_ = std::make_unique<NotificationServiceImpl>();
 96 
       ......

        // 初始化字体      
105     gfx::InitializeFonts();
106 
107     auto created_main_parts_closure =
108         std::move(parameters.created_main_parts_closure);
109 
        // 创建Browser进程的主循环对象
110     main_loop_ = std::make_unique<BrowserMainLoop>(
111         std::move(parameters), std::move(scoped_execution_fence_));
112 
113     main_loop_->Init();
114 
115     if (created_main_parts_closure) {
116       std::move(created_main_parts_closure).Run(main_loop_->parts());
117     }
118 
        // 执行早期初始化
119     const int early_init_error_code = main_loop_->EarlyInitialization();
120     if (early_init_error_code > 0) {
121       main_loop_->CreateMessageLoopForEarlyShutdown();
122       return early_init_error_code;
123     }
124 
125     // Must happen before we try to use a message loop or display any UI.
        // 初始化工具套件
126     if (!main_loop_->InitializeToolkit()) {
127       main_loop_->CreateMessageLoopForEarlyShutdown();
128       return 1;
129     }
130 
        // 创建MainLoop前执行操作
131     main_loop_->PreCreateMainMessageLoop();
         // 创建MainLoop
132     main_loop_->CreateMainMessageLoop();
        // 创建MainLoop后执行操作
133     main_loop_->PostCreateMainMessageLoop();
134 
135     // WARNING: If we get a WM_ENDSESSION, objects created on the stack here
136     // are NOT deleted. If you need something to run during WM_ENDSESSION add it
137     // to browser_shutdown::Shutdown or BrowserProcess::EndSession.
138 
        // 初始化输入法相关
139     ui::InitializeInputMethod();
140   }
      // 执行启动任务。
141   main_loop_->CreateStartupTasks();
142   int result_code = main_loop_->GetResultCode();
143   if (result_code > 0) {
144     return result_code;
145   }
146 
147   // Return -1 to indicate no early termination.
148   return -1;
149 }
150 

函数使用BrowserMainLoop 包装线程模型里面的Looper。
110-111行创建BrowserMainLoop实例。
113行执行main_loop_的初始化。
119 行执行浏览器的早期初始化工作。
126 行初始化toolkit。
131-133行执行main_loop_ 初始化方法，在Looper前、中、后执行对应方法。
139行初始化输入法相关。
141行执行启动相关任务。

我们来看一下BrowserMainLoop的init方法。
content/browser/browser_main_loop.cc

void BrowserMainLoop::Init() {
  TRACE_EVENT0("startup", "BrowserMainLoop::Init");

  if (parameters_.startup_data) {
        ......
  }

  parts_ = GetContentClient()->browser()->CreateBrowserMainParts(
      !!parameters_.ui_task);
}

函数比较简单，这里创建了BrowserMainParts。 BrowserMainParts 是浏览器的主要部分，是通过不同part来实现浏览器的不同功能。我们来看一下它实现了哪些part。
chrome/browser/chrome_content_browser_client.cc

681 std::unique_ptr<content::BrowserMainParts>
1682 ChromeContentBrowserClient::CreateBrowserMainParts(bool is_integration_test) {
1683   std::unique_ptr<ChromeBrowserMainParts> main_parts;
1684   // Construct the Main browser parts based on the OS type.
1685 #if BUILDFLAG(IS_WIN)
      ......
1697 #elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
       // 创建main_parts 实例子， 是平台相关的
1698   main_parts = std::make_unique<ChromeBrowserMainPartsLinux>(
1699       is_integration_test, &startup_data_);
       ......
1709 #else
       ......
1713 #endif
1714 
       // 线程通知相关
1715   main_parts->AddParts(
1716       std::make_unique<ChromeBrowserMainExtraPartsThreadNotifier>(
1717           base::BindOnce(&ChromeContentBrowserClient::InitOnUIThread,
1718                          weak_factory_.GetWeakPtr())));
1719 
1720   bool add_profiles_extra_parts = true;
        ......
1736 #elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
       // 增加LinuxViews 相关的Part
1737   main_parts->AddParts(
1738       std::make_unique<ChromeBrowserMainExtraPartsViewsLinux>());
1739 #else
1740   main_parts->AddParts(std::make_unique<ChromeBrowserMainExtraPartsViews>());
1741 #endif
1742 #endif
1743 
     ......
1756 
1757 #if BUILDFLAG(IS_LINUX)
       // 添加Linux平台特有的Part
1758   main_parts->AddParts(std::make_unique<ChromeBrowserMainExtraPartsLinux>());
1759 #elif BUILDFLAG(IS_OZONE)
1760   main_parts->AddParts(std::make_unique<ChromeBrowserMainExtraPartsOzone>());
1761 #endif
1762 
       // 性能监控相关part
1763   main_parts->AddParts(
1764       std::make_unique<ChromeBrowserMainExtraPartsPerformanceMonitor>());
1765 
       // 性能管理相关part
1766   main_parts->AddParts(
1767       std::make_unique<ChromeBrowserMainExtraPartsPerformanceManager>());
1768 
      // Profiling（性能优化）相关的part
1769   main_parts->AddParts(
1770       std::make_unique<ChromeBrowserMainExtraPartsProfiling>());
1771 
       // 内存相关
1772   main_parts->AddParts(std::make_unique<ChromeBrowserMainExtraPartsMemory>());
       ......
1796 
1797   return main_parts;
1798 }
	

这个函数创建了ChromeBrowserMainPartsLinux这个main_parts, 又向这个main_parts 添加了多个extra_main_part. 下面给出MainParts 和ExtrasMainParts的数据结构。

ChromeBrowserMainPartsLinux 继承自ChromeBrowserMainPartsix，ChromeBrowserMainPartsPosix继承自ChromeBrowserParts， ChromeBrowserParts继承自BrowserMainParts。 ChromeBrowserParts的成员变量chrome_extra_parts_ 指向多个ChromeBrowserMainExtraParts。 BrowserMainParts实现了多个方法，在Chrom的启动周期调用，ChromeBrowserMainExtraParts也实现了这些方法，在调用BrowserMainParts这些方法的时候也会调用ChromeBrowserMainExtraParts的这些方法。我们后面会看到。

在BrowserMainParts定义的注释中给出了它的虚方法的调用时机，我们来看一下。
content/public/browser/browser_main_parts.h

// This class contains different "stages" to be executed by |BrowserMain()|.
//
// Stages:
//
//  ** Cross-platform startup stages.
//  ** Invoked during BrowserMainRunnerImpl::Initialize(), after
//     ContentMainRunner's full initialization.
//
//  - PreEarlyInitialization: things to be be done as soon as possible on
//    program start (such as setting up signal handlers; checking auto-restarts
//    on update; etc.). Core APIs like base::FeatureList,
//    base::SingleThreadTaskRunner::CurrentDefaultHandle, and base::ThreadPool
//    are already functional at this point (ThreadPool will accept but not run
//    tasks until PostCreateThreads).
//
//  - PostEarlyInitialization: things to be be done as soon as possible but that
//    can/must wait until after the few things in BrowserMainLoop's own
//    EarlyInitialization have completed.
//
//  - ToolkitInitialized: similar to PostEarlyInitialization but for the UI
//    toolkit. Allows an embedder to do any extra toolkit initialization.
//
//  - PreCreateMainMessageLoop: things to be done at some generic time before
//    the creation of the main message loop.
//
//  - PostCreateMainMessageLoop: things to be done as early as possible but that
//    need the main message loop to be around (i.e. BrowserThread::UI is up).
//
//  - PreCreateThreads: things that don't need to happen super early but still
//    need to happen during single-threaded initialization (e.g. immutable
//    Singletons that are initialized once and read-only from all threads
//    thereafter).
//    Note: other threads might exist before this point but no child threads
//    owned by content. As such, this is still "single-threaded" initialization
//    as far as content and its embedders are concerned and the right place to
//    initialize thread-compatible objects:
//    https://chromium.googlesource.com/chromium/src/+/main/docs/threading_and_tasks.md#threading-lexicon
//
//  - PostCreateThreads: things that should be done as early as possible but
//    need browser process threads to be alive (i.e. BrowserThread::IO is up and
//    base::ThreadPool is running tasks).
//
//  - PreMainMessageLoopRun: IN DOUBT, PUT THINGS HERE. At this stage all core
//    APIs have been initialized. Services that must be initialized before the
//    browser is considered functional can be initialized from here. Ideally
//    only the frontend is initialized here while the backend takes advantage of
//    a base::ThreadPool worker to come up asynchronously. Things that must
//    happen on the main thread eventually but don't need to block startup
//    should post a BEST_EFFORT task from this stage.
//
//  ** End of cross-platform startup stages.
//  ** Stages above are run as part of startup stages in
//  ** BrowserMainLoop::CreateStartupTasks() and can even be run eagerly (e.g.
//  ** Android app warmup attempts to run these async.
//
//  - WillRunMainMessageLoop: The main thread's RunLoop will be run
//    *immediately* upon returning from this method. While PreMainMessageLoopRun
//    gives that impression, in practice it's part of initialization phases
//    which are triggered independently from MainMessageLoopRun (and can even
//    happen async). In browser tests, PreMainMessageLoopRun() will run before
//    entering test bodies whereas WillRunMainMessageLoop() won't (the control
//    is given to the test rather running the loop). Furthermore, this is only
//    called on platforms where BrowserMainLoop::RunMainMessageLoop is called.
//    Thus, very few things should be done at this stage. It's mostly intended
//    as a way for embedders to override or cancel the default RunLoop if
//    needed.
//
//  - OnFirstIdle: The main thread reached idle for the first time since
//    WillRunMainMessageLoop(). In other words, it's done running any tasks
//    posted as part of the above phases and anything else posted from these.
//
//  - PostMainMessageLoopRun: stop and cleanup things that can/should be cleaned
//    up while base::ThreadPool and BrowserThread::IO are still running.
//    Note: Also see BrowserMainLoop::ShutdownThreadsAndCleanUp() which is often
//    a good fit to stop services (PostMainMessageLoopRun() is called from it).
//
//  - PostDestroyThreads: stop and cleanup things that need to be cleaned up in
//    the single-threaded teardown phase (i.e. typically things that had to
//    created in PreCreateThreads()).
//
//
// How to add stuff (to existing parts):
//  - Figure out when your new code should be executed. What must happen
//    before/after your code is executed? Are there performance reasons for
//    running your code at a particular time? Document these things!
//  - Split out any platform-specific bits. Please avoid #ifdefs it at all
//    possible. You have two choices for platform-specific code: (1) Execute it
//    from one of the |Pre/Post...()| methods in an embedder's platform-specific
//    override (e.g., ChromeBrowserMainPartsWin::PreCreateMainMessageLoop()); do
//    this if the code is unique to an embedder and platform type. Or (2)
//    execute it from one of the "stages" (e.g.,
//    |BrowserMainLoop::EarlyInitialization()|) and provide platform-specific
//    implementations of your code (in a virtual method); do this if you need to
//    provide different implementations across most/all platforms.
//  - Unless your new code is just one or two lines, put it into a separate
//    method with a well-defined purpose. (Likewise, if you're adding to an
//    existing chunk which makes it longer than one or two lines, please move
//    the code out into a separate method.)
//

总结一下：
**跨平台启动部分

• PreEarlyInitialization: 尽早在程序启动时执行的任务（例如设置信号处理程序；检查更新时的自动重启等）。在此时，核心 API 如 base::FeatureList、base::SingleThreadTaskRunner::CurrentDefaultHandle 和 base::ThreadPool 已经可用（ThreadPool 会接受任务但不运行任务，直到 PostCreateThreads 阶段）。
• PostEarlyInitialization: 尽早执行的任务，但必须等到 BrowserMainLoop 的 EarlyInitialization 阶段的一些任务完成后才能执行。
• ToolkitInitialized: 类似于 PostEarlyInitialization，但用于 UI 工具包。允许嵌入程序执行任何额外的工具包初始化。
• PreCreateMainMessageLoop: 在创建主消息循环之前的一些通用时机执行的任务。
• PostCreateMainMessageLoop: 在尽早执行的任务，但需要主消息循环存在（即 BrowserThread::UI 已启动）。
• PreCreateThreads: 不需要非常早执行的任务，但仍需要在单线程初始化期间执行的任务（例如，初始化一次且在此后所有线程中只读取的不可变单例）。注意：在此之前可能存在其他线程，但不包括 content 拥有的子线程。因此，就 content 及其嵌入者而言，这仍然是 “单线程” 初始化，也是初始化线程兼容对象的正确位置：https://chromium.googlesource.com/chromium/src/+/main/docs/threading_and_tasks.md#threading-lexicon
• PostCreateThreads: 尽早执行的任务，但需要浏览器进程线程存在（即 BrowserThread::IO 已启动，base::ThreadPool 在运行任务）。
• PreMainMessageLoopRun: 存在疑问时，请将任务放在这里。在此阶段，所有核心 API 都已初始化。必须在浏览器被视为可用之前初始化的服务可以从这里初始化。理想情况下，只有前端在此处初始化，而后端则利用 base::ThreadPool 的工作线程异步启动。必须最终在主线程上发生但不需要阻塞启动的任务应该从此阶段发布 BEST_EFFORT 任务。

**跨平台启动阶段结束。
**以上阶段作为 BrowserMainLoop::CreateStartupTasks() 启动阶段的一部分运行，甚至可以急切地运行（例如，Android 应用程序预热尝试异步运行这些阶段）。

• WillRunMainMessageLoop: 从此方法返回后，主线程的 RunLoop 将立即运行。虽然 PreMainMessageLoopRun 给出了这种印象，但实际上它是初始化阶段的一部分，与 MainMessageLoopRun 触发的独立触发的（甚至可能是异步的）。在浏览器测试中，PreMainMessageLoopRun() 将在进入测试体之前运行，而 WillRunMainMessageLoop() 不会（控制权交给测试，而不是运行循环）。此外，仅在调用 BrowserMainLoop::RunMainMessageLoop 的平台上调用。因此，在这个阶段应该尽量少做事情。它主要用于嵌入者覆盖或取消默认的 RunLoop（如果需要的话）。

• OnFirstIdle: 主线程自 WillRunMainMessageLoop() 以来首次达到空闲。换句话说，它已完成执行上述阶段和从中发布的任何其他任务。

• PostMainMessageLoopRun: 在 base::ThreadPool 和 BrowserThread::IO 仍在运行时停止和清理可以/应该被清理的事物。注意：还请参阅 BrowserMainLoop::ShutdownThreadsAndCleanUp()，通常适用于停止服务（PostMainMessageLoopRun() 是从其中调用的）。

• PostDestroyThreads: 在单线程拆卸阶段停止和清理需要在其中创建的事物（通常是在 PreCreateThreads() 中创建的事物）。

注释描写的很细致，生命周期也很细致，但是基于我们当前对chrome的了解，还不能详细说明， 请读者用到的时候再加以分析。

BrowserMainLoop 的parts_成员变量指向BrowserMainParts， BrowserMainLoop也提供对应的生命周期方法，它会调用到BrowserMainParts的对应方法。

我们以BrowserMainLoop::EarlyInitialization() 为例进行说明。
content/browser/browser_main_loop.cc

532 int BrowserMainLoop::EarlyInitialization() {
 533   TRACE_EVENT0("startup", "BrowserMainLoop::EarlyInitialization");
 534 
       ......
       // 调用BrowserMainParts->PreEarlyInitialization() 方法
 560   if (parts_) {
 561     const int pre_early_init_error_code = parts_->PreEarlyInitialization();
 562     if (pre_early_init_error_code != RESULT_CODE_NORMAL_EXIT)
 563       return pre_early_init_error_code;
 564   }
 565 
       ......
 571 
 572   // SetCurrentThreadType relies on CurrentUIThread on some platforms. The
 573   // MessagePumpForUI needs to be bound to the main thread by this point.
 574   DCHECK(base::CurrentUIThread::IsSet());
 575   base::PlatformThread::SetCurrentThreadType(base::ThreadType::kCompositing);
 576 
       ......
 617 
 618   if (parsed_command_line_->HasSwitch(switches::kRendererProcessLimit)) {
 619     std::string limit_string = parsed_command_line_->GetSwitchValueASCII(
 620         switches::kRendererProcessLimit);
 621     size_t process_limit;
 622     if (base::StringToSizeT(limit_string, &process_limit)) {
 623       RenderProcessHost::SetMaxRendererProcessCount(process_limit);
 624     }
 625   }
 626 
       // 调用BrowserMainParts->PostEarlyInitialization() 方法
 627   if (parts_)
 628     parts_->PostEarlyInitialization();
 629 
 630   return RESULT_CODE_NORMAL_EXIT;
 631 }

我们可以看到在BrowserMainLoop::EarlyInitialization()方法中分别调用了 BrowserMainParts的PreEarlyInitialization() 方法和PostEarlyInitialization() 方法。 由此可推断BrowserMainLoop的其他生命周期方法也会调用BrowserMainParts的其他生命周期方法，请读者自行验证。

我们分析在linux的实例parts_的相应方法。 ChromeBrowserMainPartsLinux 并没有实现PreEarlyInitialization方法，我们看它父类ChromeBrowserMainPartsPosix的实现。
chrome/browser/chrome_browser_main_posix.cc

int ChromeBrowserMainPartsPosix::PreEarlyInitialization() {
  const int result = ChromeBrowserMainParts::PreEarlyInitialization();
  if (result != content::RESULT_CODE_NORMAL_EXIT)
    return result;

  // We need to accept SIGCHLD, even though our handler is a no-op because
  // otherwise we cannot wait on children. (According to POSIX 2001.)
  struct sigaction action;
  memset(&action, 0, sizeof(action));
  action.sa_handler = SIGCHLDHandler;
  CHECK_EQ(0, sigaction(SIGCHLD, &action, nullptr));

  return content::RESULT_CODE_NORMAL_EXIT;
}

这里调用了父类ChromeBrowserMainParts的PreEarlyInitialization方法并设置了信号处理程序。 我们看ChromeBrowserMainParts->PreEarlyInitialization() 方法的实现。

729 int ChromeBrowserMainParts::PreEarlyInitialization() {
 730   TRACE_EVENT0("startup", "ChromeBrowserMainParts::PreEarlyInitialization");
 731   for (auto& chrome_extra_part : chrome_extra_parts_)
 732     chrome_extra_part->PreEarlyInitialization();
 733 
       ......
 776 
 777   return load_local_state_result;
 778 }

这里有调用了chrome_extra_parts_中的每个extra_part 的PreEarlyInitialization 方法。

关于ChromeBrowserMainParts的基本逻辑和调用流程我们分析完了。 回到BrowserMainRunnerImpl::Initialize() 函数中， 完成各个ChromeBrowserMainParts的初始化工作，就可以执行启动任务了， BrowserMainLoop::CreateStartupTasks() 函数正式这个作用， 创建启动任务。

 838 void BrowserMainLoop::CreateStartupTasks() {
 839   TRACE_EVENT0("startup", "BrowserMainLoop::CreateStartupTasks");
 840 
 841   DCHECK(!startup_task_runner_);
 842 #if BUILDFLAG(IS_ANDROID)
      ......
 851 #else
       // 创建StartupTaskRunner
 852   startup_task_runner_ = std::make_unique<StartupTaskRunner>(
 853       base::OnceCallback<void(int)>(),
 854       base::SingleThreadTaskRunner::GetCurrentDefault());
 855 #endif
 856   StartupTask pre_create_threads = base::BindOnce(
 857       &BrowserMainLoop::PreCreateThreads, base::Unretained(this));
       // 添加任务调用BrowserMainLoop::PreCreateThreads
 858   startup_task_runner_->AddTask(std::move(pre_create_threads));
 859 
 860   StartupTask create_threads =
 861       base::BindOnce(&BrowserMainLoop::CreateThreads, base::Unretained(this));
       // 添加任务调用BrowserMainLoop::CreateThreads
 862   startup_task_runner_->AddTask(std::move(create_threads));
 863 
 864   StartupTask post_create_threads = base::BindOnce(
 865       &BrowserMainLoop::PostCreateThreads, base::Unretained(this));
       // 添加任务调用BrowserMainLoop::PostCreateThreads
 866   startup_task_runner_->AddTask(std::move(post_create_threads));
 867 
 868   StartupTask pre_main_message_loop_run = base::BindOnce(
 869       &BrowserMainLoop::PreMainMessageLoopRun, base::Unretained(this));
       // 添加任务调用BrowserMainLoop::PreMainMessageLoopRun
 870   startup_task_runner_->AddTask(std::move(pre_main_message_loop_run));
 871 
      ......
 887 
 888 #if BUILDFLAG(IS_ANDROID)
         ......
 890 #else
 891   startup_task_runner_->RunAllTasksNow();
 892 #endif
 893 }

函数创建StartupTaskRunner结构，我们知道TaskRunner 一般用于投递任务，StartupTaskRunner也是如此，所以就不深分析StartupTaskRunner了， 它就是向当先线程投递任务。 在CreateStartupTasks函数中分别投递了PreCreateThreads、CreateThreads、PostCreateThreads、PreMainMessageLoopRun 四个函数。CreateStartupTasks函数891行调用startup_task_runner_->RunAllTasksNow()函数会依次调用上述四个函数。 从这四个函数名称还看是在创建线程过程中执行的操作，由于chromium 启动过程中初始化了太多的组件，我们无法依依去分析，所以只看一下CreateThreads了解下启动了哪些线程。
content/browser/startup_task_runner.cc

 919 int BrowserMainLoop::CreateThreads() {
 920   TRACE_EVENT0("startup,rail", "BrowserMainLoop::CreateThreads");
 921 
 922   // Release the ThreadPool's threads.
 923   scoped_execution_fence_.reset();
 924 
 925   // The |io_thread| can have optionally been injected into Init(), but if not,
 926   // create it here. Thre thread is only tagged as BrowserThread::IO here in
 927   // order to prevent any code from statically posting to it before
 928   // CreateThreads() (as such maintaining the invariant that PreCreateThreads()
 929   // et al. "happen-before" BrowserThread::IO is "brought up").
 930   if (!io_thread_) {
 931     io_thread_ = BrowserTaskExecutor::CreateIOThread();
 932   }
 933   io_thread_->RegisterAsBrowserThread();
 934   BrowserTaskExecutor::InitializeIOThread();
 935 
 936   // TODO(https://crbug.com/863341): Replace with a better API
 937   GetContentClient()->browser()->PostAfterStartupTask(
 938       FROM_HERE, base::SequencedTaskRunner::GetCurrentDefault(),
 939       base::BindOnce(
 940           [](BrowserMainLoop* browser_main_loop) {
 941             // Informs BrowserTaskExecutor that startup is complete.
 942             content::BrowserTaskExecutor::OnStartupComplete();
 943             browser_main_loop->scoped_best_effort_execution_fence_.reset();
 944           },
 945           // Main thread tasks can't run after BrowserMainLoop destruction.
 946           // Accessing an Unretained pointer to BrowserMainLoop from a main
 947           // thread task is therefore safe.
 948           base::Unretained(this)));
 949 
 950   created_threads_ = true;
 951   return result_code_;
 952 }

929-934行，将io_thread_注册为BrowserThread。 并初始化BrowserTaskExecutor的iothread， 我们在分析线程的时候已经知道BrowserTaskExecutor 管理浏览器的ui线程和io线程，这里初始化了io线程，ui线程则是浏览器进程的主线程，在作为初始化后会被设置为BrowserTaskExecutor的ui线程。

上面浏览器进程的启动大致流程我们已经分析了，但是我们只看到的进程启动框架，用户要想使用浏览器，必须要将ui展现在屏幕上，并且通过操作ui来执行网页访问，所以我们分析一下ui的初始化过程， 在这个过程中也能看到浏览器实例的创建。

Broswer实例创建

chrome/browser/chrome_browser_main.cc

int ChromeBrowserMainParts::PreMainMessageLoopRun() {
  TRACE_EVENT0("startup", "ChromeBrowserMainParts::PreMainMessageLoopRun");

  result_code_ = PreMainMessageLoopRunImpl();

  for (auto& chrome_extra_part : chrome_extra_parts_)
    chrome_extra_part->PreMainMessageLoopRun();

  return result_code_;
}

在PreMainMessageLoopRun 调用时，会调用ChromeBrowserMainParts::PreMainMessageLoopRun() 方法， 该方法会调用PreMainMessageLoopRunImpl() 方法。 PreMainMessageLoopRunImpl方法会启动浏览器实例。我们来具体分析。

// PreMainMessageLoopRun calls these extra stages in the following order:
//  PreMainMessageLoopRunImpl()
//   ... initial setup, including browser_process_ setup.
//   PreProfileInit()
//   ... additional setup, including CreateProfile()
//   PostProfileInit()
//   ... additional setup
//   PreBrowserStart()
//   ... browser_creator_->Start
//   PostBrowserStart()
1388 int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
      ......
1401 
1402   // Do any initializating in the browser process that requires all threads
1403   // running.
1404   browser_process_->PreMainMessageLoopRun();
1405 
1406   // Record last shutdown time into a histogram.
1407   browser_shutdown::ReadLastShutdownInfo();
1408 
      ......
 
1617   // Desktop construction occurs here, (required before profile creation).
1618   PreProfileInit();
1619 
        ......
1627   // This step is costly and is already measured in Startup.CreateFirstProfile
1628   // and more directly Profile.CreateAndInitializeProfile.
1629   StartupProfileInfo profile_info = CreateInitialProfile(
1630       /*cur_dir=*/base::FilePath(), *base::CommandLine::ForCurrentProcess());
1631   base::UmaHistogramEnumeration(
1632       "ProfilePicker.StartupMode.CreateInitialProfile", profile_info.mode);
1633 
1634   if (profile_info.mode == StartupProfileMode::kError)
1635     return content::RESULT_CODE_NORMAL_EXIT;
1636 
        ......
1685 
1686   // `profile` may be nullptr if the profile picker is shown.
1687   Profile* profile = profile_info.profile;
1688   // Call `PostProfileInit()`and set it up for profiles created later.
1689   profile_init_manager_ = std::make_unique<ProfileInitManager>(this, profile);
1690 
1691 #if !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_CHROMEOS_ASH)
1692   // Execute first run specific code after the PrefService has been initialized
1693   // and preferences have been registered since some of the import code depends
1694   // on preferences.
1695   if (first_run::IsChromeFirstRun()) {
1696     // `profile` may be nullptr even on first run, for example when the
1697     // "BrowserSignin" policy is set to "Force". If so, skip the auto import.
1698     if (profile) {
1699       first_run::AutoImport(profile, master_prefs_->import_bookmarks_path);
1700     }
1701 
1702     // Note: This can pop-up the first run consent dialog on Linux & Mac.
1703     first_run::DoPostImportTasks(master_prefs_->make_chrome_default_for_user);
1704 
1705     // The first run dialog is modal, and spins a RunLoop, which could receive
1706     // a SIGTERM, and call chrome::AttemptExit(). Exit cleanly in that case.
1707     if (browser_shutdown::IsTryingToQuit())
1708       return content::RESULT_CODE_NORMAL_EXIT;
1709   }
1710 #endif  // !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_CHROMEOS_ASH)
1711 
      ......
     
1782   PreBrowserStart();
1783 
1784   variations::VariationsService* variations_service =
1785       browser_process_->variations_service();
1786   variations_service->PerformPreMainMessageLoopStartup();
1787 
       ......

1817       browser_creator_->Start(*base::CommandLine::ForCurrentProcess(),
1818                               base::FilePath(), profile_info,
1819                               last_opened_profiles);
       .......
1855 
1856   PostBrowserStart();
1857 
     ......
1869 
1870   return result_code_;
1871 }

函数的主题流程如下：

• PreProfileInit()： 初始化profile
• PostProfileInit() : profile 初始化后执行的操作
• browser_creator_->Start() 启动浏览器
• PreBrowserStart() 浏览器启动前工作

我们直接看浏览器的启动。
chrome/browser/ui/startup/startup_browser_creator.cc

bool StartupBrowserCreator::Start(const base::CommandLine& cmd_line,
                                  const base::FilePath& cur_dir,
                                  StartupProfileInfo profile_info,
                                  const Profiles& last_opened_profiles) {
  TRACE_EVENT0("startup", "StartupBrowserCreator::Start");
  SCOPED_UMA_HISTOGRAM_TIMER("Startup.StartupBrowserCreator_Start");
  return ProcessCmdLineImpl(cmd_line, cur_dir,
                            chrome::startup::IsProcessStartup::kYes,
                            profile_info, last_opened_profiles);
}

函数直接调用了ProcessCmdLineImpl函数。
chrome/browser/ui/startup/startup_browser_creator.cc

909 bool StartupBrowserCreator::ProcessCmdLineImpl(
 910     const base::CommandLine& command_line,
 911     const base::FilePath& cur_dir,
 912     chrome::startup::IsProcessStartup process_startup,
 913     StartupProfileInfo profile_info,
 914     const Profiles& last_opened_profiles) {
         ......
1260 
1261   // Launch the browser if the profile is unable to open web apps.
1262   if (!CanOpenWebApp(privacy_safe_profile)) {
         // 不能启动webapp则直接启动chrome浏览器主页
1263     LaunchBrowserForLastProfiles(command_line, cur_dir, process_startup,
1264                                  is_first_run, profile_info,
1265                                  last_opened_profiles);
1266     return true;
1267   }
1268 
1269   // Try a platform app launch.
       // 启动webapp
1270   if (MaybeLaunchExtensionApp(command_line, cur_dir, is_first_run,
1271                               privacy_safe_profile)) {
1272     return true;
1273   }
1274 
       ......
1296 
       //启动webapp失败，则直接启动chrome浏览器主页
1297   LaunchBrowserForLastProfiles(command_line, cur_dir, process_startup,
1298                                is_first_run, profile_info,
1299                                last_opened_profiles);
1300   return true;
1301 }
1302 

我们不关注webapp。所以直接看使用profiles启动浏览器的过程。
chrome/browser/ui/startup/startup_browser_creator.cc

1303 void StartupBrowserCreator::ProcessLastOpenedProfiles(
1304     const base::CommandLine& command_line,
1305     const base::FilePath& cur_dir,
1306     chrome::startup::IsProcessStartup process_startup,
1307     chrome::startup::IsFirstRun is_first_run,
1308     Profile* last_used_profile,
1309     const Profiles& last_opened_profiles) {
1310   base::CommandLine command_line_without_urls(command_line.GetProgram());
1311   for (auto& switch_pair : command_line.GetSwitches()) {
1312     command_line_without_urls.AppendSwitchNative(switch_pair.first,
1313                                                  switch_pair.second);
1314   }
1315 
1316   // Launch the profiles in the order they became active.
1317   for (Profile* profile : last_opened_profiles) {
1318     DCHECK(!profile->IsGuestSession());
1319 
          ......
1333 
1334     // Don't launch additional profiles which would only open a new tab
1335     // page. When restarting after an update, all profiles will reopen last
1336     // open pages.
1337     SessionStartupPref startup_pref =
1338         GetSessionStartupPref(command_line, profile);
1339     if (profile != last_used_profile &&
1340         startup_pref.type == SessionStartupPref::DEFAULT &&
1341         !HasPendingUncleanExit(profile)) {
1342       continue;
1343     }
1344     // Only record a launch mode histogram for |last_used_profile|. Pass a
1345     // null launch_mode_recorder for other profiles.
         // 为每个profile 启动一个浏览器实例。
1346     LaunchBrowser((profile == last_used_profile) ? command_line
1347                                                  : command_line_without_urls,
1348                   profile, cur_dir, process_startup, is_first_run,
1349                   profile == last_used_profile
1350                       ? std::make_unique<OldLaunchModeRecorder>()
1351                       : nullptr);
1352     // We've launched at least one browser.
1353     process_startup = chrome::startup::IsProcessStartup::kNo;
1354   }
1355 
      // 设置活跃的profile
1356 // Set the |last_used_profile| to activate if a browser is launched for at
1357 // least one profile. Otherwise, show UserManager.
1358 // Note that this must be done after all profiles have
1359 // been launched so the observer knows about all profiles to wait before
1360 // activation this one.
1361 #if !BUILDFLAG(IS_CHROMEOS_ASH)
1362   if (process_startup == chrome::startup::IsProcessStartup::kYes) {
1363     ProfilePicker::Show(ProfilePicker::Params::FromEntryPoint(
1364         ProfilePicker::EntryPoint::kOnStartup));
1365   } else  // NOLINT
1366 #endif
1367   {
1368     profile_launch_observer.Get().set_profile_to_activate(last_used_profile);
1369   }
1370 }

在chrome中，使用Profile 代表用户，关联一份用户数据，所以这里对每个Profile 启动一个浏览器实例，启动浏览器实例的函数为LaunchBrowser。 在所有浏览器实例都启动后，要求设置活跃profile，有两种方式，一种是直接设置最后使用的profile为活跃的，或者弹出弹框要求用户选择。 我们只关注浏览器实例的启动过程，所以继续分析LaunchBrowser函数。

652 void StartupBrowserCreator::LaunchBrowser(
 653     const base::CommandLine& command_line,
 654     Profile* profile,
 655     const base::FilePath& cur_dir,
 656     chrome::startup::IsProcessStartup process_startup,
 657     chrome::startup::IsFirstRun is_first_run,
 658     std::unique_ptr<OldLaunchModeRecorder> launch_mode_recorder) {
       .....

 686     StartupBrowserCreatorImpl lwp(cur_dir, command_line, this, is_first_run);
 687     lwp.Launch(profile,
 688                in_synchronous_profile_launch_
 689                    ? chrome::startup::IsProcessStartup::kYes
 690                    : chrome::startup::IsProcessStartup::kNo,
 691                std::move(launch_mode_recorder));
 692   }
 693   in_synchronous_profile_launch_ = false;
 694   profile_launch_observer.Get().AddLaunched(profile);
 695 }

686 行创建StartupBrowserCreatorImpl 函数门用于启动单profile对应的Browser。 687-692行调用StartupBrowserCreatorImpl->launch方法启动浏览器.
chrome/browser/ui/startup/startup_browser_creator_impl.cc

182 void StartupBrowserCreatorImpl::Launch(
183     Profile* profile,
184     chrome::startup::IsProcessStartup process_startup,
185     std::unique_ptr<OldLaunchModeRecorder> launch_mode_recorder) {
186   DCHECK(profile);
187   profile_ = profile;
188 
189   LaunchResult launch_result = DetermineURLsAndLaunch(process_startup);
      ......
224 }

函数调用DetermineURLsAndLaunch 启动浏览器。

53 StartupBrowserCreatorImpl::LaunchResult
354 StartupBrowserCreatorImpl::DetermineURLsAndLaunch(
355     chrome::startup::IsProcessStartup process_startup) {
      ......

      // 确定要启动的tab
422   auto result = DetermineStartupTabs(
423       StartupTabProviderImpl(), process_startup, is_incognito_or_guest,
424       is_post_crash_launch, has_incompatible_applications,
425       promotional_tabs_enabled, welcome_enabled, whats_new_enabled,
426       privacy_sandbox_dialog_required);
427   StartupTabs tabs = std::move(result.tabs);
428 
      .......
      // 启动浏览器，并开tabs
463   Browser* browser = RestoreOrCreateBrowser(
464       tabs, behavior, restore_options, process_startup, is_post_crash_launch);
465 
      ......
469   return result.launch_result;
470 }

422-478行决定打开哪些tabs， 如果参数里面没有url默认情况只打开一个主tab， 如果启动参数里面有一个url或者从崩溃中恢复，可以打开多个tab。我们日常使用chrome是这样的，所以DetermineURLsAndLaunch就不用分析了。 这里主要分析RestoreOrCreateBrowser函数。

653 Browser* StartupBrowserCreatorImpl::RestoreOrCreateBrowser(
654     const StartupTabs& tabs,
655     BrowserOpenBehavior behavior,
656     SessionRestore::BehaviorBitmask restore_options,
657     chrome::startup::IsProcessStartup process_startup,
658     bool is_post_crash_launch) {
659   Browser* browser = nullptr;
      ......
683   browser = OpenTabsInBrowser(
684       browser, process_startup,
685       (tabs.empty()
686            ? StartupTabs({StartupTab(GURL(chrome::kChromeUINewTabURL))})
687            : tabs));
688 
       ......
697   return browser;
698 }

683-659行启动浏览器并打开tabs。

35 Browser* StartupBrowserCreatorImpl::OpenTabsInBrowser(
236     Browser* browser,
237     chrome::startup::IsProcessStartup process_startup,
238     const StartupTabs& tabs) {
239   DCHECK(!tabs.empty());
240 
      ......
246 
247   if (!browser || !browser->is_type_normal()) {
        ......
        // 准备创建参数
256     // Startup browsers are not counted as being created by a user_gesture
257     // because of historical accident, even though the startup browser was
258     // created in response to the user clicking on chrome. There was an
259     // incomplete check on whether a user gesture created a window which looked
260     // at the state of the MessageLoop.
261     Browser::CreateParams params = Browser::CreateParams(profile_, false);
262     params.creation_source = Browser::CreationSource::kStartupCreator;
263 #if BUILDFLAG(IS_LINUX)
264     params.startup_id =
265         command_line_->GetSwitchValueASCII("desktop-startup-id");
266 #endif
267     if (command_line_->HasSwitch(switches::kWindowName)) {
268       params.user_title =
269           command_line_->GetSwitchValueASCII(switches::kWindowName);
270     }
271 
        // 创建浏览器实例
272     browser = Browser::Create(params);
273   }
274 
275   bool first_tab = true;
276   custom_handlers::ProtocolHandlerRegistry* registry =
277       profile_ ? ProtocolHandlerRegistryFactory::GetForBrowserContext(profile_)
278                : nullptr;
279   for (auto& tab : tabs) {
        .......
        // 准备启动tab参数
306     NavigateParams params(browser, tab.url, ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
307     params.disposition = first_tab ? WindowOpenDisposition::NEW_FOREGROUND_TAB
308                                    : WindowOpenDisposition::NEW_BACKGROUND_TAB;
309     params.tabstrip_add_types = add_types;
        ......
        // 导航到tab
319     Navigate(&params);
320     first_tab = false;
321   }
       // 设置活跃tab
322   if (!browser->tab_strip_model()->GetActiveWebContents()) {
323     // TODO(sky): this is a work around for 110909. Figure out why it's needed.
324     if (!browser->tab_strip_model()->count())
325       chrome::AddTabAt(browser, GURL(), -1, true);
326     else
327       browser->tab_strip_model()->ActivateTabAt(0);
328   }
329 
      .....
      // 显示window
348   browser->window()->Show();
349 
350   return browser;
351 }

247-273行准备browser创建的参数， 并创建browser。
279-321行 通过Navigate创建tab。
348行 一切准备就绪，显示浏览器页面。

我们先来浏览器实例的创建，导航的过程会比较复杂，也是浏览器的核心功能，会单独分析。
chrome/browser/ui/browser.cc

// static
Browser* Browser::Create(const CreateParams& params) {
 ......
  return new Browser(params);
}

函数只是创建了Browser 实例。

 458 Browser::Browser(const CreateParams& params)
 459     : create_params_(params),
 460       type_(params.type),
 461       profile_(params.profile),
 462       window_(nullptr),
 463       tab_strip_model_delegate_(
 464           std::make_unique<chrome::BrowserTabStripModelDelegate>(this)),
           // tab标签模型
 465       tab_strip_model_(std::make_unique<TabStripModel>(
 466           tab_strip_model_delegate_.get(),
 467           params.profile,
 468           params.are_tab_groups_enabled ? TabGroupModelFactory::GetInstance()
 469                                         : nullptr)),
           // tab menu 模型
 470       tab_menu_model_delegate_(
 471           std::make_unique<chrome::BrowserTabMenuModelDelegate>(this)),
 472       app_name_(params.app_name),
 473       is_trusted_source_(params.trusted_source),
 474       session_id_(SessionID::NewUnique()),
 475       omit_from_session_restore_(params.omit_from_session_restore),
 476       should_trigger_session_restore_(params.should_trigger_session_restore),
 477       cancel_download_confirmation_state_(NOT_PROMPTED),
 478       override_bounds_(params.initial_bounds),
 479       initial_show_state_(params.initial_show_state),
 480       initial_workspace_(params.initial_workspace),
 481       initial_visible_on_all_workspaces_state_(
 482           params.initial_visible_on_all_workspaces_state),
 483       creation_source_(params.creation_source),
 484       unload_controller_(this),
 485       content_setting_bubble_model_delegate_(
 486           new BrowserContentSettingBubbleModelDelegate(this)),
 487       location_bar_model_delegate_(new BrowserLocationBarModelDelegate(this)),
 488       live_tab_context_(new BrowserLiveTabContext(this)),
 489       synced_window_delegate_(new BrowserSyncedWindowDelegate(this)),
 490       app_controller_(web_app::MaybeCreateAppBrowserController(this)),
 491       bookmark_bar_state_(BookmarkBar::HIDDEN),
 492       command_controller_(new chrome::BrowserCommandController(this)),
 493       window_has_shown_(false),
 494       user_title_(params.user_title),
 495       signin_view_controller_(this),
 496       breadcrumb_manager_browser_agent_(
 497           breadcrumbs::IsEnabled()
 498               ? std::make_unique<BreadcrumbManagerBrowserAgent>(this)
 499               : nullptr)
 500 #if BUILDFLAG(ENABLE_EXTENSIONS)
 501       ,
 502       extension_browser_window_helper_(
 503           std::make_unique<extensions::ExtensionBrowserWindowHelper>(this))
 504 #endif
 505 {
 506   if (!profile_->IsOffTheRecord()) {
 507     profile_keep_alive_ = std::make_unique<ScopedProfileKeepAlive>(
 508         params.profile->GetOriginalProfile(),
 509         ProfileKeepAliveOrigin::kBrowserWindow);
 510   }
 511 
 512   tab_strip_model_->AddObserver(this);
 513 
       // 导航栏模型
 514   location_bar_model_ = std::make_unique<LocationBarModelImpl>(
 515       location_bar_model_delegate_.get(), content::kMaxURLDisplayChars);
       .......
       // 书签状态
 533   UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_INIT);
 534 
 535   ProfileMetrics::LogProfileLaunch(profile_);
 536 
 537   if (params.skip_window_init_for_testing)
 538     return;
 539 
       // 创建浏览器窗口
 540   window_ = params.window ? params.window.get()
 541                           : CreateBrowserWindow(std::unique_ptr<Browser>(this),
 542                                                 params.user_gesture,
 543                                                 params.in_tab_dragging);
 544 
       ......
 552   SessionServiceBase* service =
 553       GetAppropriateSessionServiceForSessionRestore(this);
 554 
 555   if (service)
 556     service->WindowOpened(this);
 557 
       .....
       // 添加到浏览器列表。（可以打开多个窗口）
 567   BrowserList::AddBrowser(this);
 568 }

函数初始化了tab标签模型、menu模型、导航栏模型、和书签条。 并在540-544行创建浏览器窗口。 我们接下来分析窗口的创建。
chrome/browser/ui/browser.cc

BrowserWindow* CreateBrowserWindow(std::unique_ptr<Browser> browser,
                                   bool user_gesture,
                                   bool in_tab_dragging) {
  return BrowserWindow::CreateBrowserWindow(std::move(browser), user_gesture,
                                            in_tab_dragging);
}																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					

函数调用CreateBrowserWindow创建BrowserWindow。
chrome/browser/ui/views/frame/browser_window_factory.cc

35 // static
 36 BrowserWindow* BrowserWindow::CreateBrowserWindow(
 37     std::unique_ptr<Browser> browser,
 38     bool user_gesture,
 39     bool in_tab_dragging) {
      ......
 47   // Create the view and the frame. The frame will attach itself via the view
 48   // so we don't need to do anything with the pointer.
 49   BrowserView* view = new BrowserView(std::move(browser));
 50   BrowserFrame* browser_frame = nullptr;
       ......
 58   if (!browser_frame)
 59     browser_frame = new BrowserFrame(view);
 60   if (in_tab_dragging)
 61     browser_frame->SetTabDragKind(TabDragKind::kAllTabs);
 62   browser_frame->InitBrowserFrame();
 63 
      ......
 86 
 87   return view;
 88 }

函数49行创建BrowserView， BrowserView 用于描述供浏览器窗口的内容，包括标签栏（TabStrip）、工具栏、下载架（download shelves）、内容区域等。50-59行创建BrowserFrame，BrowserFrame是真正负责ui管理的类。

我们先看BrowserView的创建。

796 BrowserView::BrowserView(std::unique_ptr<Browser> browser)
 797     : views::ClientView(nullptr, nullptr),
 798       browser_(std::move(browser)),
 799       accessibility_mode_observer_(
 800           std::make_unique<AccessibilityModeObserver>(this)) {
       // 设置显示的icon
 801   SetShowIcon(
 802       ::ShouldShowWindowIcon(browser_.get(), AppUsesWindowControlsOverlay()));
 803 
      ......
       // 创建顶部容器view
 865   top_container_ = AddChildView(std::make_unique<TopContainerView>(this));
 866 
       .....
       // 向顶部容器增加tab栏view
 876   tab_strip_region_view_ = top_container_->AddChildView(
 877       std::make_unique<TabStripRegionView>(std::move(tabstrip)));
 878 
 879   ColorProviderBrowserHelper::CreateForBrowser(browser_.get());
 880 
       // 设置开发者调试窗口
 881   // Create WebViews early so |webui_tab_strip_| can observe their size.
 882   auto devtools_web_view =
 883       std::make_unique<views::WebView>(browser_->profile());
 884   devtools_web_view->SetID(VIEW_ID_DEV_TOOLS_DOCKED);
 885   devtools_web_view->SetVisible(false);
 886 
      // 创建网页内容窗口
887   auto contents_web_view =
 888       std::make_unique<ContentsWebView>(browser_->profile());
 889   contents_web_view->SetID(VIEW_ID_TAB_CONTAINER);
 890 
       // 调试窗口添加到内容窗口中
 891   auto contents_container = std::make_unique<views::View>();
 892   devtools_web_view_ =
 893       contents_container->AddChildView(std::move(devtools_web_view));
        // 添加网页内容窗口到内容窗口
 894   contents_web_view_ =
 895       contents_container->AddChildView(std::move(contents_web_view));
 896   contents_web_view_->set_is_primary_web_contents_for_window(true);
       // 设置布局管理器
 897   contents_container->SetLayoutManager(std::make_unique<ContentsLayoutManager>(
 898       devtools_web_view_, contents_web_view_));
 899 
       // 添加工具栏到顶部窗口
 900   toolbar_ = top_container_->AddChildView(
 901       std::make_unique<ToolbarView>(browser_.get(), this));
 902 
       // 添加内容分割线，用于分割顶部栏和内容栏
 903   contents_separator_ =
 904       top_container_->AddChildView(std::make_unique<ContentsSeparator>());
 905 
 906   web_contents_close_handler_ =
 907       std::make_unique<WebContentsCloseHandler>(contents_web_view_);
 908 
       // 添加内容容器到当前顶部布局
 909   contents_container_ = AddChildView(std::move(contents_container));
 910   set_contents_view(contents_container_);
 911 
       // 添加分割线
 912   right_aligned_side_panel_separator_ =
 913       AddChildView(std::make_unique<ContentsSeparator>());
 914 
 915   const bool is_right_aligned = GetProfile()->GetPrefs()->GetBoolean(
      ......
 954 }

BrowserView的构造主要初始化窗口内容和布局。

我们再看BrowserFrame的 构造。
chrome/browser/ui/views/frame/browser_frame.cc

BrowserFrame::BrowserFrame(BrowserView* browser_view)
    : native_browser_frame_(nullptr),
      root_view_(nullptr),
      browser_frame_view_(nullptr),
      browser_view_(browser_view) {
  browser_view_->set_frame(this);
  set_is_secondary_widget(false);
  // Don't focus anything on creation, selecting a tab will set the focus.
  set_focus_on_creation(false);
}

非常简单。 再来看一下BrowserFrame的初始化，InitBrowserFrame函数。
chrome/browser/ui/views/frame/browser_view.h

 91 void BrowserFrame::InitBrowserFrame() {
 92   native_browser_frame_ =
 93       NativeBrowserFrameFactory::CreateNativeBrowserFrame(this, browser_view_);
 94   views::Widget::InitParams params = native_browser_frame_->GetWidgetParams();
 95   params.name = "BrowserFrame";
 96   params.delegate = browser_view_;
 97   params.headless_mode = headless::IsHeadlessMode();
 98 
      .....
139 
140   Init(std::move(params));
141   SelectNativeTheme();
142 
143   if (!native_browser_frame_->UsesNativeSystemMenu()) {
144     DCHECK(non_client_view());
145     non_client_view()->set_context_menu_controller(this);
146   }
147 }

函数创建NativeBrowserFrame,也就是和本地平台相关的Frame。然后调用Init函数进行初始化。 141行选择本地主题。 143-146行 设置menu。NativeBrowserFrame 实际上创建的是 DesktopBrowserFrameAuraLinux。我们直接看初始化过程Init。Widget 是NativeBrowserFrame的父类， Init函数是Widget实现的。

 345 void Widget::Init(InitParams params) {
       // 创建根View
 434   root_view_.reset(CreateRootView());
 435 
 436   // Copy the elements of params that will be used after it is moved.
 437   const InitParams::Type type = params.type;
 438   const gfx::Rect bounds = params.bounds;
 439   const ui::WindowShowState show_state = params.show_state;
 440   WidgetDelegate* delegate = params.delegate;
 441   
       // 初始化Widget
 442   native_widget_->InitNativeWidget(std::move(params));
 443   if (type == InitParams::TYPE_MENU)
 444     is_mouse_button_pressed_ = native_widget_->IsMouseButtonDown();
 445   if (RequiresNonClientView(type)) {
         // 设置内容视图
 446     non_client_view_ =
 447         new NonClientView(widget_delegate_->CreateClientView(this));
 448     non_client_view_->SetFrameView(CreateNonClientFrameView());
 449     non_client_view_->SetOverlayView(widget_delegate_->CreateOverlayView());
 450 
 451     // Bypass the Layout() that happens in Widget::SetContentsView(). Layout()
 452     // will occur after setting the initial bounds below. The RootView's size is
 453     // not valid until that happens.
 454     root_view_->SetContentsView(non_client_view_);
 455 
 456     // Initialize the window's icon and title before setting the window's
 457     // initial bounds; the frame view's preferred height may depend on the
 458     // presence of an icon or a title.
         // 更新icon、title等
 459     UpdateWindowIcon();
 460     UpdateWindowTitle();
 461     non_client_view_->ResetWindowControls();
 462     SetInitialBounds(bounds);
 463 
 464     // Perform the initial layout. This handles the case where the size might
 465     // not actually change when setting the initial bounds. If it did, child
 466     // views won't have a dirty Layout state, so won't do any work.
         // 执行布局
 467     root_view_->Layout();
 468 
 469     if (show_state == ui::SHOW_STATE_MAXIMIZED) {
 470       Maximize();
 471     } else if (show_state == ui::SHOW_STATE_MINIMIZED) {
 472       Minimize();
 473       saved_show_state_ = ui::SHOW_STATE_MINIMIZED;
 474     }
 475   } else if (delegate) {
 476     SetContentsView(delegate->TransferOwnershipOfContentsView());
 477     SetInitialBoundsForFramelessWindow(bounds);
 478   }
 479 
       ......
 494 }

函数创建RootView， 初始化widget， 并设置内容视图， 然后更新icon和ttitle。 最后执行布局。
我们先看RootView的创建。

internal::RootView* Widget::CreateRootView() {
  return new internal::RootView(this);
}
RootView::RootView(Widget* widget)
    : widget_(widget),
      pre_dispatch_handler_(
          std::make_unique<internal::PreEventDispatchHandler>(this)),
      post_dispatch_handler_(
          std::make_unique<internal::PostEventDispatchHandler>()) {
  AddPostTargetHandler(post_dispatch_handler_.get());
  SetEventTargeter(
      std::unique_ptr<ViewTargeter>(new RootViewTargeter(this, this)));
}

函数实现比较简单。 不不要展开分析。 再来看看Widget的初始化. native_widget_ 指向DesktopBrowserFrameAuraLinux， DesktopBrowserFrameAuraLinux的父类是DesktopBrowserFrameAura， DesktopBrowserFrameAura 实现了InitNativeWidget。 我们来看一下它的实现。
chrome/browser/ui/views/frame/desktop_browser_frame_aura.cc

548 
 549 // DesktopNativeWidgetAura, internal::NativeWidgetPrivate implementation:
 550 void DesktopNativeWidgetAura::InitNativeWidget(Widget::InitParams params) {
 551   ownership_ = params.ownership;
 552   widget_type_ = params.type;
 553   name_ = params.name;
 554 
       ......

       // 初始化桌面窗口树
 576   desktop_window_tree_host_->Init(params);
 577 
       // 增加子Window
 578   host_->window()->AddChild(content_window_);
 579   host_->window()->SetProperty(kDesktopNativeWidgetAuraKey, this);
 580 
 581   host_->window()->AddObserver(new RootWindowDestructionObserver(this));
 582 
      ......
 626 
 627   host_->window()->SetName(params.name);
 628   content_window_->SetName("DesktopNativeWidgetAura - content window");
 629   desktop_window_tree_host_->OnNativeWidgetCreated(params);
 630 
       ......
       // 事件处理
 683   event_client_ = std::make_unique<DesktopEventClient>();
 684   aura::client::SetEventClient(host_->window(), event_client_.get());
 685 
 686   shadow_controller_ = std::make_unique<wm::ShadowController>(
 687       wm::GetActivationClient(host_->window()), nullptr);
 688 
 689   OnSizeConstraintsChanged();
 690 
 691   window_reorderer_ = std::make_unique<WindowReorderer>(
 692       content_window_, GetWidget()->GetRootView());
 693 }

576行初始化桌面window 树。 578行将内容串口添加到window树中 683 创建事件处理相关结构。
我们继续看desktop_window_tree_host_的初始化。desktop_window_tree_host_是BrowserDesktopWindowTreeHostLinux的实例子。
chrome/browser/ui/views/frame/browser_desktop_window_tree_host_linux.cc

void BrowserDesktopWindowTreeHostLinux::Init(
    const views::Widget::InitParams& params) {
  DesktopWindowTreeHostLinux::Init(std::move(params));
......
}

它调用了父类DesktopWindowTreeHostLinux的Init方法

void DesktopWindowTreeHostLinux::Init(const Widget::InitParams& params) {
  DesktopWindowTreeHostPlatform::Init(params);
 ......
}

DesktopWindowTreeHostLinux又调用了父类DesktopWindowTreeHostPlatform的Init方法。
ui/views/widget/desktop_aura/desktop_window_tree_host_platform.cc

  258 void DesktopWindowTreeHostPlatform::Init(const Widget::InitParams& params) {
       .....
 293 
       // 创建平台window
 294   CreateAndSetPlatformWindow(std::move(properties));
 295 
 296   // Disable compositing on tooltips as a workaround for
 297   // https://crbug.com/442111.
       // 创建合成器
 298   CreateCompositor(params.force_software_compositing ||
 299                    params.type == Widget::InitParams::TYPE_TOOLTIP);
 300 
 301   WindowTreeHost::OnAcceleratedWidgetAvailable();
       // 初始化
 302   InitHost();
       // 显示widnow
 303   window()->Show();
 304 }

我们看一下平台窗口的创建。最终图像都要渲染在平台窗口。
ui/aura/window_tree_host_platform.cc

void WindowTreeHostPlatform::CreateAndSetPlatformWindow(
    ui::PlatformWindowInitProperties properties) {
  // Cache initial size used to create |platform_window_| so that it does not
  // end up propagating unneeded bounds change event when it is first notified
  // through OnBoundsChanged, which may lead to unneeded re-layouts, etc.
  size_in_pixels_ = properties.bounds.size();
#if BUILDFLAG(IS_OZONE)
  platform_window_ = ui::OzonePlatform::GetInstance()->CreatePlatformWindow(
      this, std::move(properties));
......
}

Ozone 是chrome用于实现gui的库， 它抽象了各平台gui管理给上层使用。在linux平台上OzonePlatform为OzonePlatformX11。
ui/ozone/platform/x11/ozone_platform_x11.cc

  std::unique_ptr<PlatformWindow> CreatePlatformWindow(
      PlatformWindowDelegate* delegate,
      PlatformWindowInitProperties properties) override {
    auto window = std::make_unique<X11Window>(delegate);
    window->Initialize(std::move(properties));
    return std::move(window);
  }

这里创建了X11Window，并执行了初始化， 我们先来看下X11Window的创建。
ui/ozone/platform/x11/x11_window.cc

X11Window::X11Window(PlatformWindowDelegate* platform_window_delegate)
    : platform_window_delegate_(platform_window_delegate),
      connection_(x11::Connection::Get()),
      x_root_window_(GetX11RootWindow()) {
    ......
}

再来看一下X11Window的初始化过程我们就不深入分析了，它主要请求创建X-Server创建window。
好了我们下面看一下怎么通过layout 更新布局
ui/views/view.cc

void View::Layout() {
  needs_layout_ = false;

  // If we have a layout manager, let it handle the layout for us.
  if (HasLayoutManager())
    GetLayoutManager()->Layout(this);

  // Make sure to propagate the Layout() call to any children that haven't
  // received it yet through the layout manager and need to be laid out. This
  // is needed for the case when the child requires a layout but its bounds
  // weren't changed by the layout manager. If there is no layout manager, we
  // just propagate the Layout() call down the hierarchy, so whoever receives
  // the call can take appropriate action.
  internal::ScopedChildrenLock lock(this);
  for (auto* child : children_) {
    if (child->needs_layout_ || !HasLayoutManager()) {
      TRACE_EVENT1("views", "View::LayoutChildren", "class",
                   child->GetClassName());
      child->needs_layout_ = false;
      child->Layout();
    }
  }
}

函数比较简单，先调用LyoutManager->Layout() 方法，再调用每一个子View的Layout方法， layout方法主要确定view的大小位置，这里就不具体分析了。 我们继续看view是怎么绘制的。 回到StartupBrowserCreatorImpl::OpenTabsInBrowser()函数，最后一行是调用browser->window()->Show();
chrome/browser/ui/views/frame/browser_view.cc

1226 void BrowserView::Show() {
       ......
1248   frame_->Show();
1249 
1250   browser()->OnWindowDidShow();
1251 
       ......
1268 }

这里调用了frame->Show() 方法。
ui/views/widget/widget.cc

795 void Widget::Show() {
 796   if (!native_widget_)
 797     return;
 798   const ui::Layer* layer = GetLayer();
 799   TRACE_EVENT1("views", "Widget::Show", "layer",
 800                layer ? layer->name() : "none");
 801   ui::WindowShowState preferred_show_state =
 802       CanActivate() ? ui::SHOW_STATE_NORMAL : ui::SHOW_STATE_INACTIVE;
 803   if (non_client_view_) {
 804     // While initializing, the kiosk mode will go to full screen before the
 805     // widget gets shown. In that case we stay in full screen mode, regardless
 806     // of the |saved_show_state_| member.
 807     if (saved_show_state_ == ui::SHOW_STATE_MAXIMIZED &&
 808         !initial_restored_bounds_.IsEmpty() && !IsFullscreen()) {
              .....
 810     } else {
 811       native_widget_->Show(
 812           IsFullscreen() ? ui::SHOW_STATE_FULLSCREEN : saved_show_state_,
 813           gfx::Rect());
 814     }
 815     // |saved_show_state_| only applies the first time the window is shown.
 816     // If we don't reset the value the window may be shown maximized every time
 817     // it is subsequently shown after being hidden.
 818     saved_show_state_ = preferred_show_state;
 819   } else {
 820     native_widget_->Show(preferred_show_state, gfx::Rect());
 821   }
 822 
 823   HandleShowRequested();
 824 }

函数调用native_widget_->Show方法去显示页面.
ui/views/widget/desktop_aura/desktop_native_widget_aura.cc

void DesktopNativeWidgetAura::Show(ui::WindowShowState show_state,
                                   const gfx::Rect& restore_bounds) {
  if (!desktop_window_tree_host_)
    return;

  desktop_window_tree_host_->Show(show_state, restore_bounds);
}

native_widget_->Show 方法调用desktop_window_tree_host_->Show 方法。desktop_window_tree_host_类型为BrowserDesktopWindowTreeHostLinux， Show方法如下：
chrome/browser/ui/views/frame/browser_desktop_window_tree_host_linux.cc

void BrowserDesktopWindowTreeHostLinux::Show(ui::WindowShowState show_state,
                                             const gfx::Rect& restore_bounds) {
  DesktopWindowTreeHostLinux::Show(show_state, restore_bounds);

  ......
}

函数调用父类DesktopWindowTreeHostLinux::Show 方法。
ui/views/widget/desktop_aura/desktop_window_tree_host_platform.cc

413 void DesktopWindowTreeHostPlatform::Show(ui::WindowShowState show_state,
 414                                          const gfx::Rect& restore_bounds) {
 415   if (compositor())
 416     SetVisible(true);
 417 
       // 请求x-server 显示window
 418   platform_window()->Show(DetermineInactivity(show_state));
 419 
       ......
 439   if (native_widget_delegate_->CanActivate()) {
 440     if (show_state != ui::SHOW_STATE_INACTIVE)
           // 激活窗口
 441       Activate();
 442 
 443     // SetInitialFocus() should be always be called, even for
 444     // SHOW_STATE_INACTIVE. If the window has to stay inactive, the method will
 445     // do the right thing.
 446     // Activate() might fail if the window is non-activatable. In this case, we
 447     // should pass SHOW_STATE_INACTIVE to SetInitialFocus() to stop the initial
 448     // focused view from getting focused. See https://crbug.com/515594 for
 449     // example.
 450     native_widget_delegate_->SetInitialFocus(
 451         IsActive() ? show_state : ui::SHOW_STATE_INACTIVE);
 452   }
 453 
       // 显示内容
 454   GetContentWindow()->Show();
 455 }

函数先请求x-server 显示窗口，然后激活窗口， 最后调用GetContentWindow()->Show() 绘制窗口内容。
ui/aura/window.cc

void Window::Show() {
   ......
  SetVisibleInternal(true);
}

Window::Show 方法调用SetVisibleInternal

 985 void Window::SetVisibleInternal(bool visible) {
       ......
       // 请求绘制
1001   SchedulePaint();
       ......
1009 }

函数调用SchedulePaint() 请求绘制

void Window::SchedulePaint() {
  SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
}

void Window::SchedulePaintInRect(const gfx::Rect& rect) {
  layer()->SchedulePaint(rect);
}

函数调用layer()->SchedulePaint() 方法完成绘制。我们查看SchedulePaint方法。
ui/compositor/layer.cc

bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
   .....
  if (!content_layer_ || !deferred_paint_requests_)
    ScheduleDraw();
  return true;
}

如果需要绘制，调用ScheduleDraw 方法

void Layer::ScheduleDraw() {
  // Do not schedule draw if this layer does not contribute the content.
  if (type_ == LAYER_NOT_DRAWN && children_.size() == 0) {
    return;
  }
  Compositor* compositor = GetCompositor();
  if (compositor) {
    compositor->ScheduleDraw();
  }
}

调用compositor->ScheduleDraw() 进行绘制。

void Compositor::ScheduleDraw() {
  host_->SetNeedsCommit();
}
void LayerTreeHost::SetNeedsCommit() {
  DCHECK(IsMainThread());
  proxy_->SetNeedsCommit();
......
}

void SingleThreadProxy::SetNeedsCommit() {
  DCHECK(task_runner_provider_->IsMainThread());
   ......
  if (scheduler_on_impl_thread_)
    scheduler_on_impl_thread_->SetNeedsBeginMainFrame();
}
void Scheduler::SetNeedsBeginMainFrame() {
  state_machine_.SetNeedsBeginMainFrame();
  ProcessScheduledActions();
}

函数最终调用到Scheduler::SetNeedsBeginMainFrame() 方法，设置了状态机状态， 然后调用ProcessScheduledActions()处理新状态。
Scheduler类是ui渲染的调度器。
关于schedule 调度器比较复杂，这里不进行深入分析。

void Scheduler::ProcessScheduledActions() {
  ......
  do {
    action = state_machine_.NextAction();
    TRACE_EVENT(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                "SchedulerStateMachine", [this](perfetto::EventContext ctx) {
                  this->AsProtozeroInto(ctx,
                                        ctx.event()->set_cc_scheduler_state());
                });
    base::AutoReset<SchedulerStateMachine::Action> mark_inside_action(
        &inside_action_, action);
    switch (action) {
      case SchedulerStateMachine::Action::NONE:
        break;
      case SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME:
        compositor_timing_history_->WillBeginMainFrame(begin_main_frame_args_);
        compositor_frame_reporting_controller_->WillBeginMainFrame(
            begin_main_frame_args_);
        state_machine_.WillSendBeginMainFrame();
        client_->ScheduledActionSendBeginMainFrame(begin_main_frame_args_);
        last_dispatched_begin_main_frame_args_ = begin_main_frame_args_;
        break;
      case SchedulerStateMachine::Action::
       
......
}

SEND_BEGIN_MAIN_FRAME 这个action 用于请求新的一帧绘制，client_->ScheduledActionSendBeginMainFrame(begin_main_frame_args_) 函数调度绘制。
cc/trees/single_thread_proxy.cc

 965 void SingleThreadProxy::ScheduledActionSendBeginMainFrame(
 966     const viz::BeginFrameArgs& begin_frame_args) {
 967   DebugScopedSetImplThread impl(task_runner_provider_);
      ......
 980 
 981   host_impl_->WillSendBeginMainFrame();
 982   task_runner_provider_->MainThreadTaskRunner()->PostTask(
 983       FROM_HERE, base::BindOnce(&SingleThreadProxy::BeginMainFrame,
 984                                 weak_factory_.GetWeakPtr(), begin_frame_args));
 985   host_impl_->DidSendBeginMainFrame(begin_frame_args);
 986 }

异步调用BeginMainFrame

1010 void SingleThreadProxy::BeginMainFrame(
       ......
       // 新的一帧开始之前的准备工作
1062   DoBeginMainFrame(begin_frame_args);
1063 
1064   // New commits requested inside UpdateLayers should be respected.
1065   commit_requested_ = false;
1066 
      .....
      // 执行绘制
1081   DoPainting(begin_frame_args);
1082   layer_tree_host_->RecordEndOfFrameMetrics(frame_start_time,
1083                                             /* trackers */ 0u);
1084 }

我们看DoPainting 绘制页面。

void SingleThreadProxy::DoPainting(const viz::BeginFrameArgs& commit_args) {
  layer_tree_host_->UpdateLayers();
  ......
}

函数调用layer_tree_host->UpdateLayers()

bool LayerTreeHost::UpdateLayers() {
  ......
  client_->WillUpdateLayers();
  bool result = DoUpdateLayers();
  client_->DidUpdateLayers();
  micro_benchmark_controller_.DidUpdateLayers();

.......
  return result;
}

DoUpdateLayers更新layer。
cc/trees/layer_tree_host.cc

bool LayerTreeHost::DoUpdateLayers() {
  ......
  LayerList update_layer_list;
  draw_property_utils::FindLayersThatNeedUpdates(this, &update_layer_list);
  // 执行绘制
  bool did_paint_content = PaintContent(update_layer_list);
  return did_paint_content;
}

调用PainContent绘制。

bool LayerTreeHost::PaintContent(const LayerList& update_layer_list) {
  DCHECK(IsMainThread());
  base::AutoReset<bool> painting(&in_paint_layer_contents_, true);
  bool did_paint_content = false;
  for (const auto& layer : update_layer_list) {
    did_paint_content |= layer->Update();
  }
  return did_paint_content;
}

绘制没一个Layer。
cc/layers/picture_layer.cc

130 bool PictureLayer::Update() {
      ......
159   if (updated) {
160     {
161       auto old_display_list = std::move(picture_layer_inputs_.display_list);
          //绘制内容到displayList
162       picture_layer_inputs_.display_list =
163           picture_layer_inputs_.client->PaintContentsToDisplayList();
164       if (old_display_list &&
165           picture_layer_inputs_.display_list
166               ->NeedsAdditionalInvalidationForLCDText(*old_display_list)) {
167         last_updated_invalidation_.Write(*this) = gfx::Rect(bounds());
168       }
169     }
170 
        .....
188     recording_source->UpdateDisplayItemList(
189         picture_layer_inputs_.display_list,
190         layer_tree_host()->recording_scale_factor());
191 
192     SetNeedsPushProperties();
193     IncreasePaintCount();
194   } else {
195     // If this invalidation did not affect the recording source, then it can be
196     // cleared as an optimization.
197     last_updated_invalidation_.Write(*this).Clear();
198   }
199 
200   return updated;
201 }

162-163行更新displaylist。
ui/compositor/layer.cc

1433 scoped_refptr<cc::DisplayItemList> Layer::PaintContentsToDisplayList() {
1434   TRACE_EVENT1("ui", "Layer::PaintContentsToDisplayList", "name", name_);
1435   gfx::Rect local_bounds(bounds().size());
1436   gfx::Rect invalidation(
1437       gfx::IntersectRects(paint_region_.bounds(), local_bounds));
1438   paint_region_.Clear();
1439   auto display_list = base::MakeRefCounted<cc::DisplayItemList>();
1440   if (delegate_) {
1441     delegate_->OnPaintLayer(PaintContext(display_list.get(),
1442                                          device_scale_factor_, invalidation,
1443                                          GetCompositor()->is_pixel_canvas()));
1444   }
1445   display_list->Finalize();
1446   // TODO(domlaskowski): Move mirror invalidation to Layer::SchedulePaint.
1447   for (const auto& mirror : mirrors_)
1448     mirror->dest()->SchedulePaint(invalidation);
1449   return display_list;
1450 }

1441 行执行真正的绘制
ui/aura/window.cc

void Window::OnPaintLayer(const ui::PaintContext& context) {
  Paint(context);
}

void Window::Paint(const ui::PaintContext& context) {
  if (delegate_)
    delegate_->OnPaint(context);
}

最终调用到Widget绘制
ui/views/widget/desktop_aura/desktop_native_widget_aura.cc

void DesktopNativeWidgetAura::OnPaint(const ui::PaintContext& context) {
  if (native_widget_delegate_) {
    desktop_window_tree_host_->UpdateWindowShapeIfNeeded(context);
    native_widget_delegate_->OnNativeWidgetPaint(context);
  }
}

调用到Widget::OnNativeWidgetPaint
ui/views/widget/widget.cc

void Widget::OnNativeWidgetPaint(const ui::PaintContext& context) {
  // On Linux Aura, we can get here during Init() because of the
  // SetInitialBounds call.
  if (!native_widget_initialized_)
    return;
  GetRootView()->PaintFromPaintRoot(context);
}

到用到rootview的PaintFromPaintRoot方法，表示从根节点开始绘制
ui/views/view.cc

void View::PaintFromPaintRoot(const ui::PaintContext& parent_context) {
  PaintInfo paint_info = PaintInfo::CreateRootPaintInfo(
      parent_context, layer() ? layer()->size() : size());
  Paint(paint_info);
   ......
}

查看Paint方法。

void View::Paint(const PaintInfo& parent_paint_info) {
  CHECK_EQ(life_cycle_state_, LifeCycleState::kAlive);

  if (!ShouldPaint())
    return;

 .....
  ui::ClipRecorder clip_recorder(parent_paint_info.context());
  if (!layer()) {
    ......
    OnPaint(canvas);
  }

  CHECK_EQ(life_cycle_state_, LifeCycleState::kAlive);

  // View::Paint() recursion over the subtree.
  PaintChildren(paint_info);
}

函数先调用OnPaint绘制自身，再调用PaintChildren 绘制子view。

void View::OnPaint(gfx::Canvas* canvas) {
  TRACE_EVENT1("views", "View::OnPaint", "class", GetClassName());
  OnPaintBackground(canvas);
  OnPaintBorder(canvas);
}

对于普通view， OnPaint绘制背景和边框即可。

void View::PaintChildren(const PaintInfo& paint_info) {
  TRACE_EVENT1("views", "View::PaintChildren", "class", GetClassName());
  RecursivePaintHelper(&View::Paint, paint_info);
}

绘制子view调用RecursivePaintHelper 方法绘制。

void View::RecursivePaintHelper(void (View::*func)(const PaintInfo&),
                                const PaintInfo& info) {
  View::Views children = GetChildrenInZOrder();
  DCHECK_EQ(children_.size(), children.size());
  for (auto* child : children) {
    if (!child->layer())
      (child->*func)(info);
  }
}

按照zorder 绘制子view。