首页 文章 精选 留言 我的

Android WebView启动Chromium渲染引擎的过程分析

2016-12-05 617

 首先感谢罗升阳的分享，原文链接http://blog.csdn.net/Luoshengyang/article/details/53237189

  Android WebView加载了Chromium动态库之后，就可以启动Chromium渲染引擎了。Chromium渲染引擎由Browser、Render和GPU三端组成。其中，Browser端负责将网页UI合成在屏幕上，Render端负责加载网页的URL和渲染网页的UI，GPU端负责执行Browser端和Render端请求的GPU命令。本文接下来详细分析Chromium渲染引擎三端的启动过程。

老罗的新浪微博：http://weibo.com/shengyangluo，欢迎关注！

       Android WebView使用了单进程架构的Chromium来加载和渲染网页，因此它的Browser端、Render端和GPU端都不是以进程的形式存在的，而是以线程的形式存在。其中，Browser端实现在App的UI线程中，Render端实现在一个独立的线程中，而GPU端实现在App的Render Thread中。注意，这是针对Android 5.0及以上版本的。Android在4.4版本引入基于Chromium实现的WebView，那时候GPU端与Browser一样，都是实现在App的UI线程中。接下来我们只讨论Android WebView在Android 5.0及以上版本的实现。

       Android WebView启动Chromium渲染引擎三端的过程如图1所示：


图1 Android WebView启动Chromium渲染引擎的过程

       从前面Android WebView加载Chromium动态库的过程分析一文可以知道，当我们在App的UI中嵌入一个WebView时，WebView会在内部创建一个类型为WebViewChromium的Provider。Android WebView就是通过这个Provider来启动和使用Chromium渲染引擎的。

       Chromium里面有一个android_webview模块。这个模块提供了两个类AwBrowserProcess和AwContents，分别用来封装Chromium的Content层提供的两个接口类BrowserStartupController和ContentViewCore，它们分别用来启动Chromium的Browser端和Render端。

       Android WebView启动Chromium的Browser端，实际上就是在App的UI线程创建一个Browser Main Loop。Chromium以后需要请求Browser端执行某一个操作时，就可以向这个Browser Main Loop发送一个Task。这个Task最终会在App进程的UI线程中调度执行。

       Android WebView启动Chromium的Render端，实际上就是在当前的App进程中创建一个线程。以后网页就由这个线程负责加载和渲染。这个线程称为In-Process Renderer Thread。

       由于Chromium的GPU端实现在App的Render Thread中，这个Render Thread是由App负责启动的，因此Chromium无需启动它。不过，Chromium里的android_webview模块会启动一个DeferredGpuCommandService服务。当Chromium的Browser端和Render端需要执行GPU操作时，就会向DeferredGpuCommandService服务发出请求。这时候DeferredGpuCommandService服务又会通过App的UI线程将请求的GPU操作提交给App的Render Thread执行。这一点可以参考前面Android WebView简要介绍和学习计划一文的描述。我们在接下来的一篇文章也会对Chromium的Browser端和Render端执行GPU操作的过程进行详细的分析。

       接下来我们就结合源码，分析Android WebView启动Chromium的Browser端和Render端的过程。对于GPU端，我们仅仅分析与它相关的DeferredGpuCommandService服务的启动过程。在接下来一篇文章分析Android WebView执行GPU命令的过程时，我们再对GPU端进行更详细的分析。

       我们首先分析Android WebView启动Chromium的Browser端的过程。前面提到，WebView会在内部创建一个类型为WebViewChromium的Provider。有了这个Provider之后，WebView就可以调用它的成员函数init启动Chromium的Browser端，如下所示：

[java]  view plain  copy
  1. class WebViewChromium implements WebViewProvider,  
  2.           WebViewProvider.ScrollDelegate, WebViewProvider.ViewDelegate {  
  3.     ......  
  4.   
  5.     public void init(final Map<String, Object> javaScriptInterfaces,  
  6.             final boolean privateBrowsing) {  
  7.         ......  
  8.   
  9.         // We will defer real initialization until we know which thread to do it on, unless:  
  10.         // - we are on the main thread already (common case),  
  11.         // - the app is targeting >= JB MR2, in which case checkThread enforces that all usage  
  12.         //   comes from a single thread. (Note in JB MR2 this exception was in WebView.java).  
  13.         if (mAppTargetSdkVersion >= Build.VERSION_CODES.JELLY_BEAN_MR2) {  
  14.             mFactory.startYourEngines(false);  
  15.             checkThread();  
  16.         } else if (!mFactory.hasStarted()) {  
  17.             if (Looper.myLooper() == Looper.getMainLooper()) {  
  18.                 mFactory.startYourEngines(true);  
  19.             }  
  20.         }  
  21.   
  22.         ......  
  23.   
  24.         mRunQueue.addTask(new Runnable() {  
  25.                 @Override  
  26.                 public void run() {  
  27.                     initForReal();  
  28.                     ......  
  29.                 }  
  30.         });  
  31.     }  
  32.   
  33.     ......  
  34. }  
      这个函数定义在文件frameworks/webview/chromium/java/com/android/webview/chromium/WebViewChromium.java中。

      WebViewChromium类的成员变量mFactory指向的是一个WebViewChromiumFactoryProvider对象。WebViewChromium类的成员函数init通过调用这个WebViewChromiumFactoryProvider对象的成员函数startYourEngines启动Chromium渲染引擎的Browser端。

       在Android 4.3之前，WebView只能在App的UI线程中创建。相应地，WebView也只能在App的UI线程中启动Chromium渲染引擎的Browser端。这时候WebViewChromium类的成员函数init会传递一个参数true给WebViewChromiumFactoryProvider类的成员函数startYourEngines，表示如果当前线程如果不是UI线程，那么就需要向UI线程发出一个通知，让UI线程执行启动Chromium渲染引擎的Browser端的操作。

       在Android 4.3及以后，WebView也允许在App的非UI线程中创建。这时候WebView允行在App的非UI线程中启动Chromium渲染引擎的Browser端。因此，WebViewChromium类的成员函数init就会传递一个参数false给WebViewChromiumFactoryProvider类的成员函数startYourEngines。

       一般情况下，WebView都是在App的UI线程中创建的。为了简单起见，我们只考虑这种情况。WebViewChromium类的成员函数init调用WebViewChromiumFactoryProvider类的成员函数startYourEngines启动了Chromium渲染引擎的Browser端之后，接下来还会向App的UI线程的消息队列发送一个Runnable。当该Runnable被执行的时候，它就会调用WebViewChromium类的成员函数initForReal创建图1所示的AwContents对象。有了这个AwContents对象之后，后面就可以通过它来加载指定的URL了。

       接下来，我们首先分析WebViewChromiumFactoryProvider类的成员函数startYourEngines启动Chromium渲染引擎的Browser端的过程，然后再分析WebViewChromium类的成员函数initForReal为WebView创建AwContents对象的过程。

       WebViewChromiumFactoryProvider类的成员函数startYourEngines的实现如下所示：

[java]  view plain  copy
  1. public class WebViewChromiumFactoryProvider implements WebViewFactoryProvider {  
  2.     ......  
  3.   
  4.     void startYourEngines(boolean onMainThread) {  
  5.         synchronized (mLock) {  
  6.             ensureChromiumStartedLocked(onMainThread);  
  7.   
  8.         }  
  9.     }  
  10.   
  11.     ......  
  12. }  

       这个函数定义在文件frameworks/webview/chromium/java/com/android/webview/chromium/WebViewChromiumFactoryProvider.java中。

       WebViewChromiumFactoryProvider类的成员函数startYourEngines调用另外一个成员函数ensureChromiumStartedLocked检查Chromium渲染引擎的Browser端是否已经启动。如果还没有启动，那么就会进行启动，如下所示：

[java]  view plain  copy
  1. public class WebViewChromiumFactoryProvider implements WebViewFactoryProvider {  
  2.     ......  
  3.   
  4.     private void ensureChromiumStartedLocked(boolean onMainThread) {  
  5.         ......  
  6.   
  7.         if (mStarted) {  // Early-out for the common case.  
  8.             return;  
  9.         }  
  10.   
  11.         Looper looper = !onMainThread ? Looper.myLooper() : Looper.getMainLooper();  
  12.         ......  
  13.         ThreadUtils.setUiThread(looper);  
  14.   
  15.         if (ThreadUtils.runningOnUiThread()) {  
  16.             startChromiumLocked();  
  17.             return;  
  18.         }  
  19.   
  20.         // We must post to the UI thread to cover the case that the user has invoked Chromium  
  21.         // startup by using the (thread-safe) CookieManager rather than creating a WebView.  
  22.         ThreadUtils.postOnUiThread(new Runnable() {  
  23.             @Override  
  24.             public void run() {  
  25.                 synchronized (mLock) {  
  26.                     startChromiumLocked();  
  27.                 }  
  28.             }  
  29.         });  
  30.         while (!mStarted) {  
  31.             try {  
  32.                 // Important: wait() releases |mLock| the UI thread can take it :-)  
  33.                 mLock.wait();  
  34.             } catch (InterruptedException e) {  
  35.                 // Keep trying... eventually the UI thread will process the task we sent it.  
  36.             }  
  37.         }  
  38.     }  
  39.   
  40.     ......  
  41. }  
       这个函数定义在文件frameworks/webview/chromium/java/com/android/webview/chromium/WebViewChromiumFactoryProvider.java中。

       如果Chromium渲染引擎的Browser端已经启动，那么WebViewChromiumFactoryProvider类的成员变量mStarted的值就会等于true。在这种情况下，WebViewChromiumFactoryProvider类的成员函数ensureChromiumStartedLocked什么也不用做就可以返回。

       另一方面，如果Chromium渲染引擎的Browser端还没有启动，那么WebViewChromiumFactoryProvider类的成员函数ensureChromiumStartedLocked首先会根据参数onMainThread确定Chromium渲染引擎的Browser端要在哪个线程中运行。

       当参数onMainThread的值等于true的时候，就表示Chromium渲染引擎的Browser端要在App的UI线程中运行。这时候如果当前线程不是App的UI线程，那么WebViewChromiumFactoryProvider类的成员函数ensureChromiumStartedLocked就会向App的UI线程的消息队列发送一个Runnable。当该Runnable被执行的时候，才会启动Chromium渲染引擎的Browser端。在这种情况下，当前线程也会等待App的UI线程启动完成Chromium渲染引擎的Browser端。

       当参数onMainThread的值等于true的时候，如果当前线程刚好也是App的UI线程，那么WebViewChromiumFactoryProvider类的成员函数ensureChromiumStartedLocked就可以马上启动Chromium渲染引擎的Browser端。

       当参数onMainThread的值等于false的时候，不管当前线程是否App的UI线程，都表示Chromium渲染引擎的Browser端要在它里面运行。因此，这时候WebViewChromiumFactoryProvider类的成员函数ensureChromiumStartedLocked都会马上启动Chromium渲染引擎的Browser端。

       无论是上述的哪一种情况，用来运行Chromium渲染引擎的Browser端的线程都会通过调用ThreadUtils类的静态成员函数setUiThread记录起来。以后WebView都需要在该线程中访问Chromium渲染引擎。

       WebViewChromiumFactoryProvider类的成员函数ensureChromiumStartedLocked是通过调用另外一个成员函数startChromiumLocked启动Chromium渲染引擎的Browser端的，如下所示：

[java]  view plain  copy
  1. public class WebViewChromiumFactoryProvider implements WebViewFactoryProvider {  
  2.     ......  
  3.   
  4.     private void startChromiumLocked() {  
  5.         ......  
  6.   
  7.         AwBrowserProcess.start(ActivityThread.currentApplication());  
  8.   
  9.         ......  
  10.     }  
  11.   
  12.     ......  
  13. }  
       这个函数定义在文件frameworks/webview/chromium/java/com/android/webview/chromium/WebViewChromiumFactoryProvider.java中。

       WebViewChromiumFactoryProvider类的成员函数startChromiumLocked通过调用AwBrowserProcess类的静态成员函数start启动Chromium渲染引擎的Browser端的，如下所示：

