Forward input and compositing tasks to the Blink scheduler

Instead of posting input and compositor tasks directly to the
main thread message loop, forward them to the Blink scheduler
so they can be prioritized over other tasks.

BUG=391005

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=290845

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

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

content/content_renderer.gypi

@@ -387,6 +387,7 @@
       'renderer/sad_plugin.h',
       'renderer/savable_resources.cc',
       'renderer/savable_resources.h',
+      'renderer/scheduler_proxy_task_runner.h',
       'renderer/screen_orientation/screen_orientation_dispatcher.cc',
       'renderer/screen_orientation/screen_orientation_dispatcher.h',
       'renderer/screen_orientation/screen_orientation_observer.cc',

content/content_tests.gypi

@@ -1214,6 +1214,7 @@
             'renderer/render_widget_browsertest.cc',
             'renderer/resource_fetcher_browsertest.cc',
             'renderer/savable_resources_browsertest.cc',
+            'renderer/scheduler_proxy_task_runner_browsertest.cc',
             'test/accessibility_browser_test_utils.cc',
             'test/accessibility_browser_test_utils.h',
             'test/content_browser_test_test.cc',

content/renderer/gpu/render_widget_compositor.cc

@@ -515,6 +515,8 @@ bool RenderWidgetCompositor::SendMessageToMicroBenchmark(
 
 void RenderWidgetCompositor::Initialize(cc::LayerTreeSettings settings) {
   scoped_refptr<base::MessageLoopProxy> compositor_message_loop_proxy;
+  scoped_refptr<base::SingleThreadTaskRunner>
+      main_thread_compositor_task_runner(base::MessageLoopProxy::current());
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   cc::SharedBitmapManager* shared_bitmap_manager = NULL;
   // render_thread may be NULL in tests.
@@ -522,21 +524,23 @@ void RenderWidgetCompositor::Initialize(cc::LayerTreeSettings settings) {
     compositor_message_loop_proxy =
         render_thread->compositor_message_loop_proxy();
     shared_bitmap_manager = render_thread->shared_bitmap_manager();
+    main_thread_compositor_task_runner =
+        render_thread->main_thread_compositor_task_runner();
   }
   if (compositor_message_loop_proxy.get()) {
-    layer_tree_host_ = cc::LayerTreeHost::CreateThreaded(
-        this,
-        shared_bitmap_manager,
-        settings,
-        base::MessageLoopProxy::current(),
-        compositor_message_loop_proxy);
+    layer_tree_host_ =
+        cc::LayerTreeHost::CreateThreaded(this,
+                                          shared_bitmap_manager,
+                                          settings,
+                                          main_thread_compositor_task_runner,
+                                          compositor_message_loop_proxy);
   } else {
     layer_tree_host_ = cc::LayerTreeHost::CreateSingleThreaded(
         this,
         this,
         shared_bitmap_manager,
         settings,
-        base::MessageLoopProxy::current());
+        main_thread_compositor_task_runner);
   }
   DCHECK(layer_tree_host_);
 }

content/renderer/input/input_event_filter.cc

@@ -10,6 +10,7 @@
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "cc/input/input_handler.h"
 #include "content/common/input/did_overscroll_params.h"
 #include "content/common/input/web_input_event_traits.h"
@@ -41,8 +42,9 @@ namespace content {
 
 InputEventFilter::InputEventFilter(
     IPC::Listener* main_listener,
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     const scoped_refptr<base::MessageLoopProxy>& target_loop)
-    : main_loop_(base::MessageLoopProxy::current()),
+    : main_task_runner_(main_task_runner),
       main_listener_(main_listener),
       sender_(NULL),
       target_loop_(target_loop),
@@ -55,7 +57,7 @@ InputEventFilter::InputEventFilter(
 }
 
 void InputEventFilter::SetBoundHandler(const Handler& handler) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   handler_ = handler;
 }
 
@@ -148,10 +150,9 @@ void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
         "input",
         "InputEventFilter::ForwardToHandler::ForwardToMainListener",
         TRACE_EVENT_SCOPE_THREAD);
-    main_loop_->PostTask(
+    main_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&InputEventFilter::ForwardToMainListener,
-                   this, message));
+        base::Bind(&InputEventFilter::ForwardToMainListener, this, message));
     return;
   }
 
