Revert of 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 67 matching lines @@
   process_control->LoadApplication(app_name, std::move(request),
                                    base::Bind(&OnApplicationLoaded, app_name));
 }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 
 // Request mojom::ProcessControl from GPU process host. Must be called on IO
 // thread.
 void RequestGpuProcessControl(
     mojo::InterfaceRequest<mojom::ProcessControl> request) {
-  GpuProcessHost* process_host =
+  BrowserChildProcessHostDelegate* 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 mojom::ProcessControl will also fail. Make sure we
   // handle
@@ skipping 117 matching lines @@
     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(user_service::kUserServiceName,
                                            IDR_MOJO_PROFILE_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