compositor worker: Use a WebThread for the compositor thread.

content/child/blink_platform_impl.cc

 // Copyright 2014 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/child/blink_platform_impl.h"
 
 #include <math.h>
 
 #include <vector>
 
@@ skipping 65 matching lines @@
 #include "ui/events/keycodes/dom/keycode_converter.h"
 
 using blink::WebData;
 using blink::WebFallbackThemeEngine;
 using blink::WebLocalizedString;
 using blink::WebString;
 using blink::WebThemeEngine;
 using blink::WebURL;
 using blink::WebURLError;
 using blink::WebURLLoader;
+using scheduler::WebThreadImplForWorkerScheduler;
 
 namespace content {
 
 namespace {
 
+class WebThreadForCompositor : public WebThreadImplForWorkerScheduler {
+ public:
+  explicit WebThreadForCompositor(base::Thread::Options options)
+      : WebThreadImplForWorkerScheduler("Compositor", options) {
+    Init();
+  }
+  ~WebThreadForCompositor() override {}
+
+ private:
+  // WebThreadImplForWorkerScheduler:
+  bool UseThreadTaskRunnerAsDefault() const override { return true; }
+
+  DISALLOW_COPY_AND_ASSIGN(WebThreadForCompositor);
+};
+
 class WebWaitableEventImpl : public blink::WebWaitableEvent {
  public:
   WebWaitableEventImpl(ResetPolicy policy, InitialState state) {
     bool manual_reset = policy == ResetPolicy::Manual;
     bool initially_signaled = state == InitialState::Signaled;
     impl_.reset(new base::WaitableEvent(manual_reset, initially_signaled));
   }
   ~WebWaitableEventImpl() override {}
 
   void reset() override { impl_->Reset(); }
@@ skipping 374 matching lines @@
     notification_dispatcher_ =
         ChildThreadImpl::current()->notification_dispatcher();
     push_dispatcher_ = ChildThreadImpl::current()->push_dispatcher();
     permission_client_.reset(new PermissionDispatcher(
         ChildThreadImpl::current()->service_registry()));
     main_thread_sync_provider_.reset(
         new BackgroundSyncProvider(main_thread_task_runner_.get()));
   }
 }
 
+void BlinkPlatformImpl::WaitUntilWebThreadTLSUpdate(
+    scheduler::WebThreadBase* thread) {
+  base::WaitableEvent event(false, false);
+  thread->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&BlinkPlatformImpl::UpdateWebThreadTLS, base::Unretained(this),
+                 base::Unretained(thread), base::Unretained(&event)));
+  event.Wait();
+}
+
 void BlinkPlatformImpl::UpdateWebThreadTLS(blink::WebThread* thread,
                                            base::WaitableEvent* event) {
   DCHECK(!current_thread_slot_.Get());
   current_thread_slot_.Set(thread);
   event->Signal();
 }
 
 BlinkPlatformImpl::~BlinkPlatformImpl() {
 }
 
@@ skipping 55 matching lines @@
   return net::IsPortAllowedForScheme(gurl.EffectiveIntPort(), gurl.scheme());
 }
 
 blink::WebThread* BlinkPlatformImpl::createThread(const char* name) {
   return createThreadWithOptions(name, base::Thread::Options()).release();
 }
 
 scoped_ptr<scheduler::WebThreadBase> BlinkPlatformImpl::createThreadWithOptions(
     const char* name,
     base::Thread::Options options) {
-  scoped_ptr<scheduler::WebThreadBase> thread(
-      new scheduler::WebThreadImplForWorkerScheduler(name, options));
-  base::WaitableEvent event(false, false);
-  thread->TaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&BlinkPlatformImpl::UpdateWebThreadTLS, base::Unretained(this),
-                 base::Unretained(thread.get()), base::Unretained(&event)));
-  event.Wait();
-  return thread;
+  WebThreadImplForWorkerScheduler* thread =
+      new WebThreadImplForWorkerScheduler(name, options);
+  thread->Init();
+  WaitUntilWebThreadTLSUpdate(thread);
+  return make_scoped_ptr(thread);
+}
+
+scoped_ptr<scheduler::WebThreadBase>
+BlinkPlatformImpl::createCompositorThread() {
+  base::Thread::Options options;
+#if defined(OS_ANDROID)
+  options.priority = base::ThreadPriority::DISPLAY;
+#endif
+  compositor_thread_ = new WebThreadForCompositor(options);
+  WaitUntilWebThreadTLSUpdate(compositor_thread_);
+  return make_scoped_ptr(compositor_thread_);
 }
 
 blink::WebThread* BlinkPlatformImpl::currentThread() {
   return static_cast<blink::WebThread*>(current_thread_slot_.Get());
 }
 
 void BlinkPlatformImpl::yieldCurrentThread() {
   base::PlatformThread::YieldCurrentThread();
 }
 
@@ skipping 722 matching lines @@
   return WebString::fromUTF8(ui::KeycodeConverter::DomKeyToKeyString(
       static_cast<ui::DomKey>(dom_key)));
 }
 
 int BlinkPlatformImpl::domKeyEnumFromString(const WebString& key_string) {
   return static_cast<int>(
       ui::KeycodeConverter::KeyStringToDomKey(key_string.utf8()));
 }
 
 }  // namespace content