[java]  view plain  copy
  1. public abstract class AwBrowserProcess {  
  2.     ......  
  3.   
  4.     public static void start(final Context context) {  
  5.         // We must post to the UI thread to cover the case that the user  
  6.         // has invoked Chromium startup by using the (thread-safe)  
  7.         // CookieManager rather than creating a WebView.  
  8.         ThreadUtils.runOnUiThreadBlocking(new Runnable() {  
  9.             @Override  
  10.             public void run() {  
  11.                 try {  
  12.                     BrowserStartupController.get(context).startBrowserProcessesSync(  
  13.                                 BrowserStartupController.MAX_RENDERERS_SINGLE_PROCESS);  
  14.                     ......  
  15.                 } catch (ProcessInitException e) {  
  16.                     ......  
  17.                 }  
  18.             }  
  19.         });  
  20.     }  
  21.   
  22.     ......  
  23. }  
       这个函数定义在文件external/chromium_org/android_webview/java/src/org/chromium/android_webview/AwBrowserProcess.java中。

       前面提到，用来运行Chromium渲染引擎的Browser端的线程会通过ThreadUtils类的静态成员函数setUiThread记录起来。AwBrowserProcess类的静态成员函数start为了确保Chromium渲染引擎的Browser端在该线程中启动，会通过调用ThreadUtils类的静态成员函数runOnUiThreadBlocking检查当前线程是否就是该线程。如果是的话，那么就会直接启动。否则的话，会向该线程的消息队列发送一个Runnable。当该Runnable被执行的时候，再启动Chromium渲染引擎的Browser端。

       AwBrowserProcess类的静态成员函数start是通过调用当前App进程中的一个BrowserStartupController单例对象的成员函数startBrowserProcessesSync来启动Chromium渲染引擎的Browser端的。这个BrowserStartupController单例对象可以通过调用BrowserStartupController类的静态成员函数get获得。

       AwBrowserProcess类的静态成员函数start在启动Chromium渲染引擎的Browser端的时候，会指定一个BrowserStartupController.MAX_RENDERERS_SINGLE_PROCESS参数。这个参数的值等于0，表示要启动一个单进程架构的Chromium渲染引擎。

       接下来，我们就继续分析Chromium渲染引擎的Browser端的启动过程，也就是BrowserStartupController类的成员函数startBrowserProcessesSync的实现，如下所示：

[java]  view plain  copy
  1. public class BrowserStartupController {  
  2.     ......  
  3.   
  4.     public void startBrowserProcessesSync(int maxRenderers) throws ProcessInitException {  
  5.         // If already started skip to checking the result  
  6.         if (!mStartupDone) {  
  7.             if (!mHasStartedInitializingBrowserProcess) {  
  8.                 prepareToStartBrowserProcess(maxRenderers);  
  9.             }  
  10.   
  11.             ......  
  12.             if (contentStart() > 0) {  
  13.                 // Failed. The callbacks may not have run, so run them.  
  14.                 enqueueCallbackExecution(STARTUP_FAILURE, NOT_ALREADY_STARTED);  
  15.             }  
  16.         }  
  17.   
  18.         ......  
  19.     }  
  20.   
  21.     ......  
  22. }  
       这个函数定义在文件external/chromium_org/content/public/android/java/src/org/chromium/content/browser/BrowserStartupController.java中。

       当BrowserStartupController类的成员变量mStartupDone的值等于true的时候，就表示Chromium渲染引擎的Browser端已经启动了。这时候BrowserStartupController类的成员函数startBrowserProcessesSync就什么也不做就直接返回。

       另一方面，如果Chromium渲染引擎的Browser端还没有启动。这时候BrowserStartupController类的成员函数startBrowserProcessesSync就会调用另外一个成员函数contentStart进行启动。

       在启动Chromium渲染引擎的Browser端之前，BrowserStartupController类的成员函数startBrowserProcessesSync也会检查成员变量mHasStartedInitializingBrowserProcess的值。当这个值等于false的时候，就会先调用成员函数prepareToStartBrowserProcess设置Chromium渲染引擎的启动参数。其中，最重要的就是将Chromium渲染引擎设置为单进程架构。

       接下来，我们先分析将Chromium渲染引擎设置为单进程架构的过程，也就是BrowserStartupController类的成员函数prepareToStartBrowserProcess的实现，然后再分析启动Chromium渲染引擎的Browser端的过程，也就是BrowserStartupController类的成员函数contentStart的实现。

       BrowserStartupController类的成员函数prepareToStartBrowserProcess的实现如下所示：

[java]  view plain  copy
  1. public class BrowserStartupController {  
  2.     ......  
  3.   
  4.     void prepareToStartBrowserProcess(int maxRendererProcesses) throws ProcessInitException {  
  5.         ......  
  6.   
  7.         nativeSetCommandLineFlags(maxRendererProcesses,  
  8.                 nativeIsPluginEnabled() ? getPlugins() : null);  
  9.         ......  
  10.     }  
  11.   
  12.     ......  
  13. }  
       这个函数定义在文件external/chromium_org/content/public/android/java/src/org/chromium/content/browser/BrowserStartupController.java中。

       BrowserStartupController类的成员函数prepareToStartBrowserProcess调用另外一个成员函数nativeSetCommandLineFlags将Chromium渲染引擎设置为单进程架构。

       BrowserStartupController类的成员函数nativeSetCommandLineFlags是一个JNI方法，它由C++层的函数Java_com_android_org_chromium_content_browser_BrowserStartupController_nativeSetCommandLineFlags实现，如下所示：

[cpp]  view plain  copy
  1. __attribute__((visibility("default")))  
  2. void  
  3.     Java_com_android_org_chromium_content_browser_BrowserStartupController_nativeSetCommandLineFlags(JNIEnv*  
  4.     env, jclass jcaller,  
  5.     jint maxRenderProcesses,  
  6.     jstring pluginDescriptor) {  
  7.   return SetCommandLineFlags(env, jcaller, maxRenderProcesses,  
  8.       pluginDescriptor);  
  9. }  
       这个函数定义在文件out/target/product/generic/obj/GYP/shared_intermediates/content/jni/BrowserStartupController_jni.h中。

       函数Java_com_android_org_chromium_content_browser_BrowserStartupController_nativeSetCommandLineFlags调用另外一个函数SetCommandLineFlags将Chromium渲染引擎设置为单进程架构，如下所示：

[cpp]  view plain  copy
  1. static void SetCommandLineFlags(JNIEnv* env,  
  2.                                 jclass clazz,  
  3.                                 jint max_render_process_count,  
  4.                                 jstring plugin_descriptor) {  
  5.   std::string plugin_str =  
  6.       (plugin_descriptor == NULL  
  7.            ? std::string()  
  8.            : base::android::ConvertJavaStringToUTF8(env, plugin_descriptor));  
  9.   SetContentCommandLineFlags(max_render_process_count, plugin_str);  
  10. }  
       这个函数定义在文件external/chromium_org/content/browser/android/browser_startup_controller.cc中。

       函数SetCommandLineFlags又会调用另外一个函数SetContentCommandLineFlags将Chromium渲染引擎设置为单进程架构，如下所示：

[cpp]  view plain  copy
  1. void SetContentCommandLineFlags(int max_render_process_count,  
  2.                                 const std::string& plugin_descriptor) {  
  3.   ......  
  4.   
  5.   CommandLine* parsed_command_line = CommandLine::ForCurrentProcess();  
  6.     
  7.   int command_line_renderer_limit = -1;  
  8.   if (parsed_command_line->HasSwitch(switches::kRendererProcessLimit)) {  
  9.     std::string limit = parsed_command_line->GetSwitchValueASCII(  
  10.         switches::kRendererProcessLimit);  
  11.     int value;  
  12.     if (base::StringToInt(limit, &value)) {  
  13.       command_line_renderer_limit = value;  
  14.       if (value <= 0)  
  15.         max_render_process_count = 0;  
  16.     }  
  17.   }  
  18.   
  19.   if (command_line_renderer_limit > 0) {  
  20.     int limit = std::min(command_line_renderer_limit,  
  21.                          static_cast<int>(kMaxRendererProcessCount));  
  22.     RenderProcessHost::SetMaxRendererProcessCount(limit);  
  23.   } else if (max_render_process_count <= 0) {  
  24.     // Need to ensure the command line flag is consistent as a lot of chrome  
  25.     // internal code checks this directly, but it wouldn't normally get set when  
  26.     // we are implementing an embedded WebView.  
  27.     parsed_command_line->AppendSwitch(switches::kSingleProcess);  
  28.   } else {  
  29.     int default_maximum = RenderProcessHost::GetMaxRendererProcessCount();  
  30.     DCHECK(default_maximum <= static_cast<int>(kMaxRendererProcessCount));  
  31.     if (max_render_process_count < default_maximum)  
  32.       RenderProcessHost::SetMaxRendererProcessCount(max_render_process_count);  
  33.   }  
  34.   
  35.   ......  
  36. }  
       这个函数定义在文件external/chromium_org/content/browser/android/content_startup_flags.cc中。

       函数SetContentCommandLineFlags首先检查Android WebView是否设置了switches::kRendererProcessLimit命令行参数。如果设置了，那么这个参数的值就会被解析出来，保存在本地变量command_line_renderer_limit中，用来限定Chromium渲染引擎最多可创建的Render进程的个数的。

       Chromium渲染引擎最多可创建的Render进程的个数还受到参数max_render_process_count的限制：

       1. 当本地变量command_line_renderer_limit的值大于0的时候，那么取max_render_process_count和command_line_renderer_limit之间的较小者作为最多可创建的Render进程的个数。

       2. 当本地变量command_line_renderer_limit的值小于等于0，并且参数max_render_process_count的值也小于等于0的时候，那么Chromium渲染引擎不允许创建Render进程，也就是它使用的是单进程架构。

       3. 当本地变量command_line_renderer_limit的值小于等于0，并且参数max_render_process_count的值大于0的时候，会调用RenderProcessHost类的静态成员函数GetMaxRendererProcessCount根据设备内存的大小计算出可以创建的Render进程的最大数default_maximum。如果参数max_render_process_count的值小于这个最大值，那么就将它设置为可以创建的Render进程的个数。

       在我们这个情景中，Android WebView没有设置switches::kRendererProcessLimit命令行参数，并且参数max_render_process_count的值等于0，因此函数SetContentCommandLineFlags会将Chromium渲染引擎设置为单进程架构。这是通过在Android WebView的命令行参数中设置一个switches::kSingleProcess选项实现的。

       这一步执行完成后，回到前面分析的BrowserStartupController类的成员函数startBrowserProcessesSync中，接下来它会调用另外一个成员函数contentStart启动Chromium渲染引擎的Browser端，如下所示：

[java]  view plain  copy
  1. public class BrowserStartupController {  
  2.     ......  
  3.   
  4.     int contentStart() {  
  5.         return ContentMain.start();  
  6.     }  
  7.   
  8.     ......  
  9. }  
       这个函数定义在文件external/chromium_org/content/public/android/java/src/org/chromium/content/browser/BrowserStartupController.java中。

       BrowserStartupController类的成员函数contentStart调用ContentMain类的静态成员函数Start启动Chromium渲染引擎的Browser端，如下所示：

[java]  view plain  copy
  1. public class ContentMain {  
  2.     ......  
  3.   
  4.     public static int start() {  
  5.         return nativeStart();  
  6.     }  
  7.   
  8.     ......  
  9. }  
       这个函数定义在文件external/chromium_org/content/public/android/java/src/org/chromium/content/app/ContentMain.java中。

       ContentMain类的静态成员函数Start调用另外一个静态成员函数nativeStart启动Chromium渲染引擎的Browser端。

       ContentMain类的静态成员函数nativeStart是一个JNI方法，它由C++层的函数Java_com_android_org_chromium_content_app_ContentMain_nativeStart实现，如下所示：

[cpp]  view plain  copy
  1. __attribute__((visibility("default")))  
  2. jint Java_com_android_org_chromium_content_app_ContentMain_nativeStart(JNIEnv*  
  3.     env, jclass jcaller) {  
  4.   return Start(env, jcaller);  
  5. }  
        这个函数定义在文件out/target/product/generic/obj/GYP/shared_intermediates/content/jni/ContentMain_jni.h中。

        函数Java_com_android_org_chromium_content_app_ContentMain_nativeStart调用另外一个函数Start启动Chromium渲染引擎的Browser端，如下所示：

