Add a WorkerScheduler and a WebThreadImplForWorker

content/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 "content/child/webthread_impl.h"
+#include "content/child/webthread_base.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/pending_task.h"
 #include "base/threading/platform_thread.h"
+#include "content/child/scheduler/single_thread_idle_task_runner.h"
 #include "third_party/WebKit/public/platform/WebTraceLocation.h"
 
 namespace content {
 
 class WebThreadBase::TaskObserverAdapter
     : public base::MessageLoop::TaskObserver {
  public:
   TaskObserverAdapter(WebThread::TaskObserver* observer)
       : observer_(observer) {}
 
   void WillProcessTask(const base::PendingTask& pending_task) override {
     observer_->willProcessTask();
   }
 
   void DidProcessTask(const base::PendingTask& pending_task) override {
     observer_->didProcessTask();
   }
 
-private:
+ private:
   WebThread::TaskObserver* observer_;
 };
 
 WebThreadBase::WebThreadBase() {
 }
 
 WebThreadBase::~WebThreadBase() {
   for (auto& observer_entry : task_observer_map_) {
     delete observer_entry.second;
   }
@@ skipping 50 matching lines @@
 // 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))));
+}
+
 void WebThreadBase::enterRunLoop() {
   CHECK(isCurrentThread());
   CHECK(MessageLoop());
   CHECK(!MessageLoop()->is_running());  // We don't support nesting.
   MessageLoop()->Run();
 }
 
 void WebThreadBase::exitRunLoop() {
   CHECK(isCurrentThread());
   CHECK(MessageLoop());
   CHECK(MessageLoop()->is_running());
   MessageLoop()->Quit();
 }
 
 bool WebThreadBase::isCurrentThread() const {
   return TaskRunner()->BelongsToCurrentThread();
 }
 
-blink::PlatformThreadId WebThreadImpl::threadId() const {
-  return thread_->thread_id();
-}
-
-WebThreadImpl::WebThreadImpl(const char* name)
-    : thread_(new base::Thread(name)) {
-  thread_->Start();
-}
-
-WebThreadImpl::~WebThreadImpl() {
-  thread_->Stop();
-}
-
-base::MessageLoop* WebThreadImpl::MessageLoop() const {
-  return nullptr;
-}
-
-base::SingleThreadTaskRunner* WebThreadImpl::TaskRunner() const {
-  return thread_->message_loop_proxy().get();
-}
-
 }  // namespace content