Support mojo applications in GPU process.

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 "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
+#include "content/browser/gpu/gpu_process_host.h"
+#include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/common/process_control.mojom.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/utility_process_host.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/service_registry.h"
 #include "mojo/application/public/cpp/application_delegate.h"
 #include "mojo/common/url_type_converters.h"
 #include "mojo/package_manager/package_manager_impl.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/connect_to_application_params.h"
 #include "mojo/shell/identity.h"
 #include "mojo/shell/static_application_loader.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_request.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/string.h"
 
 #if defined(ENABLE_MOJO_MEDIA_IN_BROWSER_PROCESS)
 #include "media/mojo/services/mojo_media_application.h"
 #endif
 
 namespace content {
 
 namespace {
 
 // An extra set of apps to register on initialization, if set by a test.
 const MojoShellContext::StaticApplicationMap* g_applications_for_test;
 
-void StartProcessOnIOThread(mojo::InterfaceRequest<ProcessControl> request,
-                            const base::string16& process_name,
-                            bool use_sandbox) {
+void StartUtilityProcessOnIOThread(
+    mojo::InterfaceRequest<ProcessControl> request,
+    const base::string16& process_name,
+    bool use_sandbox) {
   UtilityProcessHost* process_host =
       UtilityProcessHost::Create(nullptr, nullptr);
   process_host->SetName(process_name);
   if (!use_sandbox)
     process_host->DisableSandbox();
   process_host->StartMojoMode();
 
   ServiceRegistry* services = process_host->GetServiceRegistry();
   services->ConnectToRemoteService(request.Pass());
 }
@@ skipping 28 matching lines @@
       : process_name_(process_name), use_sandbox_(use_sandbox) {}
   ~UtilityProcessLoader() override {}
 
  private:
   // mojo::shell::ApplicationLoader:
   void Load(
       const GURL& url,
       mojo::InterfaceRequest<mojo::Application> application_request) override {
     ProcessControlPtr process_control;
     auto process_request = mojo::GetProxy(&process_control);
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&StartProcessOnIOThread, base::Passed(&process_request),
-                   process_name_, use_sandbox_));
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(&StartUtilityProcessOnIOThread,
+                                       base::Passed(&process_request),
+                                       process_name_, use_sandbox_));
     process_control->LoadApplication(url.spec(), application_request.Pass(),
                                      base::Bind(&OnApplicationLoaded, url));
   }
 
   const base::string16 process_name_;
   const bool use_sandbox_;
 
   DISALLOW_COPY_AND_ASSIGN(UtilityProcessLoader);
 };
 
+// Request ProcessControl from GPU process host. Must be called on IO thread.
+void RequestGpuProcessControl(mojo::InterfaceRequest<ProcessControl> request) {
+  BrowserChildProcessHostDelegate* process_host =
+      GpuProcessHost::Get(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
+                          CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH);

[piman, 2015/10/06 19:59:35]

What happens if the GPU process is not launched yet? What happens when the GPU
process dies and is restarted?

[xhwang, 2015/10/07 19:07:58]

Great question. If the process is not launched yet, |process_host| will be null
and the |request| will be dropped. 

Actually I am not familiar with these flags, should whoever needs the GPU
process start it if it's not launched yet? If so, I can add another cause,
something like CAUSE_FOR_GPU_LAUNCH_MOJO_SETUP
When the GPU process dies, all mojo applications hosted in it will be gone and
all clients of those apps (in other processes) will get notified (via a
connection error). It's the client's responsibility to reconnect to the
services. Actually this is a great case where we want to launch the GPU process
if it's not launched yet (on line 112).

[piman, 2015/10/08 22:37:02]

Yes, this is typically what we do in places we need to talk to the GPU process.
See e.g. the code in BrowserGpuChannelHostFactory (in particular
BrowserGpuChannelHostFactory::EstablishRequest::EstablishOnIO).
Ok. Keep in mind that the code to deal with lost GPU processes can be tricky to
avoid races. Some things to keep in mind:
1- a GPU process may be already dead but not known by GpuProcessHost. We detect
the GPU process death by seeing that the channel is lost, typically when sending
an IPC. That means GpuProcessHost::Get may return a non-NULL pointer, but that
GpuProcessHost may be already dead, and further IPCs on the channel will fail.
This is why we have retry logic in
BrowserGpuChannelHostFactory::EstablishRequest
2- it is often the case that 2 subsystems need to communicate to the same GPU
process. When each of these subsystems try to launch the GPU process, but a lost
GPU process happens in the middle, one of the subsystems may get an old,
invalid-but-not-known-yet GpuProcessHost, and the other subsystem may get a
now-valid GpuProcessHost corresponding to a relaunch. One way to detect this is
via the GpuProcessHost::host_id(), which would then be different between the 2.

I don't see code here to handle these cases. I don't know whether (2) is
relevant, though I suspect it will be given the context of the CL. (1) most
likely applies here (for example, could ConnectToRemoteService fail? If so what
happens?).

I'm not going to block the CL on it, but I strongly suggest adding a TODO and/or
filing a bug.

[xhwang, 2015/10/09 23:36:35]

Thanks for all the info! It seems to me in both (1) and (2),
ConnectToRemoteService will fail, and the ServiceRequest will be dropped,
causing a connection error at the client side. The individual client needs to
handle this case.

Added TODO.

+  if (!process_host) {
+    LOG(ERROR) << "GPU process host not available.";

[piman, 2015/10/06 19:59:35]

DLOG

[xhwang, 2015/10/07 19:07:58]

Done.

+    return;
+  }
+
+  ServiceRegistry* service_registry = process_host->GetServiceRegistry();
+  if (!service_registry) {

[piman, 2015/10/06 19:59:35]

When would this be false?

[xhwang, 2015/10/07 19:07:58]

Done.

+    LOG(ERROR) << "ServiceRegistry not available in GPU process host.";

[piman, 2015/10/06 19:59:35]

DLOG

[xhwang, 2015/10/07 19:07:58]

Obsolete now.

+    return;
+  }
+
+  service_registry->ConnectToRemoteService(request.Pass());
+}
+
+// Forwards the load request to the GPU process.
+class GpuProcessLoader : public mojo::shell::ApplicationLoader {
+ public:
+  GpuProcessLoader() {}
+  ~GpuProcessLoader() override {}
+
+ private:
+  // mojo::shell::ApplicationLoader:
+  void Load(
+      const GURL& url,
+      mojo::InterfaceRequest<mojo::Application> application_request) override {
+    ProcessControlPtr process_control;
+    auto process_request = mojo::GetProxy(&process_control);
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&RequestGpuProcessControl, base::Passed(&process_request)));
+    process_control->LoadApplication(url.spec(), application_request.Pass(),
+                                     base::Bind(&OnApplicationLoaded, url));
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(GpuProcessLoader);
+};
+
 }  // namespace
 
 // Thread-safe proxy providing access to the shell context from any thread.
 class MojoShellContext::Proxy {
  public:
   Proxy(MojoShellContext* shell_context)
       : shell_context_(shell_context),
         task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
   ~Proxy() {}
@@ skipping 127 matching lines @@
                             mojo::shell::GetPermissiveCapabilityFilter()));
   params->SetTarget(mojo::shell::Identity(url, std::string(), filter));
   params->set_services(request.Pass());
   params->set_exposed_services(exposed_services.Pass());
   params->set_on_application_end(base::Bind(&base::DoNothing));
   params->set_connect_callback(callback);
   application_manager_->ConnectToApplication(params.Pass());
 }
 
 }  // namespace content