WebThreadImplForMessageLoop to use blink scheduler

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 400 matching lines @@
     // coverage when we add a new symbol to WebLocalizedString.h in WebKit.
     // After a planned WebKit patch is landed, we need to add a case statement
     // for the added symbol here.
     default:
       break;
   }
   return -1;
 }
 
 BlinkPlatformImpl::BlinkPlatformImpl()
-    : main_loop_(base::MessageLoop::current()),
+    : main_thread_task_runner_(base::MessageLoopProxy::current()),
       shared_timer_func_(NULL),
       shared_timer_fire_time_(0.0),
       shared_timer_fire_time_was_set_while_suspended_(false),
       shared_timer_suspended_(0),
       current_thread_slot_(&DestroyCurrentThread) {
+  InternalInit();
+}
+
+BlinkPlatformImpl::BlinkPlatformImpl(
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
+    : main_thread_task_runner_(main_thread_task_runner),
+      shared_timer_func_(NULL),
+      shared_timer_fire_time_(0.0),
+      shared_timer_fire_time_was_set_while_suspended_(false),
+      shared_timer_suspended_(0),
+      current_thread_slot_(&DestroyCurrentThread) {
+  // TODO(alexclarke): Use c++11 delegated constructors when allowed.
+  InternalInit();
+}
+
+void BlinkPlatformImpl::InternalInit() {
   // ChildThread may not exist in some tests.
   if (ChildThread::current()) {
     geofencing_provider_.reset(new WebGeofencingProviderImpl(
         ChildThread::current()->thread_safe_sender()));
     thread_safe_sender_ = ChildThread::current()->thread_safe_sender();
     notification_dispatcher_ =
         ChildThread::current()->notification_dispatcher();
   }
+
+  shared_timer_.SetTaskRunner(main_thread_task_runner_);

[Sami, 2014/11/07 05:26:25]

Do we need to check that the runner is non-null here? IIRC you mentioned in can
be null in some cases.

[alex clarke (OOO till 29th), 2014/11/07 15:19:16]

It probably doesn't hurt to check, however the problem I was getting before
where the browser tab would crash super early doesn't occur anymore.  I'll add
it if you like.

[Sami, 2014/11/07 18:48:33]

Ok, I'm still a bit confused how this thing would be null in practice. However
to be consistent we shouldn't then need the null check in currentThread either,
right?

[alex clarke (OOO till 29th), 2014/11/07 19:18:56]

As discussed offline I added the null check here too since the other one is
needed.

 }
 
 BlinkPlatformImpl::~BlinkPlatformImpl() {
 }
 
 WebURLLoader* BlinkPlatformImpl::createURLLoader() {
   ChildThread* child_thread = ChildThread::current();
   // There may be no child thread in RenderViewTests.  These tests can still use
   // data URLs to bypass the ResourceDispatcher.
   return new WebURLLoaderImpl(
@@ skipping 38 matching lines @@
 blink::WebThread* BlinkPlatformImpl::createThread(const char* name) {
   return new WebThreadImpl(name);
 }
 
 blink::WebThread* BlinkPlatformImpl::currentThread() {
   WebThreadImplForMessageLoop* thread =
       static_cast<WebThreadImplForMessageLoop*>(current_thread_slot_.Get());
   if (thread)
     return (thread);
 
-  scoped_refptr<base::MessageLoopProxy> message_loop =
-      base::MessageLoopProxy::current();
-  if (!message_loop.get())
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner;
+  if (main_thread_task_runner_.get() &&
+      main_thread_task_runner_->BelongsToCurrentThread()) {
+    task_runner = main_thread_task_runner_;
+  } else {
+    task_runner = base::MessageLoopProxy::current();
+  }
+
+  if (!task_runner.get())
     return NULL;
 
-  thread = new WebThreadImplForMessageLoop(message_loop.get());
+  thread = new WebThreadImplForMessageLoop(task_runner);
   current_thread_slot_.Set(thread);
   return thread;
 }
 
 void BlinkPlatformImpl::yieldCurrentThread() {
   base::PlatformThread::YieldCurrentThread();
 }
 
 blink::WebWaitableEvent* BlinkPlatformImpl::createWaitableEvent() {
   return new WebWaitableEventImpl();
@@ skipping 476 matching lines @@
                       this, &BlinkPlatformImpl::DoTimeout);
   OnStartSharedTimer(base::TimeDelta::FromMicroseconds(interval));
 }
 
 void BlinkPlatformImpl::stopSharedTimer() {
   shared_timer_.Stop();
 }
 
 void BlinkPlatformImpl::callOnMainThread(
     void (*func)(void*), void* context) {
-  main_loop_->PostTask(FROM_HERE, base::Bind(func, context));
+  main_thread_task_runner_->PostTask(FROM_HERE, base::Bind(func, context));
 }
 
 blink::WebGestureCurve* BlinkPlatformImpl::createFlingAnimationCurve(
     blink::WebGestureDevice device_source,
     const blink::WebFloatPoint& velocity,
     const blink::WebSize& cumulative_scroll) {
   auto curve = WebGestureCurveImpl::CreateFromDefaultPlatformCurve(
       gfx::Vector2dF(velocity.x, velocity.y),
       gfx::Vector2dF(cumulative_scroll.width, cumulative_scroll.height));
   return curve.release();
@@ skipping 208 matching lines @@
 }
 
 // static
 void BlinkPlatformImpl::DestroyCurrentThread(void* thread) {
   WebThreadImplForMessageLoop* impl =
       static_cast<WebThreadImplForMessageLoop*>(thread);
   delete impl;
 }
 
 }  // namespace content