Patch 1/3 to get WebScheduler via WebThread

Now that all blink threads have schedulers it makes sense to get
hold the corresponding WebScheduler via WebThread.  This patch
is the chromium side of doing that.

Patch 2: https://codereview.chromium.org/1087203002
Patch 3: https://codereview.chromium.org/1084173002

BUG=463143

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

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

content/renderer/scheduler/web_scheduler_impl.cc → content/child/scheduler/web_scheduler_impl.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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.
 
-#include "content/renderer/scheduler/web_scheduler_impl.h"
+#include "content/child/scheduler/web_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
-#include "content/renderer/scheduler/renderer_scheduler.h"
+#include "content/child/scheduler/worker_scheduler.h"
 #include "third_party/WebKit/public/platform/WebTraceLocation.h"
 
 namespace content {
 
-WebSchedulerImpl::WebSchedulerImpl(RendererScheduler* renderer_scheduler)
-    : renderer_scheduler_(renderer_scheduler),
-      idle_task_runner_(renderer_scheduler_->IdleTaskRunner()),
-      loading_task_runner_(renderer_scheduler_->LoadingTaskRunner()),
-      timer_task_runner_(renderer_scheduler_->TimerTaskRunner()) {
+WebSchedulerImpl::WebSchedulerImpl(
+    ChildScheduler* child_scheduler,
+    scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> timer_task_runner)
+    : child_scheduler_(child_scheduler),
+      idle_task_runner_(idle_task_runner),
+      loading_task_runner_(loading_task_runner),
+      timer_task_runner_(timer_task_runner) {
 }
 
 WebSchedulerImpl::~WebSchedulerImpl() {
 }
 
 bool WebSchedulerImpl::shouldYieldForHighPriorityWork() {
-  return renderer_scheduler_->ShouldYieldForHighPriorityWork();
+  return child_scheduler_->ShouldYieldForHighPriorityWork();
 }
 
 bool WebSchedulerImpl::canExceedIdleDeadlineIfRequired() {
-  return renderer_scheduler_->CanExceedIdleDeadlineIfRequired();
+  return child_scheduler_->CanExceedIdleDeadlineIfRequired();
 }
 
 void WebSchedulerImpl::runIdleTask(scoped_ptr<blink::WebThread::IdleTask> task,
@@ -74,7 +78,8 @@ void WebSchedulerImpl::postIdleTaskAfterWakeup(
 }
 
 void WebSchedulerImpl::postLoadingTask(
-    const blink::WebTraceLocation& web_location, blink::WebThread::Task* task) {
+    const blink::WebTraceLocation& web_location,
+    blink::WebThread::Task* task) {
   DCHECK(loading_task_runner_);
   scoped_ptr<blink::WebThread::Task> scoped_task(task);
   tracked_objects::Location location(web_location.functionName(),

content/renderer/scheduler/web_scheduler_impl.h → content/child/scheduler/web_scheduler_impl.h

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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_RENDERER_SCHEDULER_WEB_SCHEDULER_IMPL_H_
-#define CONTENT_RENDERER_SCHEDULER_WEB_SCHEDULER_IMPL_H_
+#ifndef CONTENT_CHILD_SCHEDULER_BASE_WEB_SCHEDULER_IMPL_H_
+#define CONTENT_CHILD_SCHEDULER_BASE_WEB_SCHEDULER_IMPL_H_
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ -18,14 +18,19 @@ class SingleThreadTaskRunner;
 
 namespace content {
 
-class RendererScheduler;
+class ChildScheduler;
 class SingleThreadIdleTaskRunner;
 
 class CONTENT_EXPORT WebSchedulerImpl : public blink::WebScheduler {
  public:
-  WebSchedulerImpl(RendererScheduler* renderer_scheduler);
+  WebSchedulerImpl(
+      ChildScheduler* child_scheduler,
+      scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> timer_task_runner);
   ~WebSchedulerImpl() override;
 
+  // blink::WebScheduler implementation:
   virtual bool shouldYieldForHighPriorityWork();
   virtual bool canExceedIdleDeadlineIfRequired();
   virtual void postIdleTask(const blink::WebTraceLocation& location,
@@ -45,7 +50,7 @@ class CONTENT_EXPORT WebSchedulerImpl : public blink::WebScheduler {
                           base::TimeTicks deadline);
   static void runTask(scoped_ptr<blink::WebThread::Task> task);
 
-  RendererScheduler* renderer_scheduler_;
+  ChildScheduler* child_scheduler_;  // NOT OWNED
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> timer_task_runner_;
@@ -53,4 +58,4 @@ class CONTENT_EXPORT WebSchedulerImpl : public blink::WebScheduler {
 
 }  // namespace content
 
-#endif  // CONTENT_RENDERER_SCHEDULER_WEB_SCHEDULER_IMPL_H_
+#endif  // CONTENT_CHILD_SCHEDULER_BASE_WEB_SCHEDULER_IMPL_H_

content/child/scheduler/webthread_impl_for_worker_scheduler.cc

@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/synchronization/waitable_event.h"
 #include "content/child/scheduler/scheduler_message_loop_delegate.h"
+#include "content/child/scheduler/web_scheduler_impl.h"
 #include "content/child/scheduler/worker_scheduler_impl.h"
 #include "third_party/WebKit/public/platform/WebTraceLocation.h"
 
@@ -42,6 +43,10 @@ void WebThreadImplForWorkerScheduler::InitOnThread(
   worker_scheduler_->Init();
   task_runner_ = worker_scheduler_->DefaultTaskRunner();
   idle_task_runner_ = worker_scheduler_->IdleTaskRunner();
+  web_scheduler_.reset(new WebSchedulerImpl(
+      worker_scheduler_.get(), worker_scheduler_->IdleTaskRunner(),
+      worker_scheduler_->DefaultTaskRunner(),
+      worker_scheduler_->DefaultTaskRunner()));
   completion->Signal();
 }
 
@@ -49,7 +54,8 @@ void WebThreadImplForWorkerScheduler::ShutDownOnThread(
     base::WaitableEvent* completion) {
   task_runner_ = nullptr;
   idle_task_runner_ = nullptr;
-  worker_scheduler_.reset(nullptr);
+  web_scheduler_.reset();
+  worker_scheduler_.reset();
   completion->Signal();
 }
 
@@ -57,6 +63,10 @@ blink::PlatformThreadId WebThreadImplForWorkerScheduler::threadId() const {
   return thread_->thread_id();
 }
 
+blink::WebScheduler* WebThreadImplForWorkerScheduler::scheduler() const {
+  return web_scheduler_.get();
+}
+
 base::MessageLoop* WebThreadImplForWorkerScheduler::MessageLoop() const {
   // As per WebThreadImpl::MessageLoop()
   return nullptr;

content/child/scheduler/webthread_impl_for_worker_scheduler.h

@@ -12,9 +12,14 @@ namespace base {
 class WaitableEvent;
 };
 
+namespace blink {
+class WebScheduler;
+};
+
 namespace content {
 
 class SingleThreadIdleTaskRunner;
+class WebSchedulerImpl;
 class WorkerScheduler;
 
 class CONTENT_EXPORT WebThreadImplForWorkerScheduler : public WebThreadBase {
@@ -23,6 +28,7 @@ class CONTENT_EXPORT WebThreadImplForWorkerScheduler : public WebThreadBase {
   virtual ~WebThreadImplForWorkerScheduler();
 
   // blink::WebThread implementation.
+  virtual blink::WebScheduler* scheduler() const;
   blink::PlatformThreadId threadId() const override;
 
   // WebThreadBase implementation.
@@ -41,6 +47,7 @@ class CONTENT_EXPORT WebThreadImplForWorkerScheduler : public WebThreadBase {
 
   scoped_ptr<base::Thread> thread_;
   scoped_ptr<WorkerScheduler> worker_scheduler_;
+  scoped_ptr<WebSchedulerImpl> web_scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
 };

content/content_child.gypi

@@ -210,6 +210,8 @@
       'child/scheduler/task_queue_manager.h',
       'child/scheduler/webthread_impl_for_worker_scheduler.cc',
       'child/scheduler/webthread_impl_for_worker_scheduler.h',
+      'child/scheduler/web_scheduler_impl.cc',
+      'child/scheduler/web_scheduler_impl.h',
       'child/scheduler/worker_scheduler.cc',
       'child/scheduler/worker_scheduler.h',
       'child/scheduler/worker_scheduler_impl.cc',

content/content_renderer.gypi

@@ -381,8 +381,6 @@
       'renderer/scheduler/renderer_scheduler_impl.h',
       'renderer/scheduler/resource_dispatch_throttler.cc',
       'renderer/scheduler/resource_dispatch_throttler.h',
-      'renderer/scheduler/web_scheduler_impl.cc',
-      'renderer/scheduler/web_scheduler_impl.h',
       'renderer/scheduler/webthread_impl_for_renderer_scheduler.cc',
       'renderer/scheduler/webthread_impl_for_renderer_scheduler.h',
       'renderer/screen_orientation/screen_orientation_dispatcher.cc',

content/renderer/renderer_blink_platform_impl.cc

@@ -22,6 +22,7 @@
 #include "content/child/npapi/npobject_util.h"
 #include "content/child/quota_dispatcher.h"
 #include "content/child/quota_message_filter.h"
+#include "content/child/scheduler/web_scheduler_impl.h"
 #include "content/child/simple_webmimeregistry_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/web_database_observer_impl.h"
@@ -52,7 +53,6 @@
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/renderer_clipboard_delegate.h"
 #include "content/renderer/scheduler/renderer_scheduler.h"
-#include "content/renderer/scheduler/web_scheduler_impl.h"
 #include "content/renderer/scheduler/webthread_impl_for_renderer_scheduler.h"
 #include "content/renderer/screen_orientation/screen_orientation_observer.h"
 #include "content/renderer/webclipboard_impl.h"
@@ -223,7 +223,11 @@ class RendererBlinkPlatformImpl::SandboxSupport
 RendererBlinkPlatformImpl::RendererBlinkPlatformImpl(
     RendererScheduler* renderer_scheduler)
     : BlinkPlatformImpl(renderer_scheduler->DefaultTaskRunner()),
-      web_scheduler_(new WebSchedulerImpl(renderer_scheduler)),
+      web_scheduler_(
+          new WebSchedulerImpl(renderer_scheduler,
+                               renderer_scheduler->IdleTaskRunner(),
+                               renderer_scheduler->LoadingTaskRunner(),
+                               renderer_scheduler->TimerTaskRunner())),
       main_thread_(new WebThreadImplForRendererScheduler(renderer_scheduler)),
       clipboard_delegate_(new RendererClipboardDelegate),
       clipboard_(new WebClipboardImpl(clipboard_delegate_.get())),

content/renderer/renderer_blink_platform_impl.h

@@ -35,6 +35,7 @@ class WebDeviceMotionData;
 class WebDeviceOrientationData;
 class WebGraphicsContext3DProvider;
 class WebServiceWorkerCacheStorage;
+class WebScheduler;
 }
 
 namespace content {
@@ -51,8 +52,8 @@ class ThreadSafeSender;
 class WebClipboardImpl;
 class WebDatabaseObserverImpl;
 class WebFileSystemImpl;
-class WebThreadImplForRendererScheduler;
 class WebSchedulerImpl;
+class WebThreadImplForRendererScheduler;
 
 class CONTENT_EXPORT RendererBlinkPlatformImpl : public BlinkPlatformImpl {
  public:

content/renderer/scheduler/webthread_impl_for_renderer_scheduler.cc

@@ -4,6 +4,7 @@
 
 #include "content/renderer/scheduler/webthread_impl_for_renderer_scheduler.h"
 
+#include "content/child/scheduler/web_scheduler_impl.h"
 #include "content/renderer/scheduler/renderer_scheduler.h"
 #include "third_party/WebKit/public/platform/WebTraceLocation.h"
 
@@ -11,7 +12,11 @@ namespace content {
 
 WebThreadImplForRendererScheduler::WebThreadImplForRendererScheduler(
     RendererScheduler* scheduler)
-    : task_runner_(scheduler->DefaultTaskRunner()),
+    : web_scheduler_(new WebSchedulerImpl(scheduler,
+                                          scheduler->IdleTaskRunner(),
+                                          scheduler->LoadingTaskRunner(),
+                                          scheduler->TimerTaskRunner())),
+      task_runner_(scheduler->DefaultTaskRunner()),
       idle_task_runner_(scheduler->IdleTaskRunner()),
       scheduler_(scheduler),
       thread_id_(base::PlatformThread::CurrentId()) {
@@ -24,6 +29,10 @@ blink::PlatformThreadId WebThreadImplForRendererScheduler::threadId() const {
   return thread_id_;
 }
 
+blink::WebScheduler* WebThreadImplForRendererScheduler::scheduler() const {
+  return web_scheduler_.get();
+}
+
 base::MessageLoop* WebThreadImplForRendererScheduler::MessageLoop() const {
   DCHECK(isCurrentThread());
   return base::MessageLoop::current();

content/renderer/scheduler/webthread_impl_for_renderer_scheduler.h

@@ -8,9 +8,14 @@
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "content/child/webthread_base.h"
 
+namespace blink {
+class WebScheduler;
+};
+
 namespace content {
 
 class RendererScheduler;
+class WebSchedulerImpl;
 
 class CONTENT_EXPORT WebThreadImplForRendererScheduler : public WebThreadBase {
  public:
@@ -18,6 +23,7 @@ class CONTENT_EXPORT WebThreadImplForRendererScheduler : public WebThreadBase {
   virtual ~WebThreadImplForRendererScheduler();
 
   // blink::WebThread implementation.
+  blink::WebScheduler* scheduler() const;
   blink::PlatformThreadId threadId() const override;
 
   // WebThreadBase implementation.
@@ -31,6 +37,7 @@ class CONTENT_EXPORT WebThreadImplForRendererScheduler : public WebThreadBase {
   void RemoveTaskObserverInternal(
       base::MessageLoop::TaskObserver* observer) override;
 
+  scoped_ptr<WebSchedulerImpl> web_scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
   RendererScheduler* scheduler_;  // Not owned.

content/test/test_blink_web_unit_test_support.cc

@@ -9,8 +9,8 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/child/scheduler/web_scheduler_impl.h"
 #include "content/renderer/scheduler/renderer_scheduler.h"
-#include "content/renderer/scheduler/web_scheduler_impl.h"
 #include "content/renderer/scheduler/webthread_impl_for_renderer_scheduler.h"
 #include "content/test/mock_webclipboard_impl.h"
 #include "content/test/web_gesture_curve_mock.h"
@@ -58,7 +58,10 @@ TestBlinkWebUnitTestSupport::TestBlinkWebUnitTestSupport() {
 
   if (base::MessageLoopProxy::current()) {
     renderer_scheduler_ = RendererScheduler::Create();
-    web_scheduler_.reset(new WebSchedulerImpl(renderer_scheduler_.get()));
+    web_scheduler_.reset(new WebSchedulerImpl(
+        renderer_scheduler_.get(), renderer_scheduler_->IdleTaskRunner(),
+        renderer_scheduler_->LoadingTaskRunner(),
+        renderer_scheduler_->TimerTaskRunner()));
     web_thread_.reset(
         new WebThreadImplForRendererScheduler(renderer_scheduler_.get()));
   }

content/test/test_blink_web_unit_test_support.h

@@ -22,6 +22,7 @@ class StatsTable;
 
 namespace blink {
 class WebLayerTreeView;
+class WebScheduler;
 }
 
 namespace content {