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 WebWaitableEventImpl : public blink::WebWaitableEvent {
  public:
   WebWaitableEventImpl(ResetPolicy policy, InitialState state) {
     bool manual_reset = policy == ResetPolicy::Manual;
     bool initially_signaled = state == InitialState::Signaled;
@@ skipping 379 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 49 matching lines @@
 bool BlinkPlatformImpl::portAllowed(const blink::WebURL& url) const {
   GURL gurl = GURL(url);
   // Return true for URLs without a port specified.  This is needed to let
   // through non-network schemes that don't go over the network.
   if (!gurl.has_port())
     return true;
   return net::IsPortAllowedForScheme(gurl.EffectiveIntPort(), gurl.scheme());
 }
 
 blink::WebThread* BlinkPlatformImpl::createThread(const char* name) {
-  return createThreadWithOptions(name, base::Thread::Options()).release();
+  scoped_ptr<WebThreadImplForWorkerScheduler> thread(
+      new WebThreadImplForWorkerScheduler(name));
+  thread->Init();
+  WaitUntilWebThreadTLSUpdate(thread.get());
+  return thread.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;
+void BlinkPlatformImpl::SetCompositorThread(
+    scheduler::WebThreadBase* compositor_thread) {
+  compositor_thread_ = compositor_thread;
+  if (compositor_thread_)
+    WaitUntilWebThreadTLSUpdate(compositor_thread_);
 }
 
 blink::WebThread* BlinkPlatformImpl::currentThread() {
   return static_cast<blink::WebThread*>(current_thread_slot_.Get());
 }
 
 void BlinkPlatformImpl::yieldCurrentThread() {
   base::PlatformThread::YieldCurrentThread();
 }
 
@@ skipping 718 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