[cpp]  view plain  copy
  1. LazyInstance<scoped_ptr<ContentMainRunner> > g_content_runner =  
  2.     LAZY_INSTANCE_INITIALIZER;  
  3.   
  4. LazyInstance<scoped_ptr<ContentMainDelegate> > g_content_main_delegate =  
  5.     LAZY_INSTANCE_INITIALIZER;  
  6.   
  7. ......  
  8.   
  9. static jint Start(JNIEnv* env, jclass clazz) {  
  10.   ......  
  11.   
  12.   if (!g_content_runner.Get().get()) {  
  13.     ContentMainParams params(g_content_main_delegate.Get().get());  
  14.     g_content_runner.Get().reset(ContentMainRunner::Create());  
  15.     g_content_runner.Get()->Initialize(params);  
  16.   }  
  17.   return g_content_runner.Get()->Run();  
  18. }  
       这个函数定义在文件external/chromium_org/content/app/android/content_main.cc中。

       函数Start判断全局变量g_content_runner是否已经指向了一个ContentMainRunner对象。如果还没有指向，那么就说明Chromium渲染引擎的Browser端还没有启动。在这种情况下，函数Start就会调用ContentMainRunner类的静态成员函数Create创建一个ContentMainRunner对象，并且保存在全局变量g_content_runner中。

       ContentMainRunner类的静态成员函数Create的实现如下所示：

[cpp]  view plain  copy
  1. ContentMainRunner* ContentMainRunner::Create() {  
  2.   return new ContentMainRunnerImpl();  
  3. }  
       这个函数定义在文件external/chromium_org/content/app/content_main_runner.cc中。

       从这里可以看到，ContentMainRunner类的静态成员函数Create实际创建的是一个ContentMainRunnerImpl对象。这个ContentMainRunnerImpl返回给函数Start之后，它的成员函数Initialize就会被调用，用来对它进行初始化。

       从前面Android WebView加载Chromium动态库的过程分析一文可以知道，全局变量g_content_main_delegate指向的是一个AwMainDelegate对象。这个AwMainDelegate对象将会封装在一个ContentMainParams对象中，并且传递给前面创建的ContentMainRunnerImpl对象的成员函数Initialize，以便后者用来执行初始化工作。

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

[cpp]  view plain  copy
  1. class ContentMainRunnerImpl : public ContentMainRunner {  
  2.  public:  
  3.   ......  
  4.   
  5.   virtual int Initialize(const ContentMainParams& params) OVERRIDE {  
  6.     ......  
  7.   
  8.     delegate_ = params.delegate;  
  9.     ......  
  10.   
  11.     int exit_code;  
  12.     if (delegate_ && delegate_->BasicStartupComplete(&exit_code))  
  13.       return exit_code;  
  14.     ......  
  15.       
  16.     const CommandLine& command_line = *CommandLine::ForCurrentProcess();  
  17.     std::string process_type =  
  18.         command_line.GetSwitchValueASCII(switches::kProcessType);  
  19.   
  20.     ......  
  21.   
  22.     ContentClientInitializer::Set(process_type, delegate_);  
  23.   
  24.     ......  
  25. }  
       这个函数定义在文件external/chromium_org/content/app/content_main_runner.cc中。

       参数params描述的ContentMainParams对象的成员变量delegate指向的是就是前面描述的全局变量g_content_main_delegate指向的AwMainDelegate对象。ContentMainRunnerImpl类的成员函数Initialize会将这个AwMainDelegate对象保存在成员变量delegate_中，并且会调用这个AwMainDelegate对象的成员函数BasicStartupComplete执行一些基本的初始化工作，如下所示：

[cpp]  view plain  copy
  1. bool AwMainDelegate::BasicStartupComplete(int* exit_code) {  
  2.   content::SetContentClient(&content_client_);  
  3.   ......  
  4. }  
       这个函数定义在文件external/chromium_org/android_webview/lib/main/aw_main_delegate.cc中。

       AwMainDelegate类的成员变量content_client_描述的是一个AwContentClient对象。这个AwContentClient对象将会设置给Chromium的Content层。这个通过调用函数SetContentClient实现的，如下所示：

[cpp]  view plain  copy
  1. static ContentClient* g_client;  
  2.   
  3. ......  
  4.   
  5. void SetContentClient(ContentClient* client) {  
  6.   g_client = client;  
  7.   ......  
  8. }  
  9.   
  10. ContentClient* GetContentClient() {  
  11.   return g_client;  
  12. }  
       这个函数定义在文件external/chromium_org/content/public/common/content_client.cc中。

       函数SetContentClient将参数client指向的一个AwContentClient对象保存在全局变量g_client中。这个AwContentClient对象以后可以通过调用函数GetContentClient获得。

       这一步执行完成后，回到前面分析的ContentMainRunnerImpl类的成员函数Initialize的中，它接下来检查Android WebView是否设置了switches::kProcessType命令行参数。如果设置了，那么该参数值process_type描述的就是当前启动的进程的类型（Browser端、Render端或者GPU端）。如果没有设置，那么参数值process_type就会等于一个空字符串，表示当前要启动的是一个Browser端。

       在我们这个情景中，Android WebView没有设置switches::kProcessType，因此得到的参数值process_type就等于一个空字符串。这个空字符串，连同ContentMainRunnerImpl类的成员变量delegate_指向的AwMainDelegate对象，会进一步传递给ContentClientInitializer类的静态成员函数Set执行初始化操作，如下所示：

[cpp]  view plain  copy
  1. class ContentClientInitializer {  
  2.  public:  
  3.   static void Set(const std::string& process_type,  
  4.                   ContentMainDelegate* delegate) {  
  5.     ContentClient* content_client = GetContentClient();  
  6.     if (process_type.empty()) {  
  7.       if (delegate)  
  8.         content_client->browser_ = delegate->CreateContentBrowserClient();  
  9.       ......  
  10.     }  
  11.   
  12.     ......  
  13.   }  
  14.    
  15.   ......  
  16. };  

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

      ContentClientInitializer类的静态成员函数Set首先是调用前面提到的函数GetContentClient获得一个AwContentClient对象，接下来判断参数process_type的值是否等于一个空字符串。如果等于的话，那么就会调用参数delegate指向的一个AwMainDelegate对象的成员函数CreateContentBrowserClient创建一个ContentBrowserClient对象，并且保存在前面获得的AwContentClient对象的成员变量browser_中。

      从前面的分析可以知道，参数process_type的值等于一个空字符串，因此接下来ContentClientInitializer类的静态成员函数Set就会调用参数delegate指向的AwMainDelegate对象的成员函数CreateContentBrowserClient创建一个ContentBrowserClient对象，如下所示：

[cpp]  view plain  copy
  1. content::ContentBrowserClient*  
  2.     AwMainDelegate::CreateContentBrowserClient() {  
  3.   content_browser_client_.reset(new AwContentBrowserClient(this));  
  4.   return content_browser_client_.get();  
  5. }  
       这个函数定义在文件external/chromium_org/android_webview/lib/main/aw_main_delegate.cc中。

       AwMainDelegate类的成员函数CreateContentBrowserClient实际创建的是一个AwContentBrowserClient对象。这个AwContentBrowserClient对象是从ContentBrowserClient类继承下来的。

       这意味着前面设置到Conent层的一个AwContentClient对象的成员变量browser_指向的是一个AwContentBrowserClient对象。这个AwContentBrowserClient对象在接下来启动Chromium渲染引擎的Browser端过程中会使用到。

       这一步执行完成后，回到前面分析的函数Start中。这时候它就创建了一个ContentMainRunner对象，并且对这个ContentMainRunner对象进行初始化。接下来，函数Start继续调用这个ContentMainRunner对象的成员函数Run，以便启动Chromium渲染引擎的Browser端，如下所示：

[cpp]  view plain  copy
  1. class ContentMainRunnerImpl : public ContentMainRunner {  
  2.  public:  
  3.   ......  
  4.   
  5.   virtual int Run() OVERRIDE {  
  6.     ......  
  7.     const CommandLine& command_line = *CommandLine::ForCurrentProcess();  
  8.     std::string process_type =  
  9.           command_line.GetSwitchValueASCII(switches::kProcessType);  
  10.   
  11.     MainFunctionParams main_params(command_line);  
  12.     ......  
  13.   
  14. #if !defined(OS_IOS)  
  15.     return RunNamedProcessTypeMain(process_type, main_params, delegate_);  
  16. #else  
  17.     return 1;  
  18. #endif  
  19.   }  
  20.   
  21.   ......  
  22. };  
       这个函数定义在文件external/chromium_org/content/app/content_main_runner.cc中。

       ContentMainRunner类的成员函数Run首先获得Android WebView设置的命令行参数switches::kProcessType的值。前面提到，Android WebView没有设置命令行参数switches::kProcessType，因此这里获得的值为一个空字符串，也就是本地变量process_type的值等于一个空字符串。

       接下来，ContentMainRunner类的成员函数Run还会将Android WebView设置的命令行参数封装在一个MainFunctionParams对象中。这个MainFunctionParams对象，连同前面设置的本地变量process_type，以及ContentMainRunner类的成员变量delegate_指向的一个AwMainDelegate对象，会传递给另外一个函数RunNamedProcessTypeMain。这个函数将会负责启动Chromium渲染引擎的Browser端，如下所示：

[cpp]  view plain  copy
  1.    const MainFunctionParams& main_function_params,  
  2.     ContentMainDelegate* delegate) {  
  3.   static const MainFunction kMainFunctions[] = {  
  4. #if !defined(CHROME_MULTIPLE_DLL_CHILD)  
  5.     { "",                            BrowserMain },  
  6. #endif  
  7.     ......  
  8.     { switches::kRendererProcess,    RendererMain },  
  9.     { switches::kGpuProcess,         GpuMain },   
  10.     ......  
  11.   };  
  12.   
  13.   RegisterMainThreadFactories();  
  14.   
  15.   for (size_t i = 0; i < arraysize(kMainFunctions); ++i) {  
  16.     if (process_type == kMainFunctions[i].name) {  
  17.       if (delegate) {  
  18.         int exit_code = delegate->RunProcess(process_type,  
  19.             main_function_params);  
  20. #if defined(OS_ANDROID)  
  21.         // In Android's browser process, the negative exit code doesn't mean the  
  22.         // default behavior should be used as the UI message loop is managed by  
  23.         // the Java and the browser process's default behavior is always  
  24.         // overridden.  
  25.         if (process_type.empty())  
  26.           return exit_code;  
  27. #endif  
  28.         if (exit_code >= 0)  
  29.           return exit_code;  
  30.       }  
  31.       return kMainFunctions[i].function(main_function_params);  
  32.     }  
  33.   }  
  34.   
  35.   ......  
  36. }  

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

       函数RunNamedProcessTypeMain定义了一个MainFunction数组。这个MainFunction数组用来指定不同类型的进程的入口函数。其中，Browser进程、Render进程和GPU进程对应的入口函数分别为BrowserMain、RendererMain和GpuMain。当然，只有在参数delegate的值等于NULL的情况下，这个MainFunction数组才会生效。否则的话，所有进程的入口函数都为该参数指向的ContentMainDelegate对象的成员函数RunProcess。对于非Browser进程，如果参数delegate指向的ContentMainDelegate对象的成员函数RunProcess的返回值小于0，那么上述MainFunction数组也会同样生效。

       从前面的调用过程可以知道，参数process_type的值是一个空字符串，表示函数RunNamedProcessTypeMain需要启动的是一个Chromium渲染引擎的Browser进程（端）。这时候由于另外一个参数delegate指向了一个AwMainDelegate对象，因此，函数RunNamedProcessTypeMain将调用这个AwMainDelegate对象的成员函数RunProcess启动Chromium渲染引擎的Browser端。

       函数RunNamedProcessTypeMain在调用参数delegate指向的AwMainDelegate对象的成员函数RunProcess启动Chromium渲染引擎的Browser端之前，还会调用函数RegisterMainThreadFactories注册一些线程创建工厂函数，如下所示：

[cpp]  view plain  copy
  1. static void RegisterMainThreadFactories() {  
  2. #if !defined(CHROME_MULTIPLE_DLL_BROWSER)  
  3.   ......  
  4.   RenderProcessHostImpl::RegisterRendererMainThreadFactory(  
  5.       CreateInProcessRendererThread);  
  6.   ......  
  7. #else  
  8.   ......  
  9. #endif  
  10. }  
      这个函数定义在文件external/chromium_org/content/app/content_main_runner.cc中。

      其中的一个线程创建工厂函数是Render线程创建工厂函数，它被指定为函数CreateInProcessRendererThread，并且会通过调用RenderProcessHostImpl类的静态成员函数RegisterRendererMainThreadFactory记录起来，如下所示：

