Enable ChildThreadImpl to refer ChildScheduler for IPC task runner

Now ChildThreadImpl needs to pass an IPC listener task runner to create
IPC::SyncChannel, but ChildThreadImpl can't refer schedulers. This CL
enables ChildThreadImpl to refer ChildScheduler by adding ChildScheduler
::IPCListenerTaskRunner function. Now the implementation
(RendererScheduler::IPCListenerTaskRunner) just returns base::
ThreadTaskRunnerHandle::Get().

This CL is just a preparation for flexible scheduling, and doesn't
change any behavior so far.

Bug: 780785
Change-Id: I46965cab95ca6f98dee56299df9ebea1462886d8
Reviewed-on: https://chromium-review.googlesource.com/760336Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: Hajime Hoshi <hajimehoshi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#515913}

content/child/child_thread_impl.cc

@@ -341,6 +341,13 @@ ChildThreadImpl::Options::Builder::AddStartupFilter(
   return *this;
 }
 
+ChildThreadImpl::Options::Builder&
+ChildThreadImpl::Options::Builder::IPCTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner) {
+  options_.ipc_task_runner = ipc_task_runner;
+  return *this;
+}
+
 ChildThreadImpl::Options ChildThreadImpl::Options::Builder::Build() {
   return options_;
 }
@@ -381,6 +388,7 @@ ChildThreadImpl::ChildThreadImpl(const Options& options)
       browser_process_io_runner_(options.browser_process_io_runner),
       channel_connected_factory_(
           new base::WeakPtrFactory<ChildThreadImpl>(this)),
+      ipc_task_runner_(options.ipc_task_runner),
       weak_factory_(this) {
   Init(options);
 }
@@ -432,10 +440,10 @@ void ChildThreadImpl::Init(const Options& options) {
   IPC::Logging::GetInstance();
 #endif
 
-  channel_ =
-      IPC::SyncChannel::Create(this, ChildProcess::current()->io_task_runner(),
-                               base::ThreadTaskRunnerHandle::Get(),
-                               ChildProcess::current()->GetShutDownEvent());
+  channel_ = IPC::SyncChannel::Create(
+      this, ChildProcess::current()->io_task_runner(),
+      ipc_task_runner_ ? ipc_task_runner_ : base::ThreadTaskRunnerHandle::Get(),
+      ChildProcess::current()->GetShutDownEvent());
 #if BUILDFLAG(IPC_MESSAGE_LOG_ENABLED)
   if (!IsInBrowserProcess())
     IPC::Logging::GetInstance()->SetIPCSender(this);

content/child/child_thread_impl.h

@@ -239,6 +239,8 @@ class CONTENT_EXPORT ChildThreadImpl
   std::unique_ptr<base::WeakPtrFactory<ChildThreadImpl>>
       channel_connected_factory_;
 
+  scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
+
   base::WeakPtrFactory<ChildThreadImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildThreadImpl);
