Mus: Implement GpuMain mojo interface

services/ui/gpu/gpu_main.cc

Index: services/ui/gpu/gpu_main.cc
diff --git a/services/ui/gpu/gpu_main.cc b/services/ui/gpu/gpu_main.cc
index b41369f45d85a834243b8cf3a351427c97496280..3b9ef3f97fe917b15e1fc1f723d73ef204ebd581 100644
--- a/services/ui/gpu/gpu_main.cc
+++ b/services/ui/gpu/gpu_main.cc
@@ -7,6 +7,7 @@
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
+#include "gpu/ipc/gpu_in_process_thread_service.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "gpu/ipc/service/gpu_watchdog_thread.h"
 #include "services/ui/gpu/gpu_service_internal.h"
@@ -112,6 +113,26 @@ void GpuMain::Create(mojom::GpuServiceInternalRequest request) {
                  base::Passed(std::move(request))));
 }
 
+void GpuMain::Create(cc::mojom::DisplayCompositorFactoryRequest request) {
+  // TODO(fsamuel): This must be called AFTER GpuServiceInternal has been
+  // initialized.

[sadrul, 2016/11/29 19:46:41]

DCHECK()?

[Fady Samuel, 2016/11/29 20:08:58]

GpuMain doesn't know about GpuServiceInternal::Initialize so there's no easy way
to add a DCHECK that doesn't involve a bunch of extra plumbing. If you feel it's
sufficiently important I am happy to add. 

+  gpu_command_service_ = new gpu::GpuInProcessThreadService(
+      gpu_thread_.task_runner(), gpu_service_internal_->sync_point_manager(),
+      gpu_service_internal_->mailbox_manager(),
+      gpu_service_internal_->share_group());
+
+  // |gpu_memory_buffer_factory_| is null in tests.
+  gpu::ImageFactory* image_factory =
+      gpu_memory_buffer_factory_ ? gpu_memory_buffer_factory_->AsImageFactory()
+                                 : nullptr;
+
+  compositor_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&GpuMain::InitOnCompositorThread, base::Unretained(this),
+                 image_factory, compositor_thread_.task_runner(),
+                 base::Passed(std::move(request))));
+}
+
 void GpuMain::InitOnGpuThread(
     scoped_refptr<base::SingleThreadTaskRunner> io_runner,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_runner) {
@@ -119,20 +140,31 @@ void GpuMain::InitOnGpuThread(
   gpu_init_->set_sandbox_helper(this);
   bool success = gpu_init_->InitializeAndStartSandbox(
       *base::CommandLine::ForCurrentProcess());
-  if (success) {
-    if (gpu::GetNativeGpuMemoryBufferType() != gfx::EMPTY_BUFFER) {
-      gpu_memory_buffer_factory_ =
-          gpu::GpuMemoryBufferFactory::CreateNativeType();
-    }
-    gpu_service_internal_.reset(new GpuServiceInternal(
-        gpu_init_->gpu_info(), gpu_init_->TakeWatchdogThread(),
-        gpu_memory_buffer_factory_.get(), io_runner, compositor_runner));
+  if (!success)
+    return;
+
+  if (gpu::GetNativeGpuMemoryBufferType() != gfx::EMPTY_BUFFER) {
+    gpu_memory_buffer_factory_ =
+        gpu::GpuMemoryBufferFactory::CreateNativeType();
   }
+
+  gpu_service_internal_ = base::MakeUnique<GpuServiceInternal>(
+      gpu_init_->gpu_info(), gpu_init_->TakeWatchdogThread(),
+      gpu_memory_buffer_factory_.get(), io_runner);
+}
+
+void GpuMain::InitOnCompositorThread(
+    gpu::ImageFactory* image_factory,
+    scoped_refptr<base::SingleThreadTaskRunner> compositor_runner,
+    cc::mojom::DisplayCompositorFactoryRequest request) {
+  DCHECK(!display_compositor_factory_);
+  display_compositor_factory_ = base::MakeUnique<DisplayCompositorFactory>(
+      this, gpu_command_service_, compositor_runner, image_factory,
+      std::move(request));
 }
 
 void GpuMain::TearDownOnCompositorThread() {
-  if (gpu_service_internal_)
-    gpu_service_internal_->DestroyDisplayCompositor();
+  display_compositor_factory_.reset();
 }
 
 void GpuMain::TearDownOnGpuThread() {
@@ -143,7 +175,7 @@ void GpuMain::TearDownOnGpuThread() {
 
 void GpuMain::CreateOnGpuThread(mojom::GpuServiceInternalRequest request) {
   if (gpu_service_internal_)
-    gpu_service_internal_->Add(std::move(request));
+    gpu_service_internal_->Bind(std::move(request));
 }
 
 void GpuMain::PreSandboxStartup() {
@@ -156,4 +188,20 @@ bool GpuMain::EnsureSandboxInitialized(
   return true;
 }
 
+std::unique_ptr<gpu::GpuMemoryBufferManager>
+GpuMain::CreateGpuMemoryBufferManager() {
+  if (!gpu_service_internal_)
+    return nullptr;
+
+  if (!gpu_internal_) {
+    mojom::GpuServiceInternalRequest gpu_service_request =
+        mojo::GetProxy(&gpu_internal_);
+
+    Create(std::move(gpu_service_request));
+  }
+
+  return base::MakeUnique<MusGpuMemoryBufferManager>(gpu_internal_.get(),
+                                                     1 /* client_id */);
+}
+
 }  // namespace ui