Add a WorkerScheduler and a WebThreadImplForWorker

content/child/scheduler/worker_scheduler_impl.cc

Index: content/child/scheduler/worker_scheduler_impl.cc
diff --git a/content/renderer/scheduler/null_renderer_scheduler.cc b/content/child/scheduler/worker_scheduler_impl.cc
similarity index 20%
copy from content/renderer/scheduler/null_renderer_scheduler.cc
copy to content/child/scheduler/worker_scheduler_impl.cc
index 7c474806e4414a903b1d59530300aa76b8030e2b..5b69d6c19215b37f5b86734357cdc6de1326fcfb 100644
--- a/content/renderer/scheduler/null_renderer_scheduler.cc
+++ b/content/child/scheduler/worker_scheduler_impl.cc
@@ -2,81 +2,80 @@
 // 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)));
+  }
 
-NullRendererScheduler::~NullRendererScheduler() {
-}
+  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?

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