@@ -256,6 +258,7 @@ struct ChildThreadImpl::Options {
   std::vector<IPC::MessageFilter*> startup_filters;
   mojo::edk::OutgoingBrokerClientInvitation* broker_client_invitation;
   std::string in_process_service_request_token;
+  scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner;
 
  private:
   Options();
@@ -269,6 +272,8 @@ class ChildThreadImpl::Options::Builder {
   Builder& AutoStartServiceManagerConnection(bool auto_start);
   Builder& ConnectToBrowser(bool connect_to_browser);
   Builder& AddStartupFilter(IPC::MessageFilter* filter);
+  Builder& IPCTaskRunner(
+      scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner);
 
   Options Build();
 

content/renderer/render_thread_impl.cc

@@ -627,11 +627,13 @@ RenderThreadImpl::RenderThreadImpl(
     const InProcessChildThreadParams& params,
     std::unique_ptr<blink::scheduler::RendererScheduler> scheduler,
     const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue)
-    : ChildThreadImpl(Options::Builder()
-                          .InBrowserProcess(params)
-                          .AutoStartServiceManagerConnection(false)
-                          .ConnectToBrowser(true)
-                          .Build()),
+    : ChildThreadImpl(
+          Options::Builder()
+              .InBrowserProcess(params)
+              .AutoStartServiceManagerConnection(false)
+              .ConnectToBrowser(true)
+              .IPCTaskRunner(scheduler ? scheduler->IPCTaskRunner() : nullptr)
+              .Build()),
       renderer_scheduler_(std::move(scheduler)),
       categorized_worker_pool_(new CategorizedWorkerPool()),
       renderer_binding_(this),

third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc

@@ -10,6 +10,7 @@
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "platform/scheduler/base/task_queue.h"
 #include "platform/scheduler/child/scheduler_helper.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate.h"
@@ -47,6 +48,11 @@ CompositorWorkerScheduler::IdleTaskRunner() {
       thread_->task_runner(), this);
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+CompositorWorkerScheduler::IPCTaskRunner() {
+  return base::ThreadTaskRunnerHandle::Get();
+}
+
 bool CompositorWorkerScheduler::CanExceedIdleDeadlineIfRequired() const {
   return false;
 }

third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.h

@@ -38,6 +38,7 @@ class PLATFORM_EXPORT CompositorWorkerScheduler
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;
   scoped_refptr<scheduler::SingleThreadIdleTaskRunner> IdleTaskRunner()
       override;
+  scoped_refptr<base::SingleThreadTaskRunner> IPCTaskRunner() override;
   bool ShouldYieldForHighPriorityWork() override;
   bool CanExceedIdleDeadlineIfRequired() const override;
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler_impl.cc

@@ -8,6 +8,7 @@
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "platform/Histogram.h"
@@ -92,6 +93,11 @@ WorkerSchedulerImpl::IdleTaskRunner() {
   return idle_helper_.IdleTaskRunner();
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+WorkerSchedulerImpl::IPCTaskRunner() {
+  return base::ThreadTaskRunnerHandle::Get();
+}
+
 bool WorkerSchedulerImpl::CanExceedIdleDeadlineIfRequired() const {
   DCHECK(initialized_);
   return idle_helper_.CanExceedIdleDeadlineIfRequired();

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler_impl.h

@@ -31,6 +31,7 @@ class PLATFORM_EXPORT WorkerSchedulerImpl : public WorkerScheduler,
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;
   scoped_refptr<WorkerTaskQueue> DefaultTaskQueue() override;
   scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() override;
+  scoped_refptr<base::SingleThreadTaskRunner> IPCTaskRunner() override;
   bool CanExceedIdleDeadlineIfRequired() const override;
   bool ShouldYieldForHighPriorityWork() override;
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc

@@ -322,6 +322,11 @@ RendererSchedulerImpl::IdleTaskRunner() {
   return idle_helper_.IdleTaskRunner();
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererSchedulerImpl::IPCTaskRunner() {
+  return base::ThreadTaskRunnerHandle::Get();
+}
+
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::LoadingTaskRunner() {
   helper_.CheckOnValidThread();

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.h

@@ -100,6 +100,7 @@ class PLATFORM_EXPORT RendererSchedulerImpl
   // RendererScheduler implementation:
   std::unique_ptr<WebThread> CreateMainThread() override;
   scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() override;
+  scoped_refptr<base::SingleThreadTaskRunner> IPCTaskRunner() override;
   std::unique_ptr<RenderWidgetSchedulingState> NewRenderWidgetSchedulingState()
       override;
   void WillBeginFrame(const viz::BeginFrameArgs& args) override;

third_party/WebKit/Source/platform/scheduler/test/fake_renderer_scheduler.cc

@@ -40,6 +40,11 @@ FakeRendererScheduler::IdleTaskRunner() {
   return nullptr;
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+FakeRendererScheduler::IPCTaskRunner() {
+  return nullptr;
+}
+
 std::unique_ptr<RenderWidgetSchedulingState>
 FakeRendererScheduler::NewRenderWidgetSchedulingState() {
   return nullptr;

third_party/WebKit/public/platform/scheduler/child/child_scheduler.h

@@ -30,6 +30,8 @@ class BLINK_PLATFORM_EXPORT ChildScheduler {
   // time if no idle time is available.
   virtual scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() = 0;
 
+  virtual scoped_refptr<base::SingleThreadTaskRunner> IPCTaskRunner() = 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|,

third_party/WebKit/public/platform/scheduler/test/fake_renderer_scheduler.h

@@ -25,6 +25,7 @@ class FakeRendererScheduler : public RendererScheduler {
   scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
   scoped_refptr<base::SingleThreadTaskRunner> LoadingTaskRunner() override;
   scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() override;
+  scoped_refptr<base::SingleThreadTaskRunner> IPCTaskRunner() override;
   std::unique_ptr<RenderWidgetSchedulingState> NewRenderWidgetSchedulingState()
       override;
   void WillBeginFrame(const viz::BeginFrameArgs& args) override;

third_party/WebKit/public/platform/scheduler/test/mock_renderer_scheduler.h

@@ -31,6 +31,7 @@ class MockRendererScheduler : public RendererScheduler {
                scoped_refptr<base::SingleThreadTaskRunner>());
   MOCK_METHOD0(IdleTaskRunner,
                scoped_refptr<blink::scheduler::SingleThreadIdleTaskRunner>());
+  MOCK_METHOD0(IPCTaskRunner, scoped_refptr<base::SingleThreadTaskRunner>());
   MOCK_METHOD0(NewRenderWidgetSchedulingState,
                std::unique_ptr<RenderWidgetSchedulingState>());
   MOCK_METHOD1(WillBeginFrame, void(const viz::BeginFrameArgs&));