[cpp]  view plain  copy
  1. RendererMainThreadFactoryFunction g_renderer_main_thread_factory = NULL;  
  2.   
  3. ......  
  4.   
  5. void RenderProcessHostImpl::RegisterRendererMainThreadFactory(  
  6.     RendererMainThreadFactoryFunction create) {  
  7.   g_renderer_main_thread_factory = create;  
  8. }  
       这个函数定义在文件external/chromium_org/content/browser/renderer_host/render_process_host_impl.cc中。

       参数create描述的函数CreateInProcessRendererThread将会保存在全局变量g_renderer_main_thread_factory中。以后Chromium渲染引擎的Browser端将会通过这个函数创建In-Process Renderer Thread，以便用来加载和渲染指定的URL。

       这一步执行完成后，回到前面分析的函数RunNamedProcessTypeMain，接下来它就会调用参数delegate指向的AwMainDelegate对象的成员函数RunProcess启动Chromium渲染引擎的Browser端，如下所示：

[cpp]  view plain  copy
  1. int AwMainDelegate::RunProcess(  
  2.     const std::string& process_type,  
  3.     const content::MainFunctionParams& main_function_params) {  
  4.   if (process_type.empty()) {  
  5.     ......  
  6.   
  7.     browser_runner_.reset(content::BrowserMainRunner::Create());  
  8.     int exit_code = browser_runner_->Initialize(main_function_params);  
  9.     ......  
  10.   
  11.     return 0;  
  12.   }  
  13.   
  14.   return -1;  
  15. }  
      这个函数定义在文件external/chromium_org/android_webview/lib/main/aw_main_delegate.cc中。

      从前面的调用过程可以知道，参数process_type的值等于一个空字符串。在这种情况下，AwMainDelegate类的成员函数RunProcess会调用BrowserMainRunner类的静态成员函数Create创建一个BrowserMainRunner对象，并且会保存在成员变量browser_runner_中，如下所示：

[cpp]  view plain  copy
  1. BrowserMainRunner* BrowserMainRunner::Create() {  
  2.   return new BrowserMainRunnerImpl();  
  3. }  
      这个函数定义在文件external/chromium_org/content/browser/browser_main_runner.cc中。

      从这里可以看到，BrowserMainRunner类的静态成员函数Create创建的实际上是一个BrowserMainRunnerImpl对象。这意味着AwMainDelegate类的成员变量browser_runner_指向的是一个BrowserMainRunnerImpl对象。这个BrowserMainRunnerImpl对象的成员函数Initialize接下来会被调用。在调用的过程中，就会将Chromium渲染引擎的Browser端启动起来，如下所示：

[cpp]  view plain  copy
  1. class BrowserMainRunnerImpl : public BrowserMainRunner {  
  2.  public:  
  3.   ......  
  4.   
  5.   virtual int Initialize(const MainFunctionParams& parameters) OVERRIDE {  
  6.     ......  
  7.   
  8.     if (!initialization_started_) {  
  9.       initialization_started_ = true;  
  10.       ......  
  11.   
  12.       main_loop_.reset(new BrowserMainLoop(parameters));  
  13.   
  14.       main_loop_->Init();  
  15.   
  16.       main_loop_->EarlyInitialization();  
  17.   
  18.       ......  
  19.   
  20.       main_loop_->MainMessageLoopStart();  
  21.   
  22.       ......  
  23.     }  
  24.   
  25.     main_loop_->CreateStartupTasks();  
  26.     int result_code = main_loop_->GetResultCode();  
  27.     if (result_code > 0)  
  28.       return result_code;  
  29.   
  30.     // Return -1 to indicate no early termination.  
  31.     return -1;  
  32.   }  
  33.   
  34.   ......  
  35. }  
       这个函数定义在文件external/chromium_org/content/browser/browser_main_runner.cc中。

       BrowserMainRunnerImpl类的成员函数Initialize首先检查成员变量initialization_started_的值是否等于true。如果等于true，那么就说明Chromium渲染引擎的Browser端已经启动过。在这种情况下，BrowserMainRunnerImpl类的成员函数Initialize只会创建一些Startup Task。

       如果Chromium渲染引擎的Browser端还没有启动过，那么BrowserMainRunnerImpl类的成员函数Initialize首先就会创建一个BrowserMainLoop对象，并且保存在成员变量main_loop_中。接下来，BrowserMainRunnerImpl类的成员函数Initialize会调用上述BrowserMainLoop对象的成员函数Init和EarlyInitialization对其进行初始化。初始化完成后，它的成员函数MainMessageLoopStart又会被调用。调用完成后，Chromium渲染引擎的Browser端就启动完成了。启动完成后，上述BrowserMainLoop对象的成员函数CreateStartupTasks也会被调用，用来创建一些Startup Task。

       接下来，我们就分别分析BrowserMainLoop类的成员函数Init、EarlyInitialization、MainMessageLoopStart和CreateStartupTasks的实现，以便了解Chromium渲染引擎的Browser端的启动过程。

       BrowserMainLoop类的成员函数Init用来创建一个BrowserMainParts对象，它的实现如下所示：

[cpp]  view plain  copy
  1. void BrowserMainLoop::Init() {  
  2.   ......  
  3.   parts_.reset(  
  4.       GetContentClient()->browser()->CreateBrowserMainParts(parameters_));  
  5. }  
       这个函数定义在文件external/chromium_org/content/browser/browser_main_loop.cc中。

       BrowserMainLoop类的成员函数Init首先调用前面提到的函数GetContentClient获得一个AwContentClient对象，接下来又会调用这个AwContentClient对象的成员函数browser获得它的成员变量browser_指向的一个AwContentBrowserClient对象。获得了这个AwContentBrowserClient对象之后，就可以调用它的成员函数CreateBrowserMainParts创建一个BrowserMainParts对象，并且保存在BrowserMainLoop类的成员变量parts_中，如下所示：

[cpp]  view plain  copy
  1. content::BrowserMainParts* AwContentBrowserClient::CreateBrowserMainParts(  
  2.     const content::MainFunctionParams& parameters) {  
  3.   return new AwBrowserMainParts(browser_context_.get());  
  4. }  
       这个函数定义在文件external/chromium_org/android_webview/browser/aw_content_browser_client.cc中。

       从这里可以看出，AwContentBrowserClient类的成员函数CreateBrowserMainParts创建的实际上是一个AwBrowserMainParts对象。这个AwBrowserMainParts对象接下来会用来创建一个Native层的UI Message Loop。这个UI Message Loop接下来又会用来创建一个Browser Thread，用来表示Chromium渲染引擎的Browser端。

       这一步执行完成后，回到前面分析的BrowserMainRunnerImpl类的成员函数Initialize中，接下来BrowserMainLoop类的成员函数EarlyInitialization会被调用，用来创建一个Native层的UI Message Loop，如下所示：

[cpp]  view plain  copy
  1. void BrowserMainLoop::EarlyInitialization() {  
  2.   ......  
  3.   
  4.   if (parts_)  
  5.     parts_->PreEarlyInitialization();  
  6.     
  7.   ......  
  8. }  
      这个函数定义在文件external/chromium_org/content/browser/browser_main_loop.cc中。

      从前面的分析可以知道，BrowserMainLoop类的成员变量parts_指向的是一个AwBrowserMainParts对象。BrowserMainLoop类的成员函数EarlyInitialization会调用这个AwBrowserMainParts对象的成员函数PreEarlyInitialization创建一个UI Message Loop，如下所示：

[cpp]  view plain  copy
  1. void AwBrowserMainParts::PreEarlyInitialization() {  
  2.   ......  
  3.   main_message_loop_.reset(new base::MessageLoopForUI);  
  4.   base::MessageLoopForUI::current()->Start();  
  5. }  
       这个函数定义在文件external/chromium_org/android_webview/browser/aw_browser_main_parts.cc中。

       AwBrowserMainParts类的成员函数PreEarlyInitialization创建了一个MessageLoopForUI对象。这个MessageLoopForUI对象描述的就是一个Native层的UI Message Loop。从前面Chromium多线程模型设计和实现分析一文可以知道，Native层的UI Message Loop并没有自己的线程，而是寄生在App的UI线程中运行（当前线程就是App的UI线程）。App的UI线程在Java层也有一个Message Loop，并且是由这个Java层的Message Loop驱动运行的。

       当我们往Native层的UI Message Loop发送一个消息的时候，Native层的UI Message Loop会向App的UI线程在Java层的Message Loop发送一个消息。当该消息被Java层的Message Loop调度执行的时候，之前发送在Native层的UI Message Loop中的消息就会得到执行。Chromium渲染引擎的Browser端，就是以这种方式运行在App的UI线程中的。

       AwBrowserMainParts类的成员函数PreEarlyInitialization在当前线程中创建了一个MessageLoopForUI对象之后，以后在当前线程中调用MessageLoopForUI类的静态成员函数current时，就会获得该MessageLoopForUI对象。有了这个MessageLoopForUI对象之后，AwBrowserMainParts类的成员函数PreEarlyInitialization就会调用它的成员函数Start，用来启动它描述的Native UI Message Loop。

       这一步执行完成后，回到前面分析的BrowserMainRunnerImpl类的成员函数Initialize中，接下来BrowserMainLoop类的成员函数MainMessageLoopStart会被调用，用来创建一个Browser Thread，如下所示：

[cpp]  view plain  copy
  1. void BrowserMainLoop::MainMessageLoopStart() {  
  2.   ......  
  3.   
  4.   InitializeMainThread();  
  5.   
  6.   .....  
  7. }  
       这个函数定义在文件external/chromium_org/content/browser/browser_main_loop.cc中。

       BrowserMainLoop类的成员函数MainMessageLoopStart调用另外一个成员函数InitializeMainThread创建一个Browser Thread，如下所示：

[cpp]  view plain  copy
  1. void BrowserMainLoop::InitializeMainThread() {  
  2.   ......  
  3.   main_thread_.reset(  
  4.       new BrowserThreadImpl(BrowserThread::UI, base::MessageLoop::current()));  
  5. }  
       这个函数定义在文件external/chromium_org/content/browser/browser_main_loop.cc中。

       BrowserMainLoop类的成员函数InitializeMainThread使用前面创建的Native UI Message Loop创建了一个Browser Thread。这个Browser Thread描述的就是Chromium渲染引擎的Browser端。由于这个Browser Thread是使用前面创建的Native UI Message Loop创建的，因此，它实际上描述的是App的UI线程。以后Chromium请求这个Browser Thread执行操作时，这个操作就会在App的UI线程中执行。

       这一步执行完成之后，Chromium渲染引擎的Browser端就启动完成了。再回到前面分析的BrowserMainRunnerImpl类的成员函数Initialize中，接下来BrowserMainLoop类的成员函数CreateStartupTasks会被调用，用来在Chromium渲染引擎的Browser端执行一些Startup Task，如下所示：

[cpp]  view plain  copy
  1. void BrowserMainLoop::CreateStartupTasks() {  
  2.   ......  
  3.   
  4.   if (!startup_task_runner_.get()) {  
  5.     ......  
  6.   
  7.     StartupTask pre_create_threads =  
  8.         base::Bind(&BrowserMainLoop::PreCreateThreads, base::Unretained(this));  
  9.     startup_task_runner_->AddTask(pre_create_threads);  
  10.   
  11.     ......  
  12.   }  
  13.   
  14.   ......  
  15. }  
       这个函数定义在文件external/chromium_org/content/browser/browser_main_loop.cc中。

       其中的一个Startup Task，是在Chromium渲染引擎的Browser端创建其它线程（IO线程、数据库线程、文件线程等）之前执行的，对应的函数为BrowserMainLoop类的成员函数PreCreateThreads。

       BrowserMainLoop类的成员函数PreCreateThread会检查Android WebView的命令行参数是否设置了一个switches::kSingleProcess选项。如果设置了，那么就会将Chromium渲染引擎设置为单进程架构，如下所示：

