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(
+    scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner)
+    : helper_(main_task_runner,
+              this,
+              "worker.scheduler",
+              TRACE_DISABLED_BY_DEFAULT("worker.scheduler"),
+              SchedulerHelper::TASK_QUEUE_COUNT) {
+  for (size_t i = 0; i < SchedulerHelper::TASK_QUEUE_COUNT; i++) {
+    helper_.SchedulerTaskQueueManager()->SetQueueName(
+        i, SchedulerHelper::TaskQueueIdToString(
+               static_cast<SchedulerHelper::QueueId>(i)));
+  }
+
+  helper_.InitiateLongIdlePeriodAfterWakeup();

[rmcilroy, 2015/03/30 18:00:54]

Is it useful to do this afterwakeup rather than just doing it from the start?
I'm guessing this is to avoid doing GC before any other tasks are scheduled, but
we probably shouldn't have posted any idletask until some other work has been
done anyway right?

[alex clarke (OOO till 29th), 2015/03/31 17:03:49]

The main reason for this is some of the unit tests don't work if I do an
InitiateLongIdlePeriod right off the bat.

Hopefully it doesn't really matter in practice.  WDYT?

+
+  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);
 }
 
 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