compositor-worker: Refactor CompositorWorkerManager

content/renderer/render_thread_impl.cc

Index: content/renderer/render_thread_impl.cc
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index bf5b570c840af3fed38a5e152db7a250475ababd..610aabb504127767de0a31363c0fe3153bed8fcb 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -26,6 +26,7 @@
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_local.h"
@@ -39,7 +40,9 @@
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/layer_settings.h"
 #include "cc/raster/task_graph_runner.h"
+#include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_settings.h"
+#include "components/scheduler/child/webthread_base.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "content/child/appcache/appcache_dispatcher.h"
 #include "content/child/appcache/appcache_frontend_impl.h"
@@ -846,6 +849,8 @@ void RenderThreadImpl::Shutdown() {
 
   media_thread_.reset();
 
+  blink_platform_impl_->set_compositor_thread(nullptr);
+
   compositor_thread_.reset();
 
   // AudioMessageFilter may be accessed on |media_thread_|, so shutdown after.
@@ -1052,6 +1057,70 @@ void RenderThreadImpl::SetResourceDispatchTaskQueue(
   resource_dispatcher()->SetMainThreadTaskRunner(resource_task_queue);
 }
 
+void RenderThreadImpl::InitializeCompositorThread() {
+#if defined(OS_ANDROID)
+  SynchronousCompositorFactory* sync_compositor_factory =
+      SynchronousCompositorFactory::GetInstance();
+  bool using_ipc_sync_compositing =
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kIPCSyncCompositing);
+  DCHECK(!sync_compositor_factory || !using_ipc_sync_compositing);
+
+  if (sync_compositor_factory) {
+    compositor_task_runner_ =
+        sync_compositor_factory->GetCompositorTaskRunner();
+  }
+#endif
+  if (!compositor_task_runner_.get()) {
+    base::Thread::Options options;
+#if defined(OS_ANDROID)
+    options.priority = base::ThreadPriority::DISPLAY;
+#endif
+    compositor_thread_.reset(static_cast<scheduler::WebThreadBase*>(
+        blink_platform_impl_->createThreadWithOptions("Compositor", options)));
+    compositor_task_runner_ = compositor_thread_->TaskRunner();
+    compositor_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(base::IgnoreResult(&ThreadRestrictions::SetIOAllowed),
+                   false));
+    // Need to ensure that we finish initializing the compositor thread before
+    // setting it on |blink_platform_impl_|. This prevents the unfortunate
+    // situation where the platform is torn down before initialization (which
+    // depends on the platform) is done.
+    base::WaitableEvent event(false, false);
+    compositor_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event)));
+    event.Wait();

[piman, 2015/12/01 23:44:41]

Really sorry to be a pain, but can we move this logic into BlinkPlatformImpl?
Either in createThreadWithOptions or in set_compositor_thread (whichever makes
sense)?
The Unretained callback is an implementation detail of BlinkPlatformImpl that
doesn't seem like it should leak into here.

[Ian Vollick, 2015/12/02 00:26:40]

Good point. Done.

+
+    blink_platform_impl_->set_compositor_thread(compositor_thread_.get());
+  }
+
+  InputHandlerManagerClient* input_handler_manager_client = NULL;
+#if defined(OS_ANDROID)
+  if (using_ipc_sync_compositing) {
+    sync_compositor_message_filter_ =
+        new SynchronousCompositorFilter(compositor_task_runner_);
+    AddFilter(sync_compositor_message_filter_.get());
+    input_handler_manager_client = sync_compositor_message_filter_.get();
+  } else if (sync_compositor_factory) {
+    input_handler_manager_client =
+        sync_compositor_factory->GetInputHandlerManagerClient();
+  }
+#endif
+  if (!input_handler_manager_client) {
+    scoped_refptr<InputEventFilter> compositor_input_event_filter(
+        new InputEventFilter(main_input_callback_.callback(),
+                             main_thread_compositor_task_runner_,
+                             compositor_task_runner_));
+    input_handler_manager_client = compositor_input_event_filter.get();
+    input_event_filter_ = compositor_input_event_filter;
+  }
+  input_handler_manager_.reset(new InputHandlerManager(
+      compositor_task_runner_, input_handler_manager_client,
+      renderer_scheduler_.get()));
+}
+
 void RenderThreadImpl::EnsureWebKitInitialized() {
   if (blink_platform_impl_)
     return;
@@ -1082,60 +1151,8 @@ void RenderThreadImpl::EnsureWebKitInitialized() {
                  base::Unretained(this)));
 
   SetResourceDispatchTaskQueue(renderer_scheduler_->LoadingTaskRunner());
-
-  bool enable = !command_line.HasSwitch(switches::kDisableThreadedCompositing);
-  if (enable) {
-#if defined(OS_ANDROID)
-    SynchronousCompositorFactory* sync_compositor_factory =
-        SynchronousCompositorFactory::GetInstance();
-    bool using_ipc_sync_compositing =
-        base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kIPCSyncCompositing);
-    DCHECK(!sync_compositor_factory || !using_ipc_sync_compositing);
-
-    if (sync_compositor_factory) {
-      compositor_task_runner_ =
-          sync_compositor_factory->GetCompositorTaskRunner();
-    }
-#endif
-    if (!compositor_task_runner_) {
-      compositor_thread_.reset(new base::Thread("Compositor"));
-      base::Thread::Options compositor_thread_options;
-#if defined(OS_ANDROID)
-      compositor_thread_options.priority = base::ThreadPriority::DISPLAY;
-#endif
-      compositor_thread_->StartWithOptions(compositor_thread_options);
-      compositor_task_runner_ = compositor_thread_->task_runner();
-      compositor_task_runner_->PostTask(
-          FROM_HERE,
-          base::Bind(base::IgnoreResult(&ThreadRestrictions::SetIOAllowed),
-                     false));
-    }
-
-    InputHandlerManagerClient* input_handler_manager_client = NULL;
-#if defined(OS_ANDROID)
-    if (using_ipc_sync_compositing) {
-      sync_compositor_message_filter_ =
-          new SynchronousCompositorFilter(compositor_task_runner_);
-      AddFilter(sync_compositor_message_filter_.get());
-      input_handler_manager_client = sync_compositor_message_filter_.get();
-    } else if (sync_compositor_factory) {
-      input_handler_manager_client =
-          sync_compositor_factory->GetInputHandlerManagerClient();
-    }
-#endif
-    if (!input_handler_manager_client) {
-      scoped_refptr<InputEventFilter> compositor_input_event_filter(
-          new InputEventFilter(main_input_callback_.callback(),
-                               main_thread_compositor_task_runner_,
-                               compositor_task_runner_));
-      input_handler_manager_client = compositor_input_event_filter.get();
-      input_event_filter_ = compositor_input_event_filter;
-    }
-    input_handler_manager_.reset(new InputHandlerManager(
-        compositor_task_runner_, input_handler_manager_client,
-        renderer_scheduler_.get()));
-  }
+  if (!command_line.HasSwitch(switches::kDisableThreadedCompositing))
+    InitializeCompositorThread();
 
   if (!input_event_filter_.get()) {
     // Always provide an input event filter implementation to ensure consistent
@@ -1148,7 +1165,7 @@ void RenderThreadImpl::EnsureWebKitInitialized() {
   AddFilter(input_event_filter_.get());
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_impl_side_task_runner;
-  if (enable)
+  if (compositor_task_runner_)
     compositor_impl_side_task_runner = compositor_task_runner_;
   else
     compositor_impl_side_task_runner = base::ThreadTaskRunnerHandle::Get();