[cpp]  view plain  copy
  1. int BrowserMainLoop::PreCreateThreads() {  
  2.   ......  
  3.   
  4. #if !defined(OS_IOS) && (!defined(GOOGLE_CHROME_BUILD) || defined(OS_ANDROID))  
  5.   // Single-process is an unsupported and not fully tested mode, so  
  6.   // don't enable it for official Chrome builds (except on Android).  
  7.   if (parsed_command_line_.HasSwitch(switches::kSingleProcess))  
  8.     RenderProcessHost::SetRunRendererInProcess(true);  
  9. #endif  
  10.   return result_code_;  
  11. }  
       这个函数定义在文件external/chromium_org/content/browser/browser_main_loop.cc中。

       从前面的分析可以知道，函数SetContentCommandLineFlags会给Android WebView的命令行参数设置一个switches::kSingleProcess选项。在这种情况下，BrowserMainLoop类的成员函数PreCreateThread会调用RenderProcessHost类的静态成员函数SetRunRendererInProcess将Chromium渲染引擎设置为单进程架构，如下所示：

[cpp]  view plain  copy
  1. bool g_run_renderer_in_process_ = false;  
  2.   
  3. ......  
  4.   
  5. void RenderProcessHost::SetRunRendererInProcess(bool value) {  
  6.   g_run_renderer_in_process_ = value;  
  7.   
  8.   ......  
  9. }  
       这个函数定义在文件external/chromium_org/content/browser/renderer_host/render_process_host_impl.cc中。

       从前面的调用过程可以知道，参数value的值等于true。这时候RenderProcessHost类的静态成员函数SetRunRendererInProcess就会将全局变量g_run_renderer_in_process_的值设置为true，表示Chromium渲染引擎使用单进程加载，也就是在需要创建Render进程来加载和渲染网页时，通过一个In-Process Renderer Thread模拟。

       这一步执行完成后，Chromium渲染引擎的Browser端就启动完毕。回到前面分析的WebViewChromium类的成员函数init中，接下来它会继续调用另外一个成员函数initForReal为WebView创建一个AwContents对象。这个AwContents对象以后可以用来加载指定的URL。

       接下来，我们就继续分析WebViewChromium类的成员函数initForReal创建AwContents对象的过程，如下所示：

[java]  view plain  copy
  1. class WebViewChromium implements WebViewProvider,  
  2.           WebViewProvider.ScrollDelegate, WebViewProvider.ViewDelegate {  
  3.     ......  
  4.   
  5.     private void initForReal() {  
  6.         ......  
  7.         mAwContents = new AwContents(mFactory.getBrowserContext(), mWebView, ctx,  
  8.                 new InternalAccessAdapter(), new WebViewNativeGLDelegate(),  
  9.                 mContentsClientAdapter, mWebSettings.getAwSettings());  
  10.   
  11.         ......  
  12.     }  
  13.   
  14.     ......  
  15. }  
       这个函数定义在文件frameworks/webview/chromium/java/com/android/webview/chromium/WebViewChromium.java中。

       WebViewChromium类的成员函数initForReal主要是创建了一个AwContents对象，并且保存在成员变量mAwContents中。这个AwContents对象的创建过程，也就是AwContents类的构造函数的实现，如下所示：

[java]  view plain  copy
  1. public class AwContents {  
  2.     ......  
  3.   
  4.     public AwContents(AwBrowserContext browserContext, ViewGroup containerView, Context context,  
  5.             InternalAccessDelegate internalAccessAdapter, NativeGLDelegate nativeGLDelegate,  
  6.             AwContentsClient contentsClient, AwSettings awSettings) {  
  7.         this(browserContext, containerView, context, internalAccessAdapter, nativeGLDelegate,  
  8.                 contentsClient, awSettings, new DependencyFactory());  
  9.     }  
  10.   
  11.     ......  
  12. }  
      这个函数定义在文件external/chromium_org/android_webview/java/src/org/chromium/android_webview/AwContents.java中。

      AwContents类的构造函数调用另外一个重载版本的构造函数创建一个AwContents对象，如下所示：

[java]  view plain  copy
  1. public class AwContents {  
  2.     ......  
  3.   
  4.     public AwContents(AwBrowserContext browserContext, ViewGroup containerView, Context context,  
  5.             InternalAccessDelegate internalAccessAdapter, NativeGLDelegate nativeGLDelegate,  
  6.             AwContentsClient contentsClient, AwSettings settings,  
  7.             DependencyFactory dependencyFactory) {  
  8.         ......  
  9.         mNativeGLDelegate = nativeGLDelegate;  
  10.         ......  
  11.   
  12.         setNewAwContents(nativeInit(mBrowserContext));  
  13.   
  14.         ......  
  15.     }  
  16.   
  17.     ......  
  18. }  
       这个函数定义在文件external/chromium_org/android_webview/java/src/org/chromium/android_webview/AwContents.java中。

       参数nativeGLDelegate指向的是一个WebViewNativeGLDelegate对象。这个WebViewNativeGLDelegate对象会被保存在AwContents类的成员变量mNativeGLDelegate中。

       AwContents类的构造函数会调用另外一个成员函数nativeInit在Native层创建一个WebContents对象。WebContents类是Chromium的Content层向外提供的一个类，通过它可以描述一个网页。

       在Native层创建了一个WebContents对象之后，AwContents类的构造函数会将该WebContents对象传递给另外一个成员函数setNewAwContents，用来在Native层创建一个ContentViewCore对象。ContentViewCore类同样是Chromium的Content层向外提供的一个类，通过它可以加载一个指定的URL，也就是通过可以启动Chromium渲染引擎的Render端。

       接下来，我们就继续分析AwContents成员函数nativeInit和setNewAwContents的实现，以便了解Android WebView在Native层ContentViewCore对象的过程，为接下来分析Chromium渲染引擎的Render端的启动过程做准备。

       AwContents成员函数nativeInit是一个JNI方法，它由C++层的函数Java_com_android_org_chromium_android_1webview_AwContents_nativeInit实现，如下所示：

[cpp]  view plain  copy
  1. __attribute__((visibility("default")))  
  2. jlong  
  3.     Java_com_android_org_chromium_android_1webview_AwContents_nativeInit(JNIEnv*  
  4.     env, jclass jcaller,  
  5.     jobject browserContext) {  
  6.   return Init(env, jcaller, browserContext);  
  7. }  
       这个函数定义在文件out/target/product/generic/obj/GYP/shared_intermediates/android_webview/jni/AwContents_jni.h中。

       函数Java_com_android_org_chromium_android_1webview_AwContents_nativeInit调用另外一个函数Init创建一个WebContents对象，并且使用这个WebContents对象创建一个Native层的AwContents对象，如下所示：

[cpp]  view plain  copy
  1. static jlong Init(JNIEnv* env, jclass, jobject browser_context) {  
  2.   ......  
  3.   scoped_ptr<WebContents> web_contents(content::WebContents::Create(  
  4.       content::WebContents::CreateParams(AwBrowserContext::GetDefault())));  
  5.   ......  
  6.   return reinterpret_cast<intptr_t>(new AwContents(web_contents.Pass()));  
  7. }  
       这个函数定义在文件external/chromium_org/android_webview/native/aw_contents.cc中。

       函数Init是通过调用WebContents类的静态成员函数Create创建一个WebContents对象的。WebContents类的静态成员函数Create的实现，可以参考前面Chromium网页Frame Tree创建过程分析一文。

       创建了一个WebContents对象之后，函数Init就使用它来创建一个Native层的AwContents对象，如下所示：

[cpp]  view plain  copy
  1. AwContents::AwContents(scoped_ptr<WebContents> web_contents)  
  2.     : web_contents_(web_contents.Pass()),  
  3.       shared_renderer_state_(  
  4.           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),  
  5.           this),  
  6.       browser_view_renderer_(  
  7.           this,  
  8.           &shared_renderer_state_,  
  9.           web_contents_.get(),  
  10.           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),  
  11.       ...... {  
  12.   ......  
  13. }  
       这个函数定义在文件external/chromium_org/android_webview/native/aw_contents.cc中。

       AwContents类的构造函数首先将参数web_contents指向的WebContents对象保存在成员变量web_contents_中，接下来又会分别构造一个SharedRendererState对象和一个BrowserViewRenderer对象，并且保存在成员变量shared_renderer_state_和browser_view_renderer_中。

       通过AwContents类的成员变量shared_renderer_state_描述的SharedRendererState对象，Chromium渲染引擎的Browser端和Render端可以请求App的Render Thread执行GPU命令。同时，这个SharedRendererState对象也会用来保存Chromium渲染引擎的Render端渲染的每一帧数据。这些帧数据将会交给Chromium渲染引擎的Browser端合成显示在屏幕上。

       通过AwContents类的成员变量browser_view_renderer_描述的BrowserViewRenderer对象，则可以为Chromium渲染引擎的Render端创建一个Synchronous Compositor。这个Synchronous Compositor可以用来将网页的CC Layer Tree渲染在一个Synchronous Compositor Output Surface上。

       接下来我们就继续分析上述SharedRendererState对象和BrowserViewRenderer对象的构造过程。

       SharedRendererState对象的构造过程，也就是SharedRendererState类的构造函数的实现，如下所示：

[cpp]  view plain  copy
  1. SharedRendererState::SharedRendererState(  
  2.     scoped_refptr<base::MessageLoopProxy> ui_loop,  
  3.     BrowserViewRendererClient* client)  
  4.     : ui_loop_(ui_loop),  
  5.       client_on_ui_(client),  
  6.       ...... {  
  7.   ......  
  8. }  
       这个函数定义在文件external/chromium_org/android_webview$ vi browser/shared_renderer_state.cc中。

       参数ui_loop描述的是一个Native UI Message Loop。这个Native UI Message Loop是通过前面调用BrowserThread类的静态成员函数GetMessageLoopProxyForThread获得的。这个Native UI Message Loop会保存在SharedRendererState类的成员变量ui_loop_。以后通过这个成员变量，就可以向App的Render Thread请求执行GPU操作了。

       另外一个参数client指向的就是前面创建的AwContents对象。这个AwContents对象会保存在SharedRendererState类的成员变量client_on_ui_中。

       BrowserViewRenderer对象的构造过程，也就是BrowserViewRenderer类的构造函数的实现，如下所示：

[cpp]  view plain  copy
  1. BrowserViewRenderer::BrowserViewRenderer(  
  2.     BrowserViewRendererClient* client,  
  3.     SharedRendererState* shared_renderer_state,  
  4.     content::WebContents* web_contents,  
  5.     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner)  
  6.     : client_(client),  
  7.       ...... {  
  8.   ......  
  9.   content::SynchronousCompositor::SetClientForWebContents(web_contents_, this);  
  10.   ......  
  11. }  
       这个函数定义在文件external/chromium_org/android_webview/browser/browser_view_renderer.cc中。

       从前面的调用过程可以知道，参数client指向的是前面创建的AwContents对象。这个AwContents对象会保存在BrowserViewRenderer类的成员变量client_中。

       BrowserViewRenderer类的构造函数接下来会调用SynchronousCompositor类的静态成员函数SetClientForWebContents创建一个Synchronous Compositor，如下所示：

[cpp]  view plain  copy
  1. void SynchronousCompositor::SetClientForWebContents(  
  2.     WebContents* contents,  
  3.     SynchronousCompositorClient* client) {  
  4.   ......  
  5.   if (client) {  
  6.     ......  
  7.     SynchronousCompositorImpl::CreateForWebContents(contents);  
  8.   }  
  9.   if (SynchronousCompositorImpl* instance =  
  10.       SynchronousCompositorImpl::FromWebContents(contents)) {  
  11.     instance->SetClient(client);  
  12.   }  
  13. }  
       这个函数定义在文件external/chromium_org/content/browser/android/in_process/synchronous_compositor_impl.cc中。

       从前面的调用过程可以知道，参数client的值不等于NULL，它指向的是一个BrowserViewRenderer对象。在这种情况下，SynchronousCompositor类的静态成员函数SetClientForWebContents会调用SynchronousCompositorImpl类的静态成员函数CreateForWebContents为前面创建的WebContents对象创建一个Synchronous Compositor。

       SynchronousCompositorImpl类的静态成员函数CreateForWebContents是从父类WebContentsUserData<SynchronousCompositorImpl>继承下来的，它的实现如下所示：