@@ -183,10 +184,9 @@ void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
         TRACE_EVENT_SCOPE_THREAD);
     IPC::Message new_msg = InputMsg_HandleInputEvent(
         routing_id, event, latency_info, is_keyboard_shortcut);
-    main_loop_->PostTask(
+    main_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&InputEventFilter::ForwardToMainListener,
-                   this, new_msg));
+        base::Bind(&InputEventFilter::ForwardToMainListener, this, new_msg));
     return;
   }
 

content/renderer/input/input_event_filter.h

@@ -18,6 +18,7 @@
 
 namespace base {
 class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace IPC {
@@ -38,8 +39,10 @@ namespace content {
 class CONTENT_EXPORT InputEventFilter : public InputHandlerManagerClient,
                                         public IPC::MessageFilter {
  public:
-  InputEventFilter(IPC::Listener* main_listener,
-                   const scoped_refptr<base::MessageLoopProxy>& target_loop);
+  InputEventFilter(
+      IPC::Listener* main_listener,
+      const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
+      const scoped_refptr<base::MessageLoopProxy>& target_loop);
 
   // The |handler| is invoked on the thread associated with |target_loop| to
   // handle input events matching the filtered routes.
@@ -73,7 +76,7 @@ class CONTENT_EXPORT InputEventFilter : public InputHandlerManagerClient,
   void SendMessage(scoped_ptr<IPC::Message> message);
   void SendMessageOnIOThread(scoped_ptr<IPC::Message> message);
 
-  scoped_refptr<base::MessageLoopProxy> main_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   IPC::Listener* main_listener_;
 
   // The sender_ only gets invoked on the thread corresponding to io_loop_.

content/renderer/input/input_event_filter_unittest.cc

@@ -126,9 +126,9 @@ void AddEventsToFilter(IPC::MessageFilter* message_filter,
 class InputEventFilterTest : public testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
-    filter_ = new InputEventFilter(
-        &message_recorder_,
-        message_loop_.message_loop_proxy());
+    filter_ = new InputEventFilter(&message_recorder_,
+                                   base::MessageLoopProxy::current(),
+                                   message_loop_.message_loop_proxy());
     filter_->SetBoundHandler(
         base::Bind(&InputEventRecorder::HandleInputEvent,
             base::Unretained(&event_recorder_)));

content/renderer/render_thread_impl.cc

@@ -21,6 +21,7 @@
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_table.h"
 #include "base/path_service.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
@@ -91,6 +92,7 @@
 #include "content/renderer/render_process_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
+#include "content/renderer/scheduler_proxy_task_runner.h"
 #include "content/renderer/service_worker/embedded_worker_context_message_filter.h"
 #include "content/renderer/service_worker/embedded_worker_dispatcher.h"
 #include "content/renderer/shared_worker/embedded_shared_worker_stub.h"
@@ -105,6 +107,7 @@
 #include "net/base/net_util.h"
 #include "skia/ext/event_tracer_impl.h"
 #include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/platform/WebThread.h"
 #include "third_party/WebKit/public/web/WebColorName.h"
 #include "third_party/WebKit/public/web/WebDatabase.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
@@ -651,6 +654,9 @@ void RenderThreadImpl::Shutdown() {
   // hold pointers to V8 objects (e.g., via pending requests).
   main_thread_indexed_db_dispatcher_.reset();
 
+  main_thread_compositor_task_runner_ = NULL;
+  main_thread_input_task_runner_ = NULL;
+
   if (webkit_platform_support_)
     blink::shutdown();
 
@@ -833,6 +839,11 @@ void RenderThreadImpl::EnsureWebKitInitialized() {
 
   webkit_platform_support_.reset(new RendererWebKitPlatformSupportImpl);
   blink::initialize(webkit_platform_support_.get());
+  main_thread_compositor_task_runner_ =
+      make_scoped_refptr(new SchedulerProxyTaskRunner<
+          &blink::WebSchedulerProxy::postCompositorTask>());
+  main_thread_input_task_runner_ = make_scoped_refptr(
+      new SchedulerProxyTaskRunner<&blink::WebSchedulerProxy::postInputTask>());
 
   v8::Isolate* isolate = blink::mainThreadIsolate();
 
@@ -872,8 +883,8 @@ void RenderThreadImpl::EnsureWebKitInitialized() {
     }
 #endif
     if (!input_handler_manager_client) {
-      input_event_filter_ =
-          new InputEventFilter(this, compositor_message_loop_proxy_);
+      input_event_filter_ = new InputEventFilter(
+          this, main_thread_input_task_runner_, compositor_message_loop_proxy_);
       AddFilter(input_event_filter_.get());
       input_handler_manager_client = input_event_filter_.get();
     }

content/renderer/render_thread_impl.h

@@ -43,6 +43,7 @@ class WebMediaStreamCenterClient;
 
 namespace base {
 class MessageLoopProxy;
+class SingleThreadTaskRunner;
 class Thread;
 }
 
@@ -198,6 +199,11 @@ class CONTENT_EXPORT RenderThreadImpl : public RenderThread,
     return webkit_platform_support_.get();
   }
 
+  scoped_refptr<base::SingleThreadTaskRunner>
+  main_thread_compositor_task_runner() const {
+    return main_thread_compositor_task_runner_;
+  }
+
   IPC::ForwardingMessageFilter* compositor_output_surface_filter() const {
     return compositor_output_surface_filter_.get();
   }
@@ -569,6 +575,10 @@ class CONTENT_EXPORT RenderThreadImpl : public RenderThread,
 
   scoped_ptr<MemoryObserver> memory_observer_;
 
+  scoped_refptr<base::SingleThreadTaskRunner>
+      main_thread_compositor_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_input_task_runner_;
+
   // Compositor settings
   bool is_gpu_rasterization_enabled_;
   bool is_gpu_rasterization_forced_;

content/renderer/scheduler_proxy_task_runner.h

+// 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.
+
+#ifndef CONTENT_RENDERER_SCHEDULER_PROXY_TASK_RUNNER_H_
+#define CONTENT_RENDERER_SCHEDULER_PROXY_TASK_RUNNER_H_
+
+#include "base/debug/task_annotator.h"
+#include "base/pending_task.h"
+#include "content/renderer/render_thread_impl.h"
+#include "third_party/WebKit/public/platform/WebSchedulerProxy.h"
+#include "third_party/WebKit/public/platform/WebTraceLocation.h"
+
+namespace content {
+
+// Helper for forwarding posted tasks into different WebSchedulerProxy queues.
+template <void (blink::WebSchedulerProxy::*ProxyFunction)(
+    const blink::WebTraceLocation& location,
+    blink::WebThread::Task* task)>
+class SchedulerProxyTaskRunner : public base::SingleThreadTaskRunner {
+ public:
+  SchedulerProxyTaskRunner()
+      : main_thread_id_(base::PlatformThread::CurrentId()),
+        scheduler_proxy_(blink::WebSchedulerProxy::create()),
+        next_sequence_num_(0) {}
+
+  // base::SingleThreadTaskRunner implementation:
+  virtual bool RunsTasksOnCurrentThread() const OVERRIDE {
+    return base::PlatformThread::CurrentId() == main_thread_id_;
+  }
+
+  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
+                               const base::Closure& task,
+                               base::TimeDelta delay) OVERRIDE {
+    DCHECK(delay == base::TimeDelta());
+    base::PendingTask pending_task(from_here, task);
+    pending_task.sequence_num = ++next_sequence_num_;
+    task_annotator_.DidQueueTask("SchedulerProxyTaskRunner::PostDelayedTask",
+                                 pending_task);
+    blink::WebTraceLocation location(from_here.function_name(),
+                                     from_here.file_name());
+    TaskAdapter* task_adapter = new TaskAdapter(&task_annotator_, pending_task);
+    (scheduler_proxy_.*ProxyFunction)(location, task_adapter);
+    return true;
+  }
+
+  virtual bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task,
+      base::TimeDelta delay) OVERRIDE {
+    NOTREACHED();
+    return false;
+  }
+
+ protected:
+  virtual ~SchedulerProxyTaskRunner() {}
+
+ private:
+  class TaskAdapter : public blink::WebThread::Task {
+   public:
+    explicit TaskAdapter(base::debug::TaskAnnotator* task_annotator,
+                         const base::PendingTask& pending_task)
+        : task_annotator_(task_annotator), pending_task_(pending_task) {}
+    virtual ~TaskAdapter() {}
+
+    virtual void run() {
+      task_annotator_->RunTask("SchedulerProxyTaskRunner::PostDelayedTask",
+                               "SchedulerProxyTaskRunner::RunTask",
+                               pending_task_);
+    }
+
+   private:
+    base::debug::TaskAnnotator* task_annotator_;
+    base::PendingTask pending_task_;
+  };
+
+  const base::PlatformThreadId main_thread_id_;
+  blink::WebSchedulerProxy scheduler_proxy_;
+  base::debug::TaskAnnotator task_annotator_;
+  int next_sequence_num_;
+
+  DISALLOW_COPY_AND_ASSIGN(SchedulerProxyTaskRunner);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_SCHEDULER_PROXY_TASK_RUNNER_H_

content/renderer/scheduler_proxy_task_runner_browsertest.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/public/browser/content_browser_client.h"
+#include "content/public/common/content_client.h"
+#include "content/public/renderer/content_renderer_client.h"
+#include "content/renderer/render_process_impl.h"
+#include "content/renderer/render_thread_impl.h"
+#include "content/renderer/scheduler_proxy_task_runner.h"
+#include "content/test/mock_render_process.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+namespace {
+
+void TestTask(int value, int* result) {
+  *result = (*result << 4) | value;
+}
+
+}  // namespace
+
+class DummyListener : public IPC::Listener {
+ public:
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+    return true;
+  }
+};
+
+TEST(SchedulerProxyTaskRunnerBrowserTest, TestTaskPosting) {
+  ContentClient content_client;
+  ContentBrowserClient content_browser_client;
+  ContentRendererClient content_renderer_client;
+  SetContentClient(&content_client);
+  SetBrowserClientForTesting(&content_browser_client);
+  SetRendererClientForTesting(&content_renderer_client);
+  base::MessageLoopForIO message_loop;
+
+  std::string channel_id =
+      IPC::Channel::GenerateVerifiedChannelID(std::string());
+  DummyListener dummy_listener;
+  scoped_ptr<IPC::Channel> channel(
+      IPC::Channel::CreateServer(channel_id, &dummy_listener));
+  EXPECT_TRUE(channel->Connect());
+
+  scoped_ptr<MockRenderProcess> mock_process(new MockRenderProcess);
+  // Owned by mock_process.
+  RenderThreadImpl* thread = new RenderThreadImpl(channel_id);
+  thread->EnsureWebKitInitialized();
+
+  scoped_refptr<base::SingleThreadTaskRunner> input_task_runner =
+      make_scoped_refptr(new SchedulerProxyTaskRunner<
+          &blink::WebSchedulerProxy::postInputTask>());
+  scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner =
+      make_scoped_refptr(new SchedulerProxyTaskRunner<
+          &blink::WebSchedulerProxy::postCompositorTask>());
+
+  int input_order = 0;
+  int compositor_order = 0;
+
+  input_task_runner->PostTask(FROM_HERE,
+                              base::Bind(&TestTask, 1, &input_order));
+  compositor_task_runner->PostTask(FROM_HERE,
+                                   base::Bind(&TestTask, 1, &compositor_order));
+  input_task_runner->PostTask(FROM_HERE,
+                              base::Bind(&TestTask, 2, &input_order));
+  compositor_task_runner->PostTask(FROM_HERE,
+                                   base::Bind(&TestTask, 2, &compositor_order));
+
+  input_task_runner->PostTask(FROM_HERE,
+                              base::Bind(&TestTask, 3, &input_order));
+  input_task_runner->PostTask(FROM_HERE,
+                              base::Bind(&TestTask, 4, &input_order));
+  compositor_task_runner->PostTask(FROM_HERE,
+                                   base::Bind(&TestTask, 3, &compositor_order));
+  compositor_task_runner->PostTask(FROM_HERE,
+                                   base::Bind(&TestTask, 4, &compositor_order));
+
+  message_loop.RunUntilIdle();
+
+  EXPECT_EQ(0x1234, input_order);
+  EXPECT_EQ(0x1234, compositor_order);
+}
+
+}  // namespace content