Introduce WebTaskRunner Patch 4/5

components/scheduler/child/webthread_base.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.
 
 // An implementation of WebThread in terms of base::MessageLoop and
 // base::Thread
 
 #include "components/scheduler/child/webthread_base.h"
 
 #include "base/bind.h"
@@ skipping 54 matching lines @@
 void WebThreadBase::AddTaskObserverInternal(
     base::MessageLoop::TaskObserver* observer) {
   base::MessageLoop::current()->AddTaskObserver(observer);
 }
 
 void WebThreadBase::RemoveTaskObserverInternal(
     base::MessageLoop::TaskObserver* observer) {
   base::MessageLoop::current()->RemoveTaskObserver(observer);
 }
 
-// RunWebThreadTask takes the ownership of |task| from base::Closure and
-// deletes it on the first invocation of the closure for thread-safety.
-// base::Closure made from RunWebThreadTask is copyable but Closure::Run
-// should be called at most only once.
-// This is because WebThread::Task can contain RefPtr to a
-// thread-unsafe-reference-counted object (e.g. WorkerThreadTask can contain
-// RefPtr to WebKit's StringImpl), and if we don't delete |task| here,
-// it causes a race condition as follows:
-// [A] In task->run(), more RefPtr's to the refcounted object can be created,
-//     and the reference counter of the object can be modified via these
-//     RefPtr's (as intended) on the thread where the task is executed.
-// [B] However, base::Closure still retains the ownership of WebThread::Task
-//     even after RunWebThreadTask is called.
-//     When base::Closure is deleted, WebThread::Task is deleted and the
-//     reference counter of the object is decreased by one, possibly from a
-//     different thread from [A], which is a race condition.
-// Taking the ownership of |task| here by using scoped_ptr and base::Passed
-// removes the reference counter modification of [B] and the race condition.
-// When the closure never runs at all, the corresponding WebThread::Task is
-// destructed when base::Closure is deleted (like [B]). In this case, there
-// are no reference counter modification like [A] (because task->run() is not
-// executed), so there are no race conditions.
-// See https://crbug.com/390851 for more details.
-//
-// static
-void WebThreadBase::RunWebThreadTask(scoped_ptr<blink::WebThread::Task> task) {
-  task->run();
-}
-
 // static
 void WebThreadBase::RunWebThreadIdleTask(
     scoped_ptr<blink::WebThread::IdleTask> idle_task,
     base::TimeTicks deadline) {
   idle_task->run((deadline - base::TimeTicks()).InSecondsF());
 }
 
-void WebThreadBase::postTask(const blink::WebTraceLocation& location,
-                             Task* task) {
-  postDelayedTask(location, task, 0);
-}
-
-void WebThreadBase::postDelayedTask(const blink::WebTraceLocation& web_location,
-                                    Task* task,
-                                    long long delay_ms) {
-  tracked_objects::Location location(web_location.functionName(),
-                                     web_location.fileName(), -1, nullptr);
-  TaskRunner()->PostDelayedTask(
-      location,
-      base::Bind(RunWebThreadTask, base::Passed(make_scoped_ptr(task))),
-      base::TimeDelta::FromMilliseconds(delay_ms));
-}
-
 void WebThreadBase::postIdleTask(const blink::WebTraceLocation& web_location,
                                  IdleTask* idle_task) {
   tracked_objects::Location location(web_location.functionName(),
                                      web_location.fileName(), -1, nullptr);
   IdleTaskRunner()->PostIdleTask(
       location, base::Bind(&WebThreadBase::RunWebThreadIdleTask,
                            base::Passed(make_scoped_ptr(idle_task))));
 }
 
 void WebThreadBase::postIdleTaskAfterWakeup(
     const blink::WebTraceLocation& web_location,
     IdleTask* idle_task) {
   tracked_objects::Location location(web_location.functionName(),
                                      web_location.fileName(), -1, nullptr);
   IdleTaskRunner()->PostIdleTaskAfterWakeup(
       location, base::Bind(&WebThreadBase::RunWebThreadIdleTask,
                            base::Passed(make_scoped_ptr(idle_task))));
 }
 
 bool WebThreadBase::isCurrentThread() const {
   return TaskRunner()->BelongsToCurrentThread();
 }
 
 }  // namespace scheduler