[cpp]  view plain  copy
  1. template <typename T>  
  2. class WebContentsUserData : public base::SupportsUserData::Data {  
  3.  public:  
  4.   // Creates an object of type T, and attaches it to the specified WebContents.  
  5.   // If an instance is already attached, does nothing.  
  6.   static void CreateForWebContents(WebContents* contents) {  
  7.     ......  
  8.     if (!FromWebContents(contents))  
  9.       contents->SetUserData(UserDataKey(), new T(contents));  
  10.   }  
  11.   
  12.   ......  
  13. };  
       这个函数定义在文件external/chromium_org/content/public/browser/web_contents_user_data.h中。

       WebContentsUserData<SynchronousCompositorImpl>类的静态成员函数CreateForWebContents首先调用另外一个FromWebContents检查之前是否已经为参数contents描述的WebContents对象创建过一个SynchronousCompositorImpl对象。如果没有创建过，那么就会创建一个，并且保存在该WebContents对象的内部，这是通过调用它的成员函数SetUserData实现的。这里创建出来的SynchronousCompositorImpl对象描述的就是一个ynchronous Compositor。

       这一步执行完成后，回到前面分析的SynchronousCompositor类的静态成员函数SetClientForWebContents中，接下来它又会通过SynchronousCompositorImpl类的静态成员函数FromWebContents获得前面创建的SynchronousCompositorImpl对象，并且调用它的成员函数SetClient，用来将参数client指向的BrowserViewRenderer对象保存在内部，如下所示：

[cpp]  view plain  copy
  1. void SynchronousCompositorImpl::SetClient(  
  2.     SynchronousCompositorClient* compositor_client) {  
  3.   DCHECK(CalledOnValidThread());  
  4.   compositor_client_ = compositor_client;  
  5. }  
      这个函数定义在文件external/chromium_org/content/browser/android/in_process/synchronous_compositor_impl.cc中。

      SynchronousCompositorImpl类的成员函数SetClient将参数compositor_client指向的BrowserViewRenderer对象保存在成员变量compositor_client_中。

      这一步执行完成后，回到前面分析的Java层的AwContents类的构造函数中，这时候就在Native层创建一个WebContents对象、一个AwContents对象、一个SharedRendererState对象、一个BrowserViewRenderer对象，以及一个SynchronousCompositorImpl对象。这些对象后面在启动Chromium渲染引擎的Render端，以及Chromium渲染引擎的Render端渲染网页UI时，都会使用到。

       Java层的AwContents类的构造函数接下来会调用另外一个成员函数setNewAwContents在Native层创建一个ContentViewCore对象，如下所示：

[java]  view plain  copy
  1. public class AwContents {  
  2.     ......  
  3.   
  4.     private void setNewAwContents(long newAwContentsPtr) {  
  5.         ......  
  6.   
  7.         mNativeAwContents = newAwContentsPtr;  
  8.         ......  
  9.   
  10.         long nativeWebContents = nativeGetWebContents(mNativeAwContents);  
  11.         mContentViewCore = createAndInitializeContentViewCore(  
  12.                 mContainerView, mContext, mInternalAccessAdapter, nativeWebContents,  
  13.                 new AwGestureStateListener(), mContentViewClient, mZoomControls);  
  14.         .......  
  15.     }  
  16.   
  17.     ......  
  18. }  
       这个函数定义在文件external/chromium_org/android_webview/java/src/org/chromium/android_webview/AwContents.java中。

       从前面的调用过程可以知道，参数newAwContentsPtr描述的是前面在Native层创建的AwContents对象。这个AwContents对象将会保存在AwContents类的成员变量mNativeAwContents中。

        AwContents类的成员函数setNewAwContents接下来又会调用另外一个成员函数nativeGetWebContents获得用来创建上述Native层AwContents对象所使用的一个WebContents对象。有了这个WebContents对象之后，就使用它来在Native层创建一个ContentViewCore对象。这是通过调用AwContents类的成员函数createAndInitializeContentViewCore实现的，如下所示：

[java]  view plain  copy
  1. public class AwContents {  
  2.     ......  
  3.   
  4.     private static ContentViewCore createAndInitializeContentViewCore(ViewGroup containerView,  
  5.             Context context, InternalAccessDelegate internalDispatcher, long nativeWebContents,  
  6.             GestureStateListener gestureStateListener,  
  7.             ContentViewClient contentViewClient,  
  8.             ContentViewCore.ZoomControlsDelegate zoomControlsDelegate) {  
  9.         ContentViewCore contentViewCore = new ContentViewCore(context);  
  10.         contentViewCore.initialize(containerView, internalDispatcher, nativeWebContents,  
  11.                 context instanceof Activity ?  
  12.                         new ActivityWindowAndroid((Activity) context) :  
  13.                         new WindowAndroid(context.getApplicationContext()));  
  14.         ......  
  15.         return contentViewCore;  
  16.     }  
  17.   
  18.     ......  
  19. }  
       这个函数定义在文件external/chromium_org/android_webview/java/src/org/chromium/android_webview/AwContents.java中。

       AwContents类的成员函数createAndInitializeContentViewCore首先会创建一个Java层的ContentViewCore对象，然后再调用这个Java层的ContentViewCore对象的成员函数initialize对它进行初始化。在初始化的过程中，就会在Native层创建一个对应的ContentViewCore对象，如下所示：

[java]  view plain  copy
  1. public class ContentViewCore  
  2.         implements NavigationClient, AccessibilityStateChangeListener, ScreenOrientationObserver {  
  3.     ......  
  4.   
  5.     public void initialize(ViewGroup containerView, InternalAccessDelegate internalDispatcher,  
  6.             long nativeWebContents, WindowAndroid windowAndroid) {  
  7.         ......  
  8.   
  9.         mNativeContentViewCore = nativeInit(  
  10.                 nativeWebContents, viewAndroidNativePointer, windowNativePointer,  
  11.                 mRetainedJavaScriptObjects);  
  12.         
  13.         ......  
  14.     }  
  15.   
  16.     ......  
  17. }  
       这个函数定义在文件external/chromium_org/content/public/android/java/src/org/chromium/content/browser/ContentViewCore.java中。

       ContentViewCore类的成员函数initialize会调用另外一个成员函数nativeInit在Native层创建一个ContentViewCore对象，并且保存在成员变量mNativeContentViewCore中。在创建这个Native层的ContentViewCore对象的时候，需要使用到参数nativeWebContents描述的一个Native层的WebContents对象。

       ContentViewCore类的成员函数nativeInit是一个JNI方法，它由C++层的函数Java_com_android_org_chromium_content_browser_ContentViewCore_nativeInit实现，如下所示：

[cpp]  view plain  copy
  1. __attribute__((visibility("default")))  
  2. jlong  
  3.     Java_com_android_org_chromium_content_browser_ContentViewCore_nativeInit(JNIEnv*  
  4.     env, jobject jcaller,  
  5.     jlong webContentsPtr,  
  6.     jlong viewAndroidPtr,  
  7.     jlong windowAndroidPtr,  
  8.     jobject retainedObjectSet) {  
  9.   return Init(env, jcaller, webContentsPtr, viewAndroidPtr, windowAndroidPtr,  
  10.       retainedObjectSet);  
  11. }  
      这个函数定义在文件out/target/product/generic/obj/GYP/shared_intermediates/content/jni/ContentViewCore_jni.h中。

      函数Java_com_android_org_chromium_content_browser_ContentViewCore_nativeInit调用另外一个函数Init在Native层创建一个ContentViewCore对象，如下所示：

[cpp]  view plain  copy
  1. jlong Init(JNIEnv* env,  
  2.            jobject obj,  
  3.            jlong native_web_contents,  
  4.            jlong view_android,  
  5.            jlong window_android,  
  6.            jobject retained_objects_set) {  
  7.   ContentViewCoreImpl* view = new ContentViewCoreImpl(  
  8.       env, obj,  
  9.       reinterpret_cast<WebContents*>(native_web_contents),  
  10.       reinterpret_cast<ui::ViewAndroid*>(view_android),  
  11.       reinterpret_cast<ui::WindowAndroid*>(window_android),  
  12.       retained_objects_set);  
  13.   return reinterpret_cast<intptr_t>(view);  
  14. }  
       这个函数定义在文件external/chromium_org/content/browser/android/content_view_core_impl.cc中。

       从这里可以看到，函数Init会使用参数native_web_contents描述的一个WebContents对象以及其它参数在Native层创建一个ContentViewCoreImpl对象。 ContentViewCoreImpl类是从ContentViewCore继承下来的。  

       ContentViewCoreImpl对象的创建过程，也就是ContentViewCoreImpl类的构造函数的实现，如下所示：

[cpp]  view plain  copy
  1. ContentViewCoreImpl::ContentViewCoreImpl(  
  2.     JNIEnv* env,  
  3.     jobject obj,  
  4.     WebContents* web_contents,  
  5.     ui::ViewAndroid* view_android,  
  6.     ui::WindowAndroid* window_android,  
  7.     jobject java_bridge_retained_object_set)  
  8.     : ......,  
  9.       web_contents_(static_cast<WebContentsImpl*>(web_contents)),  
  10.       ...... {  
  11.   ......  
  12. }  
       这个函数定义在文件external/chromium_org/content/browser/android/content_view_core_impl.cc中。

       ContentViewCoreImpl类的构造函数会将参数web_contents指向的一个WebContents对象保存在成员变量web_contents_中。以后通过ContentViewCoreImpl类的成员函数LoadUrl加载指定的URL时，就需要使用到这个WebContents对象。

       在Java层创建了一个AwContents对象和在Native层创建了一个WebContents对象和一个ContentViewCore对象之后，接下来我们就可以在Android WebView中加载指定的URL了。Android WebView又会请求Chromium渲染引擎启动一个Render端，并且在这个Render端中加载指定的URL。接下来，我们就从Android WebView中加载URL开始，分析Chromium渲染引擎启动Render端的过程。

       Android WebView提供了一个成员函数loadUrl，用来加载指定的URL，如下所示：

[java]  view plain  copy
  1. public class WebView extends AbsoluteLayout  
  2.         implements ViewTreeObserver.OnGlobalFocusChangeListener,  
  3.         ViewGroup.OnHierarchyChangeListener, ViewDebug.HierarchyHandler {  
  4.     ......  
  5.   
  6.     public void loadUrl(String url) {  
  7.         checkThread();  
  8.         if (DebugFlags.TRACE_API) Log.d(LOGTAG, "loadUrl=" + url);  
  9.         mProvider.loadUrl(url);  
  10.     }  
  11.   
  12.     ......  
  13. }  
       这个函数定义在文件frameworks/base/core/java/android/webkit/WebView.java中。

       WebView类的成员函数loadUrl首先调用成员函数checkThread检查当前线程是否是创建WebView的线程。如果不是，那么就会抛出一个异常出来。

       从前面Android WebView加载Chromium动态库的过程分析一文可以知道，WebView类的成员变量mProvider指向的是一个WebViewChromium对象。如果通过前面检查，那么接下来这个WebViewChromium对象的成员函数loadUrl会被调用，用来加载参数url指定的URL，如下所示：

[java]  view plain  copy
  1. class WebViewChromium implements WebViewProvider,  
  2.           WebViewProvider.ScrollDelegate, WebViewProvider.ViewDelegate {  
  3.     ......  
  4.   
  5.     @Override  
  6.     public void loadUrl(String url) {  
  7.         // Early out to match old WebView implementation  
  8.         if (url == null) {  
  9.             return;  
  10.         }  
  11.         loadUrl(url, null);  
  12.     }  
  13.   
  14.     ......  
  15. }  
       这个函数定义在文件frameworks/webview/chromium/java/com/android/webview/chromium/WebViewChromium.java中。

       WebViewChromium类的成员函数loadUrl调用另外一个重载版本的成员函数loadUrl加载参数url指定的URL，如下所示：

[java]  view plain  copy
  1. class WebViewChromium implements WebViewProvider,  
  2.           WebViewProvider.ScrollDelegate, WebViewProvider.ViewDelegate {  
  3.     ......  
  4.   
  5.     @Override  
  6.     public void loadUrl(final String url, Map<String, String> additionalHttpHeaders) {  
  7.         ......  
  8.   
  9.         LoadUrlParams params = new LoadUrlParams(url);  
  10.         if (additionalHttpHeaders != null) params.setExtraHeaders(additionalHttpHeaders);  
  11.         loadUrlOnUiThread(params);  
  12.     }  
  13.   
  14.     ......  
  15. }  
       这个函数定义在文件frameworks/webview/chromium/java/com/android/webview/chromium/WebViewChromium.java中。

       WebViewChromium类重载版本的成员函数loadUrl将参数url和additinalHttpHeaders封装一个LoadUrlParams对象中，然后再传这个LoadUrlParams对象传递给另外一个成员函数loadUrlonUiThread，如下所示：

