Mojo changes for moving WebScheduler to WebThread

mojo/services/html_viewer/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 "mojo/services/html_viewer/webthread_impl.h"
 
 #include "base/bind.h"
@@ skipping 39 matching lines @@
   CHECK(isCurrentThread());
   TaskObserverMap::iterator iter = task_observer_map_.find(observer);
   if (iter == task_observer_map_.end())
     return;
   base::MessageLoop::current()->RemoveTaskObserver(iter->second);
   delete iter->second;
   task_observer_map_.erase(iter);
 }
 
 WebThreadImpl::WebThreadImpl(const char* name)
-    : thread_(new base::Thread(name)) {
+    : thread_(new base::Thread(name)),
+      web_scheduler_(new WebSchedulerImpl(thread_->task_runner())) {
   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,
@@ skipping 38 matching lines @@
   CHECK(!thread_->message_loop()->is_running());  // We don't support nesting.
   thread_->message_loop()->Run();
 }
 
 void WebThreadImpl::exitRunLoop() {
   CHECK(isCurrentThread());
   CHECK(thread_->message_loop()->is_running());
   thread_->message_loop()->Quit();
 }
 
+blink::WebScheduler* WebThreadImpl::scheduler() const {
+  return web_scheduler_.get();
+}
+
 bool WebThreadImpl::isCurrentThread() const {
   return thread_->thread_id() == base::PlatformThread::CurrentId();
 }
 
 blink::PlatformThreadId WebThreadImpl::threadId() const {
   return thread_->thread_id();
 }
 
 WebThreadImpl::~WebThreadImpl() {
   thread_->Stop();
 }
 
 WebThreadImplForMessageLoop::WebThreadImplForMessageLoop(
     base::MessageLoopProxy* message_loop)
-    : message_loop_(message_loop) {}
+    : message_loop_(message_loop),
+      web_scheduler_(new WebSchedulerImpl(message_loop_)) {
+}
 
 void WebThreadImplForMessageLoop::postTask(
     const blink::WebTraceLocation& location,
     Task* task) {
   postDelayedTask(location, task, 0);
 }
 
 void WebThreadImplForMessageLoop::postDelayedTask(
     const blink::WebTraceLocation& web_location,
     Task* task,
@@ skipping 12 matching lines @@
   CHECK(!base::MessageLoop::current()->is_running());
   base::MessageLoop::current()->Run();
 }
 
 void WebThreadImplForMessageLoop::exitRunLoop() {
   CHECK(isCurrentThread());
   CHECK(base::MessageLoop::current()->is_running());
   base::MessageLoop::current()->Quit();
 }
 
+blink::WebScheduler* WebThreadImplForMessageLoop::scheduler() const {
+  return web_scheduler_.get();
+}
+
 bool WebThreadImplForMessageLoop::isCurrentThread() const {
   return message_loop_->BelongsToCurrentThread();
 }
 
 blink::PlatformThreadId WebThreadImplForMessageLoop::threadId() const {
   return thread_id_;
 }
 
 WebThreadImplForMessageLoop::~WebThreadImplForMessageLoop() {}
 
 }  // namespace html_viewer