compositor worker: Use a WebThread for the compositor thread.

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 <utility>
@@ skipping 26 matching lines @@
 #include "base/values.h"
 #include "build/build_config.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/compositor_worker_scheduler.h"
 #include "components/scheduler/child/webthread_base.h"
+#include "components/scheduler/child/webthread_impl_for_worker_scheduler.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 153 matching lines @@
 
 using base::ThreadRestrictions;
 using blink::WebDocument;
 using blink::WebFrame;
 using blink::WebNetworkStateNotifier;
 using blink::WebRuntimeFeatures;
 using blink::WebScriptController;
 using blink::WebSecurityPolicy;
 using blink::WebString;
 using blink::WebView;
+using scheduler::WebThreadImplForWorkerScheduler;
 
 namespace content {
 
 namespace {
 
 const int64_t kInitialIdleHandlerDelayMs = 1000;
 const int64_t kLongIdleHandlerDelayMs = 30 * 1000;
 
 #if defined(OS_ANDROID)
 // On Android, resource messages can each take ~1.5ms to dispatch on the browser
 // IO thread. Limiting the message rate to 3/frame at 60hz ensures that the
 // induced work takes but a fraction (~1/4) of the overall frame budget.
 const int kMaxResourceRequestsPerFlushWhenThrottled = 3;
 #else
 const int kMaxResourceRequestsPerFlushWhenThrottled = 8;
 #endif
 const double kThrottledResourceRequestFlushPeriodS = 1. / 60.;
 
 // Maximum allocation size allowed for image scaling filters that
 // require pre-scaling. Skia will fallback to a filter that doesn't
 // require pre-scaling if the default filter would require an
 // allocation that exceeds this limit.
 const size_t kImageCacheSingleAllocationByteLimit = 64 * 1024 * 1024;
 
 // Keep the global RenderThreadImpl in a TLS slot so it is impossible to access
 // incorrectly from the wrong thread.
 base::LazyInstance<base::ThreadLocalPointer<RenderThreadImpl> >
     lazy_tls = LAZY_INSTANCE_INITIALIZER;
 
+class WebThreadForCompositor : public WebThreadImplForWorkerScheduler {
+ public:
+  explicit WebThreadForCompositor(base::Thread::Options options)
+      : WebThreadImplForWorkerScheduler("Compositor", options) {
+    Init();
+  }
+  ~WebThreadForCompositor() override {}
+
+ private:
+  // WebThreadImplForWorkerScheduler:
+  scoped_ptr<scheduler::WorkerScheduler> CreateWorkerScheduler() override {
+    return make_scoped_ptr(new scheduler::CompositorWorkerScheduler(thread()));
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(WebThreadForCompositor);
+};
+
 class RenderViewZoomer : public RenderViewVisitor {
  public:
   RenderViewZoomer(const std::string& scheme,
                    const std::string& host,
                    double zoom_level) : scheme_(scheme),
                                         host_(host),
                                         zoom_level_(zoom_level) {
   }
 
   bool Visit(RenderView* render_view) override {
@@ skipping 626 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);
+  blink_platform_impl_->SetCompositorThread(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();
@@ skipping 234 matching lines @@
       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()) {
-
-    compositor_thread_.reset(new base::Thread("Compositor"));
-    base::Thread::Options compositor_thread_options;
+    base::Thread::Options options;
 #if defined(OS_ANDROID)
-    compositor_thread_options.priority = base::ThreadPriority::DISPLAY;
+    options.priority = base::ThreadPriority::DISPLAY;
 #endif
-    compositor_thread_->StartWithOptions(compositor_thread_options);
-    compositor_task_runner_ = compositor_thread_->task_runner();
+    compositor_thread_.reset(new WebThreadForCompositor(options));
+    blink_platform_impl_->SetCompositorThread(compositor_thread_.get());
+    compositor_task_runner_ = compositor_thread_->TaskRunner();
     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_ =
@@ skipping 923 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content