[java]  view plain  copy
  1. class WebViewChromium implements WebViewProvider,  
  2.           WebViewProvider.ScrollDelegate, WebViewProvider.ViewDelegate {  
  3.     ......  
  4.   
  5.     private void loadUrlOnUiThread(final LoadUrlParams loadUrlParams) {  
  6.         ......  
  7.         if (checkNeedsPost()) {  
  8.             // Disallowed in WebView API for apps targetting a new SDK  
  9.             assert mAppTargetSdkVersion < Build.VERSION_CODES.JELLY_BEAN_MR2;  
  10.             mRunQueue.addTask(new Runnable() {  
  11.                 @Override  
  12.                 public void run() {  
  13.                     mAwContents.loadUrl(loadUrlParams);  
  14.                 }  
  15.             });  
  16.             return;  
  17.         }  
  18.         mAwContents.loadUrl(loadUrlParams);  
  19.     }  
  20.   
  21.     ......  
  22. }  
       这个函数定义在文件frameworks/webview/chromium/java/com/android/webview/chromium/WebViewChromium.java中。

       WebViewChromium类的成员函数LoadUrlParams会调用成员函数checkNeedsPost检查当前线程是否就是WebView的创建线程。如果不是，并且当前的Android版本小于4.3，那么就会向WebView的创建线程的消息队列发送一个Runnable。当该Runnable被执行的时候，才会调用WebViewChromium类的成员变量mAwContents指向的一个AwContents对象的成员函数loadUrl加载参数loadUrlParam描述的URL。

       注意，如果当前线程不是WebView的创建线程，并且当前的Android版本大于等于4.3，那么WebViewChromium类的成员函数LoadUrlParams是不允许调用的。在我们这个情景中，前面已经保证了当前线程就是WebView的创建线程。在这种情况下，WebViewChromium类的成员函数LoadUrlParams就会直接调用成员变量mAwContents指向的一个AwContents对象的成员函数loadUrl加载参数loadUrlParam描述的URL，如下所示：

[java]  view plain  copy
  1. public class AwContents {  
  2.     ......  
  3.   
  4.     public void loadUrl(LoadUrlParams params) {  
  5.         ......  
  6.   
  7.         mContentViewCore.loadUrl(params);  
  8.   
  9.         ......  
  10.     }  
  11.   
  12.     ......  
  13. }  
       这个函数定义在文件external/chromium_org/android_webview/java/src/org/chromium/android_webview/AwContents.java中。

       从前面的分析可以知道，AwContents类的成员变量mContentViewCore指向的是一个ContentViewCore对象。AwContents类的成员函数loadUrl调用这个ContentViewCore对象的成员函数loadUrl加载参数params描述的URL。

       ContentViewCore类的成员函数loadUrl加载指定URL的过程可以参考前面Chromium网页Frame Tree创建过程分析一文。在加载的过程中，会创建一个RenderViewHostImpl对象。从前面Chromium的Render进程启动过程分析一文又可以知道，在创建这个RenderViewHostImpl对象的过程中，又会创建一个RenderProcessHostImpl对象描述一个Render端。接下来这个RenderProcessHostImpl对象的成员函数Init又会被调用。在调用的过程中，它就会判断是要创建一个Render进程还是一个Render线程描述一个Render端，如下所示：

[cpp]  view plain  copy
  1. bool RenderProcessHostImpl::Init() {      
  2.   ......    
  3.     
  4.   if (run_renderer_in_process()) {    
  5.     ......    
  6.     in_process_renderer_.reset(g_renderer_main_thread_factory(channel_id));    
  7.     
  8.     base::Thread::Options options;    
  9.     ......    
  10.     options.message_loop_type = base::MessageLoop::TYPE_DEFAULT;    
  11.         
  12.     in_process_renderer_->StartWithOptions(options);    
  13.     ......    
  14.   } else {    
  15.     ......    
  16.     
  17.     child_process_launcher_.reset(new ChildProcessLauncher(    
  18.         new RendererSandboxedProcessLauncherDelegate(channel_.get()),    
  19.         cmd_line,    
  20.         GetID(),    
  21.         this));    
  22.     
  23.     ......    
  24.   }    
  25.     
  26.   return true;    
  27. }    
       这个函数定义在文件external/chromium_org/content/browser/renderer_host/render_process_host_impl.cc中。

       RenderProcessHostImpl类的成员函数Init调用另外一个成员函数run_renderer_in_process判断要创建一个Render进程还是一个Render线程描述一个Render端。

       RenderProcessHostImpl类的成员函数run_renderer_in_process是从父类RenderProcessHost继承下来的，它的实现如下所示：

[cpp]  view plain  copy
  1. bool g_run_renderer_in_process_ = false;  
  2.   
  3. ......  
  4.   
  5. bool RenderProcessHost::run_renderer_in_process() {  
  6.   return g_run_renderer_in_process_;  
  7. }  
      这个函数定义在文件external/chromium_org/content/browser/renderer_host/render_process_host_impl.cc中。

      RenderProcessHostImpl类的成员函数run_renderer_in_process返回的是全局变量g_run_renderer_in_process_的值。从前面的分析可以知道，这个全局变量g_run_renderer_in_process_已经被Android WebView设置为true。因此，RenderProcessHostImpl类的成员函数Init会创建一个Render线程来描述一个Render端。

      这个Render线程是通过调用另外一个全局变量g_renderer_main_thread_factory描述的一个线程创建工厂函数创建的。从前面的分析可以知道，这个全局变量g_renderer_main_thread_factory描述的线程创建工厂函数为CreateInProcessRendererThread，它的实现如下所示：

[cpp]  view plain  copy
  1. base::Thread* CreateInProcessRendererThread(const std::string& channel_id) {  
  2.   return new InProcessRendererThread(channel_id);  
  3. }  
       这个函数定义在文件external/chromium_org/content/renderer/in_process_renderer_thread.cc中。

       从这里可以看到，函数为CreateInProcessRendererThread创建的是一个InProcessRendererThread对象。这个InProcessRendererThread对象描述的是一个类型为In-Process的Render线程。这个Render线程在RenderProcessHostImpl类的成员函数Init中将会被启动起来。这时候Android WebView就将Chromium渲染引擎的Render端启动起来了。

       最后，我们分析Chromium渲染引擎的GPU端。由于Android WebView要求Chromium渲染引擎使用App的Render Thread来执行GPU命令，因此Chromium渲染引擎的GPU端是通过App的Render Thread描述的，它的启动过程可以参考前面Android应用程序UI硬件加速渲染技术简要介绍和学习计划这个系列的文章。

       为了让Chromium渲染引擎可以使用App的Render Thread执行GPU命令，Chromium的android_webview模块会创建一个DeferredGpuCommandService服务。这个DeferredGpuCommandService服务将会负责请求App的Render Thread执行Chromium渲染引擎的Render端和Browser端发出来的GPU命令。接下来我们就分析这个DeferredGpuCommandService服务的创建过程。

       DeferredGpuCommandService服务是在Android WebView的成员函数onDraw被App的UI线程调用时创建的，因此接下来我们就从Android WebView的成员函数onDraw开始分析DeferredGpuCommandService服务的创建过程，如下所示：

[java]  view plain  copy
  1. public class WebView extends AbsoluteLayout  
  2.         implements ViewTreeObserver.OnGlobalFocusChangeListener,  
  3.         ViewGroup.OnHierarchyChangeListener, ViewDebug.HierarchyHandler {  
  4.     ......  
  5.   
  6.     @Override  
  7.     protected void onDraw(Canvas canvas) {  
  8.         mProvider.getViewDelegate().onDraw(canvas);  
  9.     }  
  10.   
  11.     ......  
  12. }  
       这个函数定义在文件frameworks/base/core/java/android/webkit/WebView.java中。

       前面提到，WebView类的成员变量mProvider指向的是一个WebViewChromium对象。WebView的成员函数onDraw调用这个WebViewChromium对象的成员函数getViewDelegate获得一个View Delegate，如下所示：

[java]  view plain  copy
  1. class WebViewChromium implements WebViewProvider,  
  2.           WebViewProvider.ScrollDelegate, WebViewProvider.ViewDelegate {  
  3.     ......  
  4.   
  5.     @Override  
  6.     // This needs to be kept thread safe!  
  7.     public WebViewProvider.ViewDelegate getViewDelegate() {  
  8.         return this;  
  9.     }  
  10.   
  11.     ......  
  12. }  
       这个函数定义在文件frameworks/webview/chromium/java/com/android/webview/chromium/WebViewChromium.java中。

       从这里可以看到，WebViewChromium类的成员函数getViewDelegate返回的View Delegate就是当前正在处理的WebViewChromium对象。这个WebViewChromium对象返回给WebView类的成员函数onDraw之后，它的成员函数onDraw就会被调用，如下所示：

[java]  view plain  copy
  1. class WebViewChromium implements WebViewProvider,  
  2.           WebViewProvider.ScrollDelegate, WebViewProvider.ViewDelegate {  
  3.     ......  
  4.   
  5.     @Override  
  6.     public void onDraw(final Canvas canvas) {  
  7.         ......  
  8.         if (checkNeedsPost()) {  
  9.             runVoidTaskOnUiThreadBlocking(new Runnable() {  
  10.                 @Override  
  11.                 public void run() {  
  12.                     onDraw(canvas);  
  13.                 }  
  14.             });  
  15.             return;  
  16.         }  
  17.         mAwContents.onDraw(canvas);  
  18.     }  
  19.   
  20.     ......  
  21. }  
       这个函数定义在文件frameworks/webview/chromium/java/com/android/webview/chromium/WebViewChromium.java中。

       WebViewChromium类的成员函数onDraw首先会调用成员函数checkNeedsPost检查当前线程是否就是WebView的创建线程。如果不是，那么就会向WebView的创建线程的消息队列发送一个Runnable。当该Runnable被执行的时候，才会重新进入WebViewChromium类的成员函数onDraw中，并且调用它的成员变量mAwContents指向的一个AwContents对象的成员函数onDraw，用来绘制网页的UI。

       如果当前线程就是WebView的创建线程，那么WebViewChromium类的成员函数onDraw就会直接调用成员变量mAwContents指向的一个AwContents对象的成员函数onDraw绘制网页的UI。

       AwContents类的成员函数onDraw的实现如下所示：

[java]  view plain  copy
  1. public class AwContents {  
  2.     ......  
  3.   
  4.     public void onDraw(Canvas canvas) {  
  5.         mAwViewMethods.onDraw(canvas);  
  6.     }  
  7.   
  8.     ......  
  9. }  
       这个函数定义在文件external/chromium_org/android_webview/java/src/org/chromium/android_webview/AwContents.java中。

       AwContents类的成员变量mAwViewMethods指向的是一个AwViewMethodsImpl对象。AwContents类的成员函数onDraw调用这个AwViewMethodsImpl对象的成员函数onDraw绘制网页的UI，如下所示：

[java]  view plain  copy
  1. public class AwContents {  
  2.     ......  
  3.   
  4.     private long mNativeAwContents;  
  5.     ......  
  6.    
  7.     private class AwViewMethodsImpl implements AwViewMethods {  
  8.         ......  
  9.   
  10.         @Override  
  11.         public void onDraw(Canvas canvas) {  
  12.             ......  
  13.   
  14.             if (!nativeOnDraw(mNativeAwContents, canvas, canvas.isHardwareAccelerated(),  
  15.                     mContainerView.getScrollX(), mContainerView.getScrollY(),  
  16.                     globalVisibleRect.left, globalVisibleRect.top,  
  17.                     globalVisibleRect.right, globalVisibleRect.bottom)) {  
  18.                 ......  
  19.             }  
  20.   
  21.             ......  
  22.         }  
  23.   
  24.         ......  
  25.     }  
  26.   
  27.     ......  
  28. }  
       这个函数定义在文件external/chromium_org/android_webview/java/src/org/chromium/android_webview/AwContents.java中。

       AwViewMethodsImpl类的成员函数onDraw会调用外部类AwContents的成员函数nativeOnDraw绘制网页的UI，并且会将外部类的成员变量mNativeAwContents描述的一个Native层的AwContents对象传递给它。

       AwContents类的成员函数nativeOnDraw是一个JNI方法，它由C++层的函数Java_com_android_org_chromium_android_1webview_AwContents_nativeOnDraw实现，如下所示：

