Introduce ChildScheduler as common base interface for WorkerScheduler and RendererScheduler.

BUG=463143

Review URL: https://codereview.chromium.org/1089833002

Cr-Commit-Position: refs/heads/master@{#325433}

content/child/scheduler/child_scheduler.h

+// Copyright 2015 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.
+
+#ifndef CONTENT_CHILD_SCHEDULER_CHILD_SCHEDULER_H_
+#define CONTENT_CHILD_SCHEDULER_CHILD_SCHEDULER_H_
+
+#include "base/message_loop/message_loop.h"
+#include "content/child/scheduler/single_thread_idle_task_runner.h"
+#include "content/common/content_export.h"
+
+namespace base {
+class MessageLoop;
+}
+
+namespace content {
+
+class CONTENT_EXPORT ChildScheduler {
+ public:
+  virtual ~ChildScheduler() { }
+
+  // Returns the default task runner.
+  virtual scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() = 0;
+
+  // Returns the idle task runner. Tasks posted to this runner may be reordered
+  // relative to other task types and may be starved for an arbitrarily long
+  // time if no idle time is available.
+  virtual scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() = 0;
+
+  // Returns true if there is high priority work pending on the main thread
+  // and the caller should yield to let the scheduler service that work. Note
+  // that this is a stricter condition than |IsHighPriorityWorkAnticipated|,
+  // restricted to the case where real work is pending.
+  // Must be called from the thread this scheduler was created on.
+  virtual bool ShouldYieldForHighPriorityWork() = 0;
+
+  // Returns true if a currently running idle task could exceed its deadline
+  // without impacting user experience too much. This should only be used if
+  // there is a task which cannot be pre-empted and is likely to take longer
+  // than the largest expected idle task deadline. It should NOT be polled to
+  // check whether more work can be performed on the current idle task after
+  // its deadline has expired - post a new idle task for the continuation of the
+  // work in this case.
+  // Must be called from the thread this scheduler was created on.
+  virtual bool CanExceedIdleDeadlineIfRequired() const = 0;
+
+  // Adds or removes a task observer from the scheduler. The observer will be
+  // notified before and after every executed task. These functions can only be
+  // called on the thread this scheduler was created on.
+  virtual void AddTaskObserver(
+      base::MessageLoop::TaskObserver* task_observer) = 0;
+  virtual void RemoveTaskObserver(
+      base::MessageLoop::TaskObserver* task_observer) = 0;
+
+  // Shuts down the scheduler by dropping any remaining pending work in the work
+  // queues. After this call any work posted to the task runners will be
+  // silently dropped.
+  virtual void Shutdown() = 0;
+
+ protected:
+  ChildScheduler() { }
+  DISALLOW_COPY_AND_ASSIGN(ChildScheduler);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_CHILD_SCHEDULER_CHILD_SCHEDULER_H_

content/child/scheduler/null_worker_scheduler.cc

@@ -42,6 +42,10 @@ bool NullWorkerScheduler::CanExceedIdleDeadlineIfRequired() const {
   return false;
 }
 
+bool NullWorkerScheduler::ShouldYieldForHighPriorityWork() {
+  return false;
+}
+
 void NullWorkerScheduler::Init() {
 }
 

content/child/scheduler/null_worker_scheduler.h

@@ -21,6 +21,7 @@ class NullWorkerScheduler : public WorkerScheduler {
   void RemoveTaskObserver(
       base::MessageLoop::TaskObserver* task_observer) override;
   bool CanExceedIdleDeadlineIfRequired() const override;
+  bool ShouldYieldForHighPriorityWork() override;
   void Init() override;
   void Shutdown() override;
 

content/child/scheduler/worker_scheduler.h

@@ -6,6 +6,7 @@
 #define CONTENT_CHILD_SCHEDULER_WORKER_SCHEDULER_H_
 
 #include "base/message_loop/message_loop.h"
+#include "content/child/scheduler/child_scheduler.h"
 #include "content/child/scheduler/single_thread_idle_task_runner.h"
 #include "content/common/content_export.h"
 
@@ -15,46 +16,15 @@ class MessageLoop;
 
 namespace content {
 
-class CONTENT_EXPORT WorkerScheduler {
+class CONTENT_EXPORT WorkerScheduler : public ChildScheduler {
  public:
-  virtual ~WorkerScheduler();
+  ~WorkerScheduler() override;
   static scoped_ptr<WorkerScheduler> Create(base::MessageLoop* message_loop);
 
   // Must be called before the scheduler can be used. Does any post construction
   // initialization needed such as initializing idle period detection.
   virtual void Init() = 0;
 
-  // Returns the default task runner.
-  virtual scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() = 0;
-
-  // Returns the idle task runner. Tasks posted to this runner may be reordered
-  // relative to other task types and may be starved for an arbitrarily long
-  // time if no idle time is available.
-  virtual scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() = 0;
-
-  // Returns true if a currently running idle task could exceed its deadline
-  // without impacting user experience too much. This should only be used if
-  // there is a task which cannot be pre-empted and is likely to take longer
-  // than the largest expected idle task deadline. It should NOT be polled to
-  // check whether more work can be performed on the current idle task after
-  // its deadline has expired - post a new idle task for the continuation of the
-  // work in this case.
-  // Must be called from the worker's thread.
-  virtual bool CanExceedIdleDeadlineIfRequired() const = 0;
-
-  // Adds or removes a task observer from the scheduler. The observer will be
-  // notified before and after every executed task. These functions can only be
-  // called on the main thread.
-  virtual void AddTaskObserver(
-      base::MessageLoop::TaskObserver* task_observer) = 0;
-  virtual void RemoveTaskObserver(
-      base::MessageLoop::TaskObserver* task_observer) = 0;
-
-  // Shuts down the scheduler by dropping any remaining pending work in the work
-  // queues. After this call any work posted to the task runners will be
-  // silently dropped.
-  virtual void Shutdown() = 0;
-
  protected:
   WorkerScheduler();
   DISALLOW_COPY_AND_ASSIGN(WorkerScheduler);

content/child/scheduler/worker_scheduler_impl.cc

@@ -52,6 +52,11 @@ bool WorkerSchedulerImpl::CanExceedIdleDeadlineIfRequired() const {
   return helper_.CanExceedIdleDeadlineIfRequired();
 }
 
+bool WorkerSchedulerImpl::ShouldYieldForHighPriorityWork() {
+  // We don't consider any work as being high priority on workers.
+  return false;
+}
+
 void WorkerSchedulerImpl::AddTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   DCHECK(initialized_);

content/child/scheduler/worker_scheduler_impl.h

@@ -30,6 +30,7 @@ class CONTENT_EXPORT WorkerSchedulerImpl
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;
   scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() override;
   bool CanExceedIdleDeadlineIfRequired() const override;
+  bool ShouldYieldForHighPriorityWork() override;
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;
   void RemoveTaskObserver(
       base::MessageLoop::TaskObserver* task_observer) override;

content/content_child.gypi

@@ -191,6 +191,7 @@
       'child/request_info.h',
       'child/scheduler/cancelable_closure_holder.cc',
       'child/scheduler/cancelable_closure_holder.h',
+      'child/scheduler/child_scheduler.h',
       'child/scheduler/nestable_single_thread_task_runner.h',
       'child/scheduler/null_idle_task_runner.cc',
       'child/scheduler/null_idle_task_runner.h',

content/renderer/scheduler/renderer_scheduler.h

@@ -6,6 +6,7 @@
 #define CONTENT_RENDERER_SCHEDULER_RENDERER_SCHEDULER_H_
 
 #include "base/message_loop/message_loop.h"
+#include "content/child/scheduler/child_scheduler.h"
 #include "content/child/scheduler/single_thread_idle_task_runner.h"
 #include "content/common/content_export.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
@@ -16,23 +17,15 @@ struct BeginFrameArgs;
 
 namespace content {
 
-class CONTENT_EXPORT RendererScheduler {
+class CONTENT_EXPORT RendererScheduler : public ChildScheduler {
  public:
-  virtual ~RendererScheduler();
+  ~RendererScheduler() override;
   static scoped_ptr<RendererScheduler> Create();
 
-  // Returns the default task runner.
-  virtual scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() = 0;
-
   // Returns the compositor task runner.
   virtual scoped_refptr<base::SingleThreadTaskRunner>
   CompositorTaskRunner() = 0;
 
-  // Returns the idle task runner. Tasks posted to this runner may be reordered
-  // relative to other task types and may be starved for an arbitrarily long
-  // time if no idle time is available.
-  virtual scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() = 0;
-
   // Returns the loading task runner.  This queue is intended for tasks related
   // to resource dispatch, foreground HTML parsing, etc...
   virtual scoped_refptr<base::SingleThreadTaskRunner> LoadingTaskRunner() = 0;
@@ -78,36 +71,6 @@ class CONTENT_EXPORT RendererScheduler {
   // Must be called from the main thread.
   virtual bool IsHighPriorityWorkAnticipated() = 0;
 
-  // Returns true if there is high priority work pending on the main thread
-  // and the caller should yield to let the scheduler service that work. Note
-  // that this is a stricter condition than |IsHighPriorityWorkAnticipated|,
-  // restricted to the case where real work is pending.
-  // Must be called from the main thread.
-  virtual bool ShouldYieldForHighPriorityWork() = 0;
-
-  // Returns true if a currently running idle task could exceed its deadline
-  // without impacting user experience too much. This should only be used if
-  // there is a task which cannot be pre-empted and is likely to take longer
-  // than the largest expected idle task deadline. It should NOT be polled to
-  // check whether more work can be performed on the current idle task after
-  // its deadline has expired - post a new idle task for the continuation of the
-  // work in this case.
-  // Must be called from the main thread.
-  virtual bool CanExceedIdleDeadlineIfRequired() const = 0;
-
-  // Adds or removes a task observer from the scheduler. The observer will be
-  // notified before and after every executed task. These functions can only be
-  // called on the main thread.
-  virtual void AddTaskObserver(
-      base::MessageLoop::TaskObserver* task_observer) = 0;
-  virtual void RemoveTaskObserver(
-      base::MessageLoop::TaskObserver* task_observer) = 0;
-
-  // Shuts down the scheduler by dropping any remaining pending work in the work
-  // queues. After this call any work posted to the task runners will be
-  // silently dropped.
-  virtual void Shutdown() = 0;
-
   // Suspends the timer queue and increments the timer queue suspension count.
   // May only be called from the main thread.
   virtual void SuspendTimerQueue() = 0;