compositor-worker: Refactor CompositorWorkerManager

content/renderer/render_thread_impl.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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #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"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "cc/base/histograms.h"
 #include "cc/base/switches.h"
 #include "cc/blink/web_external_bitmap_impl.h"
 #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"
 #include "content/child/child_discardable_shared_memory_manager.h"
 #include "content/child/child_gpu_memory_buffer_manager.h"
 #include "content/child/child_histogram_message_filter.h"
 #include "content/child/child_resource_message_filter.h"
 #include "content/child/child_shared_bitmap_manager.h"
 #include "content/child/content_child_helpers.h"
 #include "content/child/db_message_filter.h"
@@ skipping 786 matching lines @@
 #if defined(OS_ANDROID)
   if (sync_compositor_message_filter_) {
     RemoveFilter(sync_compositor_message_filter_.get());
     sync_compositor_message_filter_ = nullptr;
   }
   stream_texture_factory_ = nullptr;
 #endif
 
   media_thread_.reset();
 
+  blink_platform_impl_->set_compositor_thread(nullptr);
+
   compositor_thread_.reset();
 
   // AudioMessageFilter may be accessed on |media_thread_|, so shutdown after.
   RemoveFilter(audio_message_filter_.get());
   audio_message_filter_ = NULL;
 
   raster_worker_pool_->Shutdown();
 
   main_input_callback_.Cancel();
   input_handler_manager_.reset();
@@ skipping 186 matching lines @@
       new ResourceSchedulingFilter(resource_task_queue, resource_dispatcher()));
   channel()->AddFilter(filter.get());
   resource_dispatcher()->SetResourceSchedulingFilter(filter);
 
   // The ChildResourceMessageFilter and the ResourceDispatcher need to use the
   // same queue to ensure tasks are executed in the expected order.
   child_resource_message_filter()->SetMainThreadTaskRunner(resource_task_queue);
   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;
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 
 #ifdef ENABLE_VTUNE_JIT_INTERFACE
   if (command_line.HasSwitch(switches::kEnableVtune))
     gin::Debug::SetJitCodeEventHandler(vTune::GetVtuneCodeEventHandler());
@@ skipping 10 matching lines @@
   isolate->SetAddHistogramSampleFunction(AddHistogramSample);
 
   main_thread_compositor_task_runner_ =
       renderer_scheduler_->CompositorTaskRunner();
 
   main_input_callback_.Reset(
       base::Bind(base::IgnoreResult(&RenderThreadImpl::OnMessageReceived),
                  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
     // input event scheduling and prioritization.
     // TODO(jdduke): Merge InputEventFilter, InputHandlerManager and
     // MainThreadInputEventFilter, crbug.com/436057.
     input_event_filter_ = new MainThreadInputEventFilter(
         main_input_callback_.callback(), main_thread_compositor_task_runner_);
   }
   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();
 
   compositor_message_filter_ = new CompositorForwardingMessageFilter(
       compositor_impl_side_task_runner.get());
   AddFilter(compositor_message_filter_.get());
 
   RenderThreadImpl::RegisterSchemes();
 
@@ skipping 823 matching lines @@
 
 void RenderThreadImpl::ReleaseFreeMemory() {
   base::allocator::ReleaseFreeMemory();
   discardable_shared_memory_manager()->ReleaseFreeMemory();
 
   if (blink_platform_impl_)
     blink::decommitFreeableMemory();
 }
 
 }  // namespace content