[cpp]  view plain  copy
  1. __attribute__((visibility("default")))  
  2. jboolean  
  3.     Java_com_android_org_chromium_android_1webview_AwContents_nativeOnDraw(JNIEnv*  
  4.     env,  
  5.     jobject jcaller,  
  6.     jlong nativeAwContents,  
  7.     jobject canvas,  
  8.     jboolean isHardwareAccelerated,  
  9.     jint scrollX,  
  10.     jint scrollY,  
  11.     jint visibleLeft,  
  12.     jint visibleTop,  
  13.     jint visibleRight,  
  14.     jint visibleBottom) {  
  15.   AwContents* native = reinterpret_cast<AwContents*>(nativeAwContents);  
  16.   CHECK_NATIVE_PTR(env, jcaller, native, "OnDraw", false);  
  17.   return native->OnDraw(env, jcaller, canvas, isHardwareAccelerated, scrollX,  
  18.       scrollY, visibleLeft, visibleTop, visibleRight, visibleBottom);  
  19. }  
       这个函数定义在文件out/target/product/generic/obj/GYP/shared_intermediates/android_webview/jni/AwContents_jni.h中。

       函数Java_com_android_org_chromium_android_1webview_AwContents_nativeOnDraw调用参数nativeAwContents描述的一个Native层AwContents对象的成员函数OnDraw绘制网页的UI，如下所示：

[cpp]  view plain  copy
  1. bool AwContents::OnDraw(JNIEnv* env,  
  2.                         jobject obj,  
  3.                         jobject canvas,  
  4.                         jboolean is_hardware_accelerated,  
  5.                         jint scroll_x,  
  6.                         jint scroll_y,  
  7.                         jint visible_left,  
  8.                         jint visible_top,  
  9.                         jint visible_right,  
  10.                         jint visible_bottom) {  
  11.   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));  
  12.   if (is_hardware_accelerated)  
  13.     InitializeHardwareDrawIfNeeded();  
  14.   return browser_view_renderer_.OnDraw(  
  15.       canvas,  
  16.       is_hardware_accelerated,  
  17.       gfx::Vector2d(scroll_x, scroll_y),  
  18.       gfx::Rect(visible_left,  
  19.                 visible_top,  
  20.                 visible_right - visible_left,  
  21.                 visible_bottom - visible_top));  
  22. }  
       这个函数定义在文件external/chromium_org/android_webview/native/aw_contents.cc中。

       参数is_hardware_accelerated表示App的UI是否采用硬件加速方式绘制。如果是的话，那么Chromium也会使用硬件加速方式绘制网页的UI。在这种情况下，AwContents类的成员函数OnDraw首先会调用另外一个成员函数InitializeHardwareDrawIfNeeded检查是否需要为Chromium初始化一个硬件加速渲染环境。这个硬件加速渲染环境初始化完成后，AwContents类的成员函数OnDraw才会调用成员变量browser_view_renderer_描述的一个BrowserViewRenderer对象的成员函数OnDraw绘制网页的UI。

       AwContents类的成员函数InitializeHardwareDrawIfNeeded在为Chromium初始化硬件加速渲染环境的过程中，就会创建一个DeferredGpuCommandService服务，如下所示：

[cpp]  view plain  copy
  1. void AwContents::InitializeHardwareDrawIfNeeded() {  
  2.   GLViewRendererManager* manager = GLViewRendererManager::GetInstance();  
  3.   
  4.   base::AutoLock lock(render_thread_lock_);  
  5.   if (renderer_manager_key_ == manager->NullKey()) {  
  6.     renderer_manager_key_ = manager->PushBack(&shared_renderer_state_);  
  7.     DeferredGpuCommandService::SetInstance();  
  8.   }  
  9. }  
       这个函数定义在文件external/chromium_org/android_webview/native/aw_contents.cc中。

       在Chromium渲染引擎中，存在一个GLViewRendererManager单例对象。这个GLViewRendererManager单例对象可以通过调用GLViewRendererManager类的静态成员函数GetInstance获得，它用来记录当前有哪些WebView是采用硬件加速方式绘制的。

       AwContents类的成员函数InitializeHardwareDrawIfNeeded会检查成员变量renderer_manager_key_的值是否等于一个Null Key。如果等于的话，那么就说明当前正在绘制的WebView还没有初始化过硬件加速渲染环境。这时候AwContents类的成员函数InitializeHardwareDrawIfNeeded就会将成员变量shared_renderer_state_描述的一个SharedRendererState对象添加到上述GLViewRendererManager单例对象中。添加之后，会获得一个Key。这个Key就保存在AwContents类的成员变量renderer_manager_key_。同时，DeferredGpuCommandService类的静态成员函数SetInstance会被调用，用来创建一个DeferredGpuCommandService服务。这时候就表示当前正在绘制的WebView的硬件加速渲染环境初始化好了。

        接下来我们继续分析DeferredGpuCommandService类的静态成员函数SetInstance会创建ferredGpuCommandService服务的过程，如下所示：

[cpp]  view plain  copy
  1. base::LazyInstance<scoped_refptr<DeferredGpuCommandService> >  
  2.     g_service = LAZY_INSTANCE_INITIALIZER;  
  3.   
  4. ......  
  5.   
  6. void DeferredGpuCommandService::SetInstance() {  
  7.   if (!g_service.Get()) {  
  8.     g_service.Get() = new DeferredGpuCommandService;  
  9.     content::SynchronousCompositor::SetGpuService(g_service.Get());  
  10.   }  
  11. }  
  12.   
  13. ......  
  14.   
  15. DeferredGpuCommandService* DeferredGpuCommandService::GetInstance() {  
  16.   DCHECK(g_service.Get().get());  
  17.   return g_service.Get().get();  
  18. }  
       这个函数定义在文件external/chromium_org/android_webview/browser/deferred_gpu_command_service.cc中。

       DeferredGpuCommandService类的静态成员函数SetInstance检查全局变量g_service是否已经指向了一个DeferredGpuCommandService对象。如果还没有指向，那么就会创建一个DeferredGpuCommandService对象让它指向。创建出来的DeferredGpuCommandService对象描述的就是一个DeferredGpuCommandService服务。这个DeferredGpuCommandService服务可以通过调用DeferredGpuCommandService类的静态成员函数GetInstance获得。

       DeferredGpuCommandService类的静态成员函数SetInstance创建出来的DeferredGpuCommandService服务会被设置为Android WebView绘制网页所使用的Synchronous Compositor的GPU服务，这是通过调用SynchronousCompositor类的静态成员函数SetGpuService实现的，如下所示：

[cpp]  view plain  copy
  1. base::LazyInstance<synchronouscompositorfactoryimpl>::Leaky g_factory =  
  2.     LAZY_INSTANCE_INITIALIZER;  
  3.   
  4. ......  
  5.   
  6. void SynchronousCompositor::SetGpuService(  
  7.     scoped_refptr<gpu::InProcessCommandBuffer::Service> service) {  
  8.   g_factory.Get().SetDeferredGpuService(service);  
  9. }  

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

       全局变量g_factory描述的是一个SynchronousCompositorFactoryImpl对象，SynchronousCompositor类的静态成员函数SetGpuService会将参数service描述的一个DeferredGpuCommandService服务保存在它内部。这个通过调用它的成员函数SetDeferredGpuService实现的，如下所示

[cpp]  view plain  copy
  1. void SynchronousCompositorFactoryImpl::SetDeferredGpuService(  
  2.     scoped_refptr<gpu::InProcessCommandBuffer::Service> service) {  
  3.   DCHECK(!service_);  
  4.   service_ = service;  
  5. }  
       这个函数定义在文件external/chromium_org/content/browser/android/in_process/synchronous_compositor_factory_impl.cc中。

       SynchronousCompositorFactoryImpl类的成员函数SetDeferredGpuService将参数service描述的一个DeferredGpuCommandService服务保存在成员变量service_。

       这一步执行完成后，Chromium渲染引擎的Render端以后就会通过保存在SynchronousCompositorFactoryImpl类的成员变量service_中的DeferredGpuCommandService服务来执行GPU命令。这一点我们在接下来一篇文章中再详细分析。

       至此，我们就分析完成了Android WebView启动Chromium渲染引擎的过程，主要就是启动的Chromium渲染引擎的Browser端和Render端。其中，Browser端对应的就是App的UI线程，而Render端对应的是一个类型为In-Process的Render线程。

       由于Android WebView要求Chromium渲染引擎使用App的Render Thread执行GPU命令，因此Chromium渲染引擎就不会创建自己的GPU端。不过，它会创建一个DeferredGpuCommandService服务，用来将Chromium渲染引擎发出的GPU命令交给App的Render Thread执行。在接下来一篇文章中，我们就详细分析Chromium渲染引擎执行GPU命令的过程。

上一篇 下一篇
优秀的个人博客,低调大师

微信关注我们

原文链接：https://yq.aliyun.com/articles/65318

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

安卓勒索软件进一步扩散

勒索软件在网络中有着自己的一种“魅力”，自2014年从多平台开始不断的增长。安卓用户已经成为各种勒索软件的目标，最常见的就是假冒警察去吓唬那些受害者要收缴他们设备上的非法内容。 最流行的网络攻击媒介“网络诈骗”从开始流行到现在一直没有改变。这是滥用非官方市场和论坛去传播推荐或者变异的恶意代码造成的。 但从2016以来网络上的犯罪分子的手法更多，更加老练的去用恶意工具。攻击者试图进入更深入的payloads中的应用中（ex.kali）.要做到这一点，他们会对其加密，然后移动到重要的文件夹里，他们通常应用到应用程序所必须的图片或者其他内容中。这些程序在外表看起来没有什么异常，但是在内部有个解密器可以加密解密和执行勒索动作。 杀毒软件的专家也证实恶意软件会通过邮件传播。攻击者还利用社会工程学去让受害者点击恶意链接，来感染到他们的APK应用上。 今年观察到一个有趣的现象，就是jsut恶意软件运营商在中国的发展迅速并使用人民币来直接缴纳赎金。 如果你想要知道更多关于安卓恶意软件的新走向内容，XXX广告。除此之外，杀毒软件专家还会近期讨论恶意软件和勒索软件对银行系统的影响。
2016-12-05
682
上一篇

【直播预告】云栖直播：阿里热修复产品HotFix2.0升级详解

全面——你知道吗？1891年，卡尔森纳做出的第一把瑞士军刀，只有螺丝刀和开罐器。经过一代又一代能工巧匠的打磨，这把刀陆续增加了锯子、剪刀、镊子、放大镜、改锥，甚至内藏激光、LED手电筒、USB记忆碟等功能。 稳定——你知道吗？公元前1500多年前，埃及人就已经用绳子和竖棍做成了简易天平，成为现代天平的雏型。天平是平衡的象征，托盘内不断增加的砝码，更是自信与质量的保障。 精准——你知道吗？1608年，荷兰眼镜商汉斯·利伯希用两块镜片发明了人类历史上第一架望远镜，随着技术的发展，大千世界在人类的探索下无所遁形。射电望远镜，更是将观测目标锁定在直径10万光年的银河系边缘。 热修复技术一直在移动开发领域颇受关注，在行业的推动下不断发展和完善，随着后移动互联网时代的到来，这项技术越来越多的被APP开发者所使用，从内测到公测，从1.0到2.0
2016-12-06
616
下一篇

相关文章

发表评论

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2025-12-12 大小: 211.28KB 下载: 54次
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2025-12-28 大小: 1MB 下载: 4次
Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2025-12-21 大小: 189MB 下载: 2次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次
手机查看

扫码在手机上查看文章

扫描二维码，手机阅读更方便

热门标签
OpenAi SpringBoot4 Redis Kubernetes DeepSeek Service Mesh Rocky Nacos3 Docker SpringCloud Jdk25 HarmonyOS6 Gemini3

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册