scheduler: Implement task observers

content/child/webthread_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.
 
 // An implementation of WebThread in terms of base::MessageLoop and
 // base::Thread
 
 #include "content/child/webthread_impl.h"
 
 #include "base/bind.h"
@@ skipping 25 matching lines @@
 private:
   WebThread::TaskObserver* observer_;
 };
 
 void WebThreadBase::addTaskObserver(TaskObserver* observer) {
   CHECK(isCurrentThread());
   std::pair<TaskObserverMap::iterator, bool> result = task_observer_map_.insert(
       std::make_pair(observer, static_cast<TaskObserverAdapter*>(NULL)));
   if (result.second)
     result.first->second = new TaskObserverAdapter(observer);
-  base::MessageLoop::current()->AddTaskObserver(result.first->second);
+  AddTaskObserverInternal(result.first->second);
 }
 
 void WebThreadBase::removeTaskObserver(TaskObserver* observer) {
   CHECK(isCurrentThread());
   TaskObserverMap::iterator iter = task_observer_map_.find(observer);
   if (iter == task_observer_map_.end())
     return;
-  base::MessageLoop::current()->RemoveTaskObserver(iter->second);
+  RemoveTaskObserverInternal(iter->second);
   delete iter->second;
   task_observer_map_.erase(iter);
 }
 
+void WebThreadBase::AddTaskObserverInternal(
+    base::MessageLoop::TaskObserver* observer) {
+  base::MessageLoop::current()->AddTaskObserver(observer);

[alex clarke (OOO till 29th), 2015/02/13 11:02:07]

Do we need DCHECK(main_thread_checker_.CalledOnValidThread());

+}
+
+void WebThreadBase::RemoveTaskObserverInternal(
+    base::MessageLoop::TaskObserver* observer) {
+  base::MessageLoop::current()->RemoveTaskObserver(observer);
+}
+
 WebThreadImpl::WebThreadImpl(const char* name)
     : thread_(new base::Thread(name)) {
   thread_->Start();
 }
 
 // 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 RunWebThreadTask(scoped_ptr<blink::WebThread::Task> task) {
+//
+// static
+void WebThreadBase::RunWebThreadTask(scoped_ptr<blink::WebThread::Task> task) {
     task->run();
 }
 
 void WebThreadImpl::postTask(Task* task) {
   postDelayedTask(task, 0);
 }
 
 void WebThreadImpl::postTask(const blink::WebTraceLocation& location,
                              Task* task) {
   postDelayedTask(location, task, 0);
@@ skipping 94 matching lines @@
   return owning_thread_task_runner_->BelongsToCurrentThread();
 }
 
 blink::PlatformThreadId WebThreadImplForMessageLoop::threadId() const {
   return thread_id_;
 }
 
 WebThreadImplForMessageLoop::~WebThreadImplForMessageLoop() {}
 
 }  // namespace content