services/ui: Initialize all of gpu in one thread.

services/ui/gpu/gpu_main.cc

 // Copyright 2016 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 "services/ui/gpu/gpu_main.h"
 
 #include "base/command_line.h"
+#include "base/message_loop/message_loop.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.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"
 
+namespace {
+
+#if defined(OS_WIN)
+std::unique_ptr<base::MessagePump> CreateMessagePumpWin() {
+  base::MessagePumpForGpu::InitFactory();
+  return base::MessageLoop::CreateMessagePumpForType(
+      base::MessageLoop::TYPE_UI);
+}
+#endif  // defined(OS_WIN)
+
+#if defined(USE_X11)
+std::unique_ptr<base::MessagePump> CreateMessagePumpX11() {
+  // TODO(sad): This should create a TYPE_UI message pump, and create a
+  // PlatformEventSource when gpu process split happens.
+  return base::MessageLoop::CreateMessagePumpForType(
+      base::MessageLoop::TYPE_DEFAULT);
+}
+#endif  // defined(USE_X11)
+
+#if defined(OS_MACOSX)
+std::unique_ptr<base::MessagePump> CreateMessagePumpMac() {
+  return base::MakeUnique<base::MessagePumpCFRunLoop>();
+}
+#endif  // defined(OS_MACOSX)
+
+}  // namespace
+
 namespace ui {
 
-GpuMain::GpuMain() {
-  gpu_init_.set_sandbox_helper(this);
-  bool success = gpu_init_.InitializeAndStartSandbox(
+GpuMain::GpuMain()
+    : gpu_thread_("GpuThread"), io_thread_("GpuIOThread"), weak_factory_(this) {
+  base::Thread::Options thread_options;
+
+#if defined(OS_WIN)
+  thread_options.message_pump_factory = base::Bind(&CreateMessagePumpWin);
+#elif defined(USE_X11)
+  thread_options.message_pump_factory = base::Bind(&CreateMessagePumpX11);
+#elif defined(USE_OZONE)
+  thread_options.message_loop_type = base::MessageLoop::TYPE_UI;

[rjkroege, 2016/09/25 14:31:21]

My intuition is that this is the not right. I presume that the existing CrOS gpu
process has this type of message loop? If the GPU services is TYPE_UI, what is
the main thread? The "main" aka CC thread should be type DEFAULT?

We will have a gpu, cc, drm thread in ozone-drm mus-gpu? Why have more? Watchdog
facilities can be on the drm thread?

[sadrul, 2016/09/25 22:09:57]

Yes. The 'main' thread is initialized in mojo-runner land, and DEFAULT is used
for that.

The UI message-loop type is necessary only for the x11 ozone-platform. This is
because on X11, the gpu process still wants to receive expose events from x11
server, which means it needs the UI message loop. Using the DEFAULT type works
for headless, gbm/drm etc. platforms. We do use UI loop on gpu for ozone-x11 in
chrome too (https://cs.chromium.org/chromium/src/content/gpu/gpu_main.cc?l=219)
The watchdog facility is shared with chrome, which always creates a new thread
right now. We can change that if we want (and presumably we can do that in tot,
unrelated to mus). But maybe we can do the thread audit/cleanup after the gpu
process split.

+#elif defined(OS_LINUX)
+  thread_options.message_loop_type = base::MessageLoop::TYPE_DEFAULT;
+#elif defined(OS_MACOSX)
+  thread_options.message_pump_factory = base::Bind(&CreateMessagePumpMac);
+#else
+  thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
+#endif
+
+#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
+  thread_options.priority = base::ThreadPriority::DISPLAY;
+#endif
+  CHECK(gpu_thread_.StartWithOptions(thread_options));
+
+  // TODO(sad): We do not need the IO thread once gpu has a separate process. It

[rjkroege, 2016/09/25 14:31:21]

why do we need it now?

[sadrul, 2016/09/25 22:09:57]

I think we can get rid of it, and plan on just using the 'main thread' (i.e the
'ui thread', where the ws lives right now) as the io thread. But I want to do
that as a separate patch.

+  // should be possible to use |main_task_runner_| for doing IO tasks.
+  thread_options = base::Thread::Options(base::MessageLoop::TYPE_IO, 0);
+  thread_options.priority = base::ThreadPriority::NORMAL;
+#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
+  // TODO(reveman): Remove this in favor of setting it explicitly for each type
+  // of process.
+  thread_options.priority = base::ThreadPriority::DISPLAY;
+#endif
+  CHECK(io_thread_.StartWithOptions(thread_options));
+}
+
+GpuMain::~GpuMain() {
+  // Unretained() is OK here since the thread/task runner is owned by |this|.
+  gpu_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&GpuMain::TearDownOnGpuThread, base::Unretained(this)));
+  gpu_thread_.Stop();
+  io_thread_.Stop();
+}
+
+void GpuMain::OnStart() {
+  gpu_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&GpuMain::InitOnGpuThread, weak_factory_.GetWeakPtr()));
+}
+
+void GpuMain::Create(mojom::GpuServiceInternalRequest request) {
+  gpu_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&GpuMain::CreateOnGpuThread, weak_factory_.GetWeakPtr(),
+                 base::Passed(std::move(request))));
+}
+
+void GpuMain::InitOnGpuThread() {
+  gpu_init_.reset(new gpu::GpuInit());
+  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_.watchdog_thread(),
-        gpu_memory_buffer_factory_.get()));
+        gpu_init_->gpu_info(), gpu_init_->watchdog_thread(),
+        gpu_memory_buffer_factory_.get(), io_thread_.task_runner()));
   }
 }
 
-GpuMain::~GpuMain() {
-  if (gpu_init_.watchdog_thread())
-    gpu_init_.watchdog_thread()->Stop();
+void GpuMain::TearDownOnGpuThread() {
+  gpu_service_internal_.reset();
+  gpu_memory_buffer_factory_.reset();
+  if (gpu_init_->watchdog_thread())
+    gpu_init_->watchdog_thread()->Stop();
+  gpu_init_.reset();
 }
 
-void GpuMain::Add(mojom::GpuServiceInternalRequest request) {
+void GpuMain::CreateOnGpuThread(mojom::GpuServiceInternalRequest request) {
   if (gpu_service_internal_)
     gpu_service_internal_->Add(std::move(request));
 }
 
 void GpuMain::PreSandboxStartup() {
   // TODO(sad): https://crbug.com/645602
 }
 
 bool GpuMain::EnsureSandboxInitialized() {
   // TODO(sad): https://crbug.com/645602
   return true;
 }
 
 }  // namespace ui