Establish MojoChildConnection from BrowserChildProcessHostImpl

content/browser/mojo/mojo_shell_context.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/mojo/mojo_shell_context.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 57 matching lines @@
                                      base::Passed(GetProxy(&service_factory)),
                                      process_name, use_sandbox));
   service_factory->CreateService(std::move(request), service_name);
 }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 
 // Request shell::mojom::ServiceFactory from GPU process host. Must be called on
 // IO thread.
 void RequestGpuServiceFactory(shell::mojom::ServiceFactoryRequest request) {
-  BrowserChildProcessHostDelegate* process_host =
+  GpuProcessHost* process_host =
       GpuProcessHost::Get(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED);
   if (!process_host) {
     DLOG(ERROR) << "GPU process host not available.";
     return;
   }
 
   // TODO(xhwang): It's possible that |process_host| is non-null, but the actual
   // process is dead. In that case, |request| will be dropped and application
   // load requests through ServiceFactory will also fail. Make sure we handle
   // these cases correctly.
@@ skipping 85 matching lines @@
  private:
   friend class base::RefCountedThreadSafe<InProcessServiceManagerContext>;
 
   ~InProcessServiceManagerContext() {}
 
   void StartOnIOThread(
       std::unique_ptr<BuiltinManifestProvider> manifest_provider,
       shell::mojom::ServicePtrInfo embedder_service_proxy_info) {
     manifest_provider_ = std::move(manifest_provider);
 
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
-        BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE);
+    base::SequencedWorkerPool* blocking_pool = BrowserThread::GetBlockingPool();
     std::unique_ptr<shell::NativeRunnerFactory> native_runner_factory(
-        new shell::InProcessNativeRunnerFactory(
-            BrowserThread::GetBlockingPool()));
-    catalog_.reset(new catalog::Catalog(
-        file_task_runner.get(), nullptr, manifest_provider_.get()));
+        new shell::InProcessNativeRunnerFactory(blocking_pool));
+    catalog_.reset(
+        new catalog::Catalog(blocking_pool, nullptr, manifest_provider_.get()));
     service_manager_.reset(new shell::ServiceManager(
         std::move(native_runner_factory), catalog_->TakeService()));
 
     shell::mojom::ServiceRequest request =
         service_manager_->StartEmbedderService(kBrowserMojoApplicationName);
     mojo::FuseInterface(
         std::move(request), std::move(embedder_service_proxy_info));
   }
 
   void ShutDownOnIOThread() {
     service_manager_.reset();
     catalog_.reset();
     manifest_provider_.reset();
   }
 
   std::unique_ptr<BuiltinManifestProvider> manifest_provider_;
   std::unique_ptr<catalog::Catalog> catalog_;
   std::unique_ptr<shell::ServiceManager> service_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(InProcessServiceManagerContext);
 };
 
-
 MojoShellContext::MojoShellContext() {
   shell::mojom::ServiceRequest request;
   if (shell::ShellIsRemote()) {
     mojo::edk::SetParentPipeHandleFromCommandLine();
     request = shell::GetServiceRequestFromCommandLine();
   } else {
     // Allow the embedder to register additional Mojo application manifests
     // beyond the default ones below.
     std::unique_ptr<ContentBrowserClient::MojoApplicationManifestMap> manifests(
         new ContentBrowserClient::MojoApplicationManifestMap);
     GetContentClient()->browser()->RegisterMojoApplicationManifests(
         manifests.get());
     std::unique_ptr<BuiltinManifestProvider> manifest_provider =
         base::MakeUnique<BuiltinManifestProvider>();
     manifest_provider->AddManifests(std::move(manifests));
     manifest_provider->AddManifestResource(kBrowserMojoApplicationName,
                                            IDR_MOJO_CONTENT_BROWSER_MANIFEST);
     manifest_provider->AddManifestResource(kGpuMojoApplicationName,
                                            IDR_MOJO_CONTENT_GPU_MANIFEST);
+    manifest_provider->AddManifestResource(kPluginMojoApplicationName,
+                                           IDR_MOJO_CONTENT_PLUGIN_MANIFEST);
     manifest_provider->AddManifestResource(kRendererMojoApplicationName,
                                            IDR_MOJO_CONTENT_RENDERER_MANIFEST);
     manifest_provider->AddManifestResource(kUtilityMojoApplicationName,
                                            IDR_MOJO_CONTENT_UTILITY_MANIFEST);
     manifest_provider->AddManifestResource("mojo:catalog",
                                            IDR_MOJO_CATALOG_MANIFEST);
     manifest_provider->AddManifestResource(file::kFileServiceName,
                                            IDR_MOJO_FILE_MANIFEST);
 
     in_process_context_ = new InProcessServiceManagerContext;
@@ skipping 54 matching lines @@
     in_process_context_->ShutDown();
 }
 
 // static
 shell::Connector* MojoShellContext::GetConnectorForIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return g_io_thread_connector.Get().get();
 }
 
 }  // namespace content