Add a WorkerScheduler and a WebThreadImplForWorker

content/child/scheduler/worker_scheduler_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/renderer/scheduler/null_renderer_scheduler.h"
+#include "content/child/scheduler/worker_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
-#include "content/child/scheduler/null_idle_task_runner.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
+#include "content/child/scheduler/nestable_single_thread_task_runner.h"
 
 namespace content {
 
-NullRendererScheduler::NullRendererScheduler()
-    : task_runner_(base::MessageLoopProxy::current()),
-      idle_task_runner_(new NullIdleTaskRunner()) {
+WorkerSchedulerImpl::WorkerSchedulerImpl(

[Sami, 2015/04/02 10:19:46]

I like how how this class doesn't really need to do anything special -- just
plumbing.

[rmcilroy, 2015/04/02 11:01:26]

+1 :)

[alex clarke (OOO till 29th), 2015/04/02 15:19:28]

Acknowledged.

+    scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner)
+    : helper_(main_task_runner,
+              this,
+              "worker.scheduler",
+              TRACE_DISABLED_BY_DEFAULT("worker.scheduler"),
+              SchedulerHelper::TASK_QUEUE_COUNT) {
+  TRACE_EVENT_OBJECT_CREATED_WITH_ID(
+      TRACE_DISABLED_BY_DEFAULT("worker.scheduler"), "WorkerScheduler", this);
 }
 
-NullRendererScheduler::~NullRendererScheduler() {
+WorkerSchedulerImpl::~WorkerSchedulerImpl() {
+  TRACE_EVENT_OBJECT_DELETED_WITH_ID(
+      TRACE_DISABLED_BY_DEFAULT("worker.scheduler"), "WorkerScheduler", this);
+}
+
+void WorkerSchedulerImpl::Init() {
+  helper_.InitiateLongIdlePeriod();

[rmcilroy, 2015/04/02 11:01:26]

Could you add an initialized_ flag to the class which is set to True here, and
DCHECK(initialized_) in the other functions.

[alex clarke (OOO till 29th), 2015/04/02 15:19:28]

Done.

 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
-NullRendererScheduler::DefaultTaskRunner() {
-  return task_runner_;
-}
-
-scoped_refptr<base::SingleThreadTaskRunner>
-NullRendererScheduler::CompositorTaskRunner() {
-  return task_runner_;
-}
-
-scoped_refptr<base::SingleThreadTaskRunner>
-NullRendererScheduler::LoadingTaskRunner() {
-  return task_runner_;
+WorkerSchedulerImpl::DefaultTaskRunner() {
+  return helper_.DefaultTaskRunner();
 }
 
 scoped_refptr<SingleThreadIdleTaskRunner>
-NullRendererScheduler::IdleTaskRunner() {
-  return idle_task_runner_;
+WorkerSchedulerImpl::IdleTaskRunner() {
+  return helper_.IdleTaskRunner();
 }
 
-void NullRendererScheduler::WillBeginFrame(const cc::BeginFrameArgs& args) {
+bool WorkerSchedulerImpl::CanExceedIdleDeadlineIfRequired() const {
+  return helper_.CanExceedIdleDeadlineIfRequired();
 }
 
-void NullRendererScheduler::BeginFrameNotExpectedSoon() {
+void WorkerSchedulerImpl::AddTaskObserver(
+    base::MessageLoop::TaskObserver* task_observer) {
+  helper_.AddTaskObserver(task_observer);
 }
 
-void NullRendererScheduler::DidCommitFrameToCompositor() {
+void WorkerSchedulerImpl::RemoveTaskObserver(
+    base::MessageLoop::TaskObserver* task_observer) {
+  helper_.RemoveTaskObserver(task_observer);
 }
 
-void NullRendererScheduler::DidReceiveInputEventOnCompositorThread(
-    const blink::WebInputEvent& web_input_event) {
+void WorkerSchedulerImpl::Shutdown() {
+  helper_.Shutdown();
 }
 
-void NullRendererScheduler::DidAnimateForInputOnCompositorThread() {
+void WorkerSchedulerImpl::SetTimeSourceForTesting(
+    scoped_refptr<cc::TestNowSource> time_source) {
+  helper_.SetTimeSourceForTesting(time_source);
 }
 
-bool NullRendererScheduler::IsHighPriorityWorkAnticipated() {
-  return false;
+void WorkerSchedulerImpl::SetWorkBatchSizeForTesting(size_t work_batch_size) {
+  helper_.SetWorkBatchSizeForTesting(work_batch_size);
 }
 
-bool NullRendererScheduler::ShouldYieldForHighPriorityWork() {
-  return false;
-}
-
-bool NullRendererScheduler::CanExceedIdleDeadlineIfRequired() const {
-  return false;
-}
-
-void NullRendererScheduler::AddTaskObserver(
-    base::MessageLoop::TaskObserver* task_observer) {
-  base::MessageLoop::current()->AddTaskObserver(task_observer);
-}
-
-void NullRendererScheduler::RemoveTaskObserver(
-    base::MessageLoop::TaskObserver* task_observer) {
-  base::MessageLoop::current()->RemoveTaskObserver(task_observer);
-}
-
-void NullRendererScheduler::Shutdown() {
+bool WorkerSchedulerImpl::CanEnterLongIdlePeriod(base::TimeTicks,
+                                                 base::TimeDelta*) {
+  return true;
 }
 
 }  // namespace content