[scheduler] Prioritise input events on the compositor thread

Bind input-related mojo interface to the input task runner and add a
feature to assign the highest priority to it.

BUG=857099
R=alexclarke@chromium.org,yutak@chromium.org,haraken@chromium.org,rkaplow@chromium.org
CC=​eseckler@chromium.org,hajimehoshi@chromium.org

Change-Id: I19f3e08bcc6af626dba298f31570102ddaffc4ac
Reviewed-on: https://chromium-review.googlesource.com/1117188Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Reviewed-by: Robert Kaplow <rkaplow@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Yuta Kitamura <yutak@chromium.org>
Commit-Queue: Alexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#571916}

content/renderer/render_widget.cc

@@ -574,10 +574,13 @@ void RenderWidget::Init(const ShowCallback& show_callback,
 
   RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
 
+  blink::scheduler::WebThreadScheduler* compositor_thread_scheduler =
+      blink::scheduler::WebThreadScheduler::CompositorThreadScheduler();
+
   widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
       weak_ptr_factory_.GetWeakPtr(),
-      render_thread_impl && compositor_
-          ? render_thread_impl->compositor_task_runner()
+      compositor_thread_scheduler && compositor_
+          ? compositor_thread_scheduler->InputTaskRunner()
           : nullptr,
       render_thread_impl ? render_thread_impl->GetWebMainThreadScheduler()
                          : nullptr);

testing/variations/fieldtrial_testing_config.json

@@ -757,7 +757,7 @@
             ]
         }
     ],
