Support mojo applications in GPU process.

content/gpu/gpu_child_thread.cc

 // Copyright (c) 2012 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/gpu/gpu_child_thread.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #include "content/child/child_process.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/gpu_messages.h"
+#include "content/gpu/gpu_process_control_impl.h"
 #include "content/gpu/gpu_watchdog_thread.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/config/gpu_info_collector.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gpu_switching_manager.h"
 
 #if defined(USE_OZONE)
@@ skipping 150 matching lines @@
   return supported_types[0];
 }
 
 void GpuChildThread::Shutdown() {
   ChildThreadImpl::Shutdown();
   logging::SetLogMessageHandler(NULL);
 }
 
 void GpuChildThread::Init(const base::Time& process_start_time) {
   process_start_time_ = process_start_time;
+
+  process_control_.reset(new GpuProcessControlImpl());
+  // Use of base::Unretained(this) is safe here because |service_registry()|
+  // and the message loop will be destroyed before GpuChildThread is destructed.

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

To be clear, does that mean BindProcessControlRequest is called on a separate
thread? If so, can you add comments about this? It sounds like process_control_
is accessed from 2 threads. Is that ok?

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

Sorry I didn't make it clear. BindProcessControlRequest() is only called on the
main/UI thread. I was just saying even if
GpuChildThread::BindProcessControlRequest() is posted to the message loop we are
still okay. But now I look at ServiceRegistryImpl's implementation that's not
gonna happen.

+  service_registry()->AddService(base::Bind(
+      &GpuChildThread::BindProcessControlRequest, base::Unretained(this)));
 }
 
 bool GpuChildThread::Send(IPC::Message* msg) {
   // The GPU process must never send a synchronous IPC message to the browser
   // process. This could result in deadlock.
   DCHECK(!msg->is_sync());
 
   return ChildThreadImpl::Send(msg);
 }
 
@@ skipping 172 matching lines @@
     watchdog_thread_->Stop();
   }
 }
 
 void GpuChildThread::OnGpuSwitched() {
   DVLOG(1) << "GPU: GPU has switched";
   // Notify observers in the GPU process.
   ui::GpuSwitchingManager::GetInstance()->NotifyGpuSwitched();
 }
 
+void GpuChildThread::BindProcessControlRequest(
+    mojo::InterfaceRequest<ProcessControl> request) {
+  DCHECK(process_control_);
+  process_control_bindings_.AddBinding(process_control_.get(), request.Pass());
+}
+
 }  // namespace content