-    "BlinkSchedulerHighPriorityInput": [
+    "BlinkSchedulerHighPriorityInputOnCompositorThread": [
         {
             "platforms": [
                 "android",
@@ -769,7 +769,27 @@
             ],
             "experiments": [
                 {
-                    "name": "BlinkSchedulerHighPriorityInput",
+                    "name": "Enabled",
+                    "enable_features": [
+                        "BlinkSchedulerHighPriorityInputOnCompositorThread"
+                    ]
+                }
+            ]
+        }
+    ],
+    "BlinkSchedulerHighPriorityInputOnMainThread": [
+        {
+            "platforms": [
+                "android",
+                "chromeos",
+                "ios",
+                "linux",
+                "mac",
+                "win"
+            ],
+            "experiments": [
+                {
+                    "name": "Enabled",
                     "enable_features": [
                         "BlinkSchedulerHighPriorityInput"
                     ]

third_party/blink/public/platform/scheduler/web_thread_scheduler.h

@@ -74,6 +74,10 @@ class BLINK_PLATFORM_EXPORT WebThreadScheduler {
   static std::unique_ptr<WebThreadScheduler> CreateMainThreadScheduler(
       base::Optional<base::Time> initial_virtual_time = base::nullopt);
 
+  // Returns compositor thread scheduler for the compositor thread
+  // of the current process.
+  static WebThreadScheduler* CompositorThreadScheduler();
+
   // Returns the default task runner.
   virtual scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner();
 

third_party/blink/public/platform/task_type.h

@@ -183,11 +183,12 @@ enum class TaskType : unsigned {
   kMainThreadTaskQueueIPC = 42,
   kMainThreadTaskQueueControl = 43,
   kCompositorThreadTaskQueueDefault = 45,
+  kCompositorThreadTaskQueueInput = 49,
   kWorkerThreadTaskQueueDefault = 46,
   kWorkerThreadTaskQueueV8 = 47,
   kWorkerThreadTaskQueueCompositor = 48,
 
-  kCount = 49,
+  kCount = 50,
 };
 
 }  // namespace blink

third_party/blink/renderer/platform/scheduler/BUILD.gn

@@ -215,6 +215,7 @@ jumbo_source_set("unit_tests") {
     "renderer/webthread_impl_for_renderer_scheduler_unittest.cc",
     "util/thread_load_tracker_unittest.cc",
     "util/tracing_helper_unittest.cc",
+    "worker/compositor_thread_scheduler_unittest.cc",
     "worker/worker_scheduler_proxy_unittest.cc",
     "worker/worker_scheduler_unittest.cc",
     "worker/worker_thread_scheduler_unittest.cc",

third_party/blink/renderer/platform/scheduler/child/features.h

@@ -10,8 +10,12 @@
 namespace blink {
 namespace scheduler {
 
-const base::Feature kHighPriorityInput{"BlinkSchedulerHighPriorityInput",
-                                       base::FEATURE_DISABLED_BY_DEFAULT};
+const base::Feature kHighPriorityInputOnMainThread{
+    "BlinkSchedulerHighPriorityInput", base::FEATURE_DISABLED_BY_DEFAULT};
+
+const base::Feature kHighPriorityInputOnCompositorThread{
+    "BlinkSchedulerHighPriorityInputOnCompositorThread",
+    base::FEATURE_DISABLED_BY_DEFAULT};
 
 const base::Feature kDedicatedWorkerThrottling{
     "BlinkSchedulerWorkerThrottling", base::FEATURE_DISABLED_BY_DEFAULT};

third_party/blink/renderer/platform/scheduler/common/scheduler_helper.cc

@@ -32,9 +32,11 @@ void SchedulerHelper::InitDefaultQueues(
     TaskType default_task_type) {
   control_task_queue->SetQueuePriority(TaskQueue::kControlPriority);
 
+  default_task_runner_ =
+      TaskQueueWithTaskType::Create(default_task_queue, default_task_type);
+
   DCHECK(sequence_manager_);
-  sequence_manager_->SetDefaultTaskRunner(
-      TaskQueueWithTaskType::Create(default_task_queue, default_task_type));
+  sequence_manager_->SetDefaultTaskRunner(default_task_runner_);
 }
 
 SchedulerHelper::~SchedulerHelper() {
@@ -49,6 +51,11 @@ void SchedulerHelper::Shutdown() {
   sequence_manager_.reset();
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+SchedulerHelper::DefaultTaskRunner() {
+  return default_task_runner_;
+}
+
 void SchedulerHelper::SetWorkBatchSizeForTesting(size_t work_batch_size) {
   CheckOnValidThread();
   DCHECK(sequence_manager_.get());

third_party/blink/renderer/platform/scheduler/common/scheduler_helper.h

@@ -44,6 +44,9 @@ class PLATFORM_EXPORT SchedulerHelper
   virtual scoped_refptr<base::sequence_manager::TaskQueue>
   ControlTaskQueue() = 0;
 
+  // Returns task runner for the default queue.
+  scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner();
+
   // 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 class was created on.
@@ -108,6 +111,8 @@ class PLATFORM_EXPORT SchedulerHelper
  private:
   friend class SchedulerHelperTest;
 
+  scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
+
   Observer* observer_;  // NOT OWNED
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerHelper);

third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.cc

@@ -358,6 +358,7 @@ scoped_refptr<base::SingleThreadTaskRunner> FrameSchedulerImpl::GetTaskRunner(
     case TaskType::kMainThreadTaskQueueIPC:
     case TaskType::kMainThreadTaskQueueControl:
     case TaskType::kCompositorThreadTaskQueueDefault:
+    case TaskType::kCompositorThreadTaskQueueInput:
     case TaskType::kWorkerThreadTaskQueueDefault:
     case TaskType::kWorkerThreadTaskQueueV8:
     case TaskType::kWorkerThreadTaskQueueCompositor:

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc

@@ -203,6 +203,8 @@ const char* TaskTypeToString(TaskType task_type) {
       return "InternalIntersectionObserver";
     case TaskType::kCompositorThreadTaskQueueDefault:
       return "CompositorThreadTaskQueueDefault";
+    case TaskType::kCompositorThreadTaskQueueInput:
+      return "CompositorThreadTaskQueueInput";
     case TaskType::kWorkerThreadTaskQueueDefault:
       return "WorkerThreadTaskQueueDefault";
     case TaskType::kWorkerThreadTaskQueueV8:
@@ -321,9 +323,6 @@ MainThreadSchedulerImpl::MainThreadSchedulerImpl(
   control_task_runner_ =
       TaskQueueWithTaskType::Create(helper_.ControlMainThreadTaskQueue(),
                                     TaskType::kMainThreadTaskQueueControl);
-  default_task_runner_ =
-      TaskQueueWithTaskType::Create(helper_.DefaultMainThreadTaskQueue(),
-                                    TaskType::kMainThreadTaskQueueDefault);
   input_task_runner_ = TaskQueueWithTaskType::Create(
       input_task_queue_, TaskType::kMainThreadTaskQueueInput);
   ipc_task_runner_ = TaskQueueWithTaskType::Create(
@@ -635,7 +634,8 @@ MainThreadSchedulerImpl::AnyThread::AnyThread(
           YesNoStateToString) {}
 
 MainThreadSchedulerImpl::SchedulingSettings::SchedulingSettings() {
-  high_priority_input = base::FeatureList::IsEnabled(kHighPriorityInput);
+  high_priority_input =
+      base::FeatureList::IsEnabled(kHighPriorityInputOnMainThread);
 
   low_priority_background_page =
       base::FeatureList::IsEnabled(kLowPriorityForBackgroundPages);
@@ -701,7 +701,7 @@ MainThreadSchedulerImpl::ControlTaskRunner() {
 
 scoped_refptr<base::SingleThreadTaskRunner>
 MainThreadSchedulerImpl::DefaultTaskRunner() {
-  return default_task_runner_;
+  return helper_.DefaultTaskRunner();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h

@@ -762,7 +762,6 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
   scoped_refptr<TaskQueueWithTaskType> v8_task_runner_;
   scoped_refptr<TaskQueueWithTaskType> compositor_task_runner_;
   scoped_refptr<TaskQueueWithTaskType> control_task_runner_;
-  scoped_refptr<TaskQueueWithTaskType> default_task_runner_;
   scoped_refptr<TaskQueueWithTaskType> input_task_runner_;
   scoped_refptr<TaskQueueWithTaskType> ipc_task_runner_;
 

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc

@@ -307,7 +307,7 @@ class MainThreadSchedulerImplTest : public testing::Test {
   }
 
   MainThreadSchedulerImplTest()
-      : MainThreadSchedulerImplTest({kHighPriorityInput},
+      : MainThreadSchedulerImplTest({kHighPriorityInputOnMainThread},
                                     {kPrioritizeCompositingAfterInput}) {}
 
   ~MainThreadSchedulerImplTest() override = default;
@@ -3911,7 +3911,7 @@ class CompositingExperimentWithExplicitSignalsTest
  public:
   CompositingExperimentWithExplicitSignalsTest()
       : MainThreadSchedulerImplTest(
-            {kHighPriorityInput, kPrioritizeCompositingAfterInput,
+            {kHighPriorityInputOnMainThread, kPrioritizeCompositingAfterInput,
              kUseExplicitSignalForTriggeringCompositingPrioritization,
              kUseWillBeginMainFrameForCompositingPrioritization},
             {}) {}
@@ -3953,7 +3953,7 @@ class CompositingExperimentWithImplicitSignalsTest
  public:
   CompositingExperimentWithImplicitSignalsTest()
       : MainThreadSchedulerImplTest(
-            {kHighPriorityInput, kPrioritizeCompositingAfterInput},
+            {kHighPriorityInputOnMainThread, kPrioritizeCompositingAfterInput},
             {kHighestPriorityForCompositingAfterInput,
              kUseExplicitSignalForTriggeringCompositingPrioritization,
              kUseWillBeginMainFrameForCompositingPrioritization}) {}

third_party/blink/renderer/platform/scheduler/worker/compositor_thread_scheduler.cc

@@ -13,20 +13,53 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "third_party/blink/public/platform/task_type.h"
 #include "third_party/blink/renderer/platform/scheduler/base/task_queue_forward.h"
+#include "third_party/blink/renderer/platform/scheduler/child/features.h"
 #include "third_party/blink/renderer/platform/scheduler/child/task_queue_with_task_type.h"
 #include "third_party/blink/renderer/platform/scheduler/common/scheduler_helper.h"
 
 namespace blink {
 namespace scheduler {
 
+namespace {
+
+CompositorThreadScheduler* g_compositor_thread_scheduler = nullptr;
+
+}  // namespace
+
+// static
+WebThreadScheduler* WebThreadScheduler::CompositorThreadScheduler() {
+  return g_compositor_thread_scheduler;
+}
+
 CompositorThreadScheduler::CompositorThreadScheduler(
     std::unique_ptr<base::sequence_manager::SequenceManager> sequence_manager)
     : NonMainThreadSchedulerImpl(std::make_unique<NonMainThreadSchedulerHelper>(
           std::move(sequence_manager),
           this,
-          TaskType::kCompositorThreadTaskQueueDefault)) {}
+          TaskType::kCompositorThreadTaskQueueDefault)),
+      input_task_queue_(
+          base::FeatureList::IsEnabled(kHighPriorityInputOnCompositorThread)
+              ? helper()->NewTaskQueue(
+                    base::sequence_manager::TaskQueue::Spec("input_tq")
+                        .SetShouldMonitorQuiescence(true))
+              : nullptr),
+      input_task_runner_(input_task_queue_
+                             ? TaskQueueWithTaskType::Create(
+                                   input_task_queue_,
+                                   TaskType::kCompositorThreadTaskQueueInput)
+                             : nullptr) {
+  if (input_task_queue_) {
+    input_task_queue_->SetQueuePriority(
+        base::sequence_manager::TaskQueue::QueuePriority::kHighestPriority);
+  }
+  DCHECK(!g_compositor_thread_scheduler);
+  g_compositor_thread_scheduler = this;
+}
 
-CompositorThreadScheduler::~CompositorThreadScheduler() = default;
+CompositorThreadScheduler::~CompositorThreadScheduler() {
+  DCHECK_EQ(g_compositor_thread_scheduler, this);
+  g_compositor_thread_scheduler = nullptr;
+}
 
 scoped_refptr<NonMainThreadTaskQueue>
 CompositorThreadScheduler::DefaultTaskQueue() {
@@ -51,8 +84,15 @@ CompositorThreadScheduler::IdleTaskRunner() {
   // an idle task runner with the semantics we want for the compositor thread
   // which runs them after the current frame has been drawn before the next
   // vsync. https://crbug.com/609532
-  return base::MakeRefCounted<SingleThreadIdleTaskRunner>(DefaultTaskQueue(),
-                                                          this);
+  return base::MakeRefCounted<SingleThreadIdleTaskRunner>(
+      helper()->DefaultTaskRunner(), this);
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+CompositorThreadScheduler::InputTaskRunner() {
+  if (input_task_runner_)
+    return input_task_runner_;
+  return helper()->DefaultTaskRunner();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
@@ -85,7 +125,9 @@ void CompositorThreadScheduler::RemoveTaskObserver(
   helper()->RemoveTaskObserver(task_observer);
 }
 
-void CompositorThreadScheduler::Shutdown() {}
+void CompositorThreadScheduler::Shutdown() {
+  input_task_queue_->ShutdownTaskQueue();
+}
 
 void CompositorThreadScheduler::OnIdleTaskPosted() {}
 

third_party/blink/renderer/platform/scheduler/worker/compositor_thread_scheduler.h

@@ -41,6 +41,7 @@ class PLATFORM_EXPORT CompositorThreadScheduler
       override;
   scoped_refptr<base::SingleThreadTaskRunner> V8TaskRunner() override;
   scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
+  scoped_refptr<base::SingleThreadTaskRunner> InputTaskRunner() override;
   bool ShouldYieldForHighPriorityWork() override;
   bool CanExceedIdleDeadlineIfRequired() const override;
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;
@@ -59,6 +60,9 @@ class PLATFORM_EXPORT CompositorThreadScheduler
   void InitImpl() override;
 
  private:
+  scoped_refptr<NonMainThreadTaskQueue> input_task_queue_;
+  scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
+
   CompositorMetricsHelper compositor_metrics_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositorThreadScheduler);

third_party/blink/renderer/platform/scheduler/worker/compositor_thread_scheduler_unittest.cc

+// Copyright 2017 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 "third_party/blink/renderer/platform/scheduler/worker/compositor_thread_scheduler.h"
+#include <memory>
+#include "base/macros.h"
+#include "base/test/scoped_feature_list.h"
+#include "base/test/simple_test_tick_clock.h"
+#include "base/test/test_mock_time_task_runner.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/renderer/platform/scheduler/base/test/sequence_manager_for_test.h"
+#include "third_party/blink/renderer/platform/scheduler/child/features.h"
+#include "third_party/blink/renderer/platform/wtf/functional.h"
+
+using testing::ElementsAreArray;
+using testing::ElementsAre;
+
+namespace blink {
+namespace scheduler {
+// To avoid symbol collisions in jumbo builds.
+namespace compositor_thread_scheduler_unittest {
+
+class CompositorThreadSchedulerTest : public testing::Test {
+ public:
+  CompositorThreadSchedulerTest(
+      std::vector<base::Feature> features_to_enable,
+      std::vector<base::Feature> features_to_disable) {
+    feature_list_.InitWithFeatures(features_to_enable, features_to_disable);
+  }
+
+  CompositorThreadSchedulerTest() : CompositorThreadSchedulerTest({}, {}) {}
+
+  ~CompositorThreadSchedulerTest() override = default;
+
+  void SetUp() override {
+    mock_task_runner_ = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
+    mock_task_runner_->AdvanceMockTickClock(
+        base::TimeDelta::FromMicroseconds(5000));
+
+    scheduler_ = std::make_unique<CompositorThreadScheduler>(
+        base::sequence_manager::SequenceManagerForTest::Create(
+            nullptr, mock_task_runner_, mock_task_runner_->GetMockTickClock()));
+    scheduler_->Init();
+  }
+
+  void TearDown() override {}
+
+ protected:
+  base::test::ScopedFeatureList feature_list_;
+
+  scoped_refptr<base::TestMockTimeTaskRunner> mock_task_runner_;
+  std::unique_ptr<CompositorThreadScheduler> scheduler_;
+
+  DISALLOW_COPY_AND_ASSIGN(CompositorThreadSchedulerTest);
+};
+
+class CompositorThreadInputPriorityTest : public CompositorThreadSchedulerTest {
+ public:
+  CompositorThreadInputPriorityTest()
+      : CompositorThreadSchedulerTest(
+            {kHighPriorityInputOnCompositorThread} /* features_to_enable */,
+            {} /* features_to_disable */) {}
+  ~CompositorThreadInputPriorityTest() override = default;
+};
+
+namespace {
+
+void RunTestTask(std::string name, std::vector<std::string>* log) {
+  log->push_back(name);
+}
+
+}  // namespace
+
+TEST_F(CompositorThreadInputPriorityTest, HighestPriorityInput) {
+  std::vector<std::string> run_order;
+
+  scheduler_->DefaultTaskQueue()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&RunTestTask, "default", base::Unretained(&run_order)));
+  scheduler_->InputTaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&RunTestTask, "input", base::Unretained(&run_order)));
+
+  mock_task_runner_->RunUntilIdle();
+
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("input"),
+                                              std::string("default")));
+}
+
+class CompositorThreadNoInputPriorityTest
+    : public CompositorThreadSchedulerTest {
+ public:
+  CompositorThreadNoInputPriorityTest()
+      : CompositorThreadSchedulerTest(
+            {} /* features_to_enable */,
+            {kHighPriorityInputOnCompositorThread} /* features_to_disable */) {}
+  ~CompositorThreadNoInputPriorityTest() override = default;
+};
+
+TEST_F(CompositorThreadNoInputPriorityTest, InputNotPrioritized) {
+  std::vector<std::string> run_order;
+
+  scheduler_->DefaultTaskQueue()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&RunTestTask, "default", base::Unretained(&run_order)));
+  scheduler_->InputTaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&RunTestTask, "input", base::Unretained(&run_order)));
+
+  mock_task_runner_->RunUntilIdle();
+
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("default"),
+                                              std::string("input")));
+}
+}  // namespace compositor_thread_scheduler_unittest
+}  // namespace scheduler
+}  // namespace blink

third_party/blink/renderer/platform/scheduler/worker/worker_scheduler.cc

@@ -137,6 +137,7 @@ scoped_refptr<base::SingleThreadTaskRunner> WorkerScheduler::GetTaskRunner(
     case TaskType::kMainThreadTaskQueueIPC:
     case TaskType::kMainThreadTaskQueueControl:
     case TaskType::kCompositorThreadTaskQueueDefault:
+    case TaskType::kCompositorThreadTaskQueueInput:
     case TaskType::kWorkerThreadTaskQueueDefault:
     case TaskType::kWorkerThreadTaskQueueV8:
     case TaskType::kWorkerThreadTaskQueueCompositor: