Fix priority of TaskQueue::QueueType::COMPOSITOR on touch events

content/renderer/input/input_handler_manager_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 <map>
+
+#include "base/message_loop/message_loop.h"
+#include "base/test/test_simple_task_runner.h"
+#include "content/public/test/mock_render_thread.h"
+#include "content/renderer/input/input_handler_manager.h"
+#include "content/renderer/input/input_handler_manager_client.h"
+#include "content/renderer/render_view_impl.h"
+#include "content/test/fake_compositor_dependencies.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebTouchEvent.h"
+#include "third_party/WebKit/public/platform/scheduler/test/fake_renderer_scheduler.h"
+#include "ui/events/latency_info.h"
+
+namespace content {
+
+namespace {
+
+const int kTestRoutingID = 13;
+
+class TestRendererScheduler : public blink::scheduler::FakeRendererScheduler {
+ public:
+  TestRendererScheduler() : input_event_handled_(false) {}
+  ~TestRendererScheduler() override {}
+
+  // RendererScheduler implementation:
+  void DidHandleInputEventOnCompositorThread(
+      const blink::WebInputEvent& web_input_event,
+      InputEventState event_state) override {
+    input_event_handled_ = true;
+  }
+
+  bool input_event_handled() const { return input_event_handled_; }
+
+ private:
+  bool input_event_handled_;
+  DISALLOW_COPY_AND_ASSIGN(TestRendererScheduler);
+};
+
+class TestInputHandlerManagerClient : public InputHandlerManagerClient {
+ public:
+  TestInputHandlerManagerClient() {}
+  ~TestInputHandlerManagerClient() override {}
+
+  void SetInputHandlerManager(InputHandlerManager*) override {}
+  void NotifyInputEventHandled(int routing_id,
+                               blink::WebInputEvent::Type type,
+                               blink::WebInputEventResult result,
+                               InputEventAckState ack_result) override {}
+  void ProcessRafAlignedInput(int routing_id,
+                              base::TimeTicks frame_time) override {}
+
+  void RegisterRoutingID(int routing_id) override {}
+  void UnregisterRoutingID(int routing_id) override {}
+
+  void DidOverscroll(int routing_id,
+                     const ui::DidOverscrollParams& params) override {}
+  void DidStopFlinging(int routing_id) override {}
+  void DispatchNonBlockingEventToMainThread(
+      int routing_id,
+      ui::WebScopedInputEvent event,
+      const ui::LatencyInfo& latency_info) override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestInputHandlerManagerClient);
+};
+
+class TestInputHandler : public cc::InputHandler,
+                         public base::SupportsWeakPtr<TestInputHandler> {
+ public:
+  TestInputHandler() : factory_(this) {}
+  ~TestInputHandler() override {}
+
+  void BindToClient(cc::InputHandlerClient* client) override {}
+
+  ScrollStatus ScrollBegin(cc::ScrollState* scroll_state,
+                           ScrollInputType type) override {
+    return ScrollStatus();
+  }
+
+  ScrollStatus RootScrollBegin(cc::ScrollState* scroll_state,
+                               ScrollInputType type) override {
+    return ScrollStatus();
+  }
+
+  ScrollStatus ScrollAnimatedBegin(const gfx::Point& viewport_point) override {
+    return ScrollStatus();
+  }
+
+  ScrollStatus ScrollAnimated(const gfx::Point& viewport_point,
+                              const gfx::Vector2dF& scroll_delta,
+                              base::TimeDelta delayed_by) override {
+    return ScrollStatus();
+  }
+
+  cc::InputHandlerScrollResult ScrollBy(
+      cc::ScrollState* scroll_state) override {
+    return cc::InputHandlerScrollResult();
+  }
+
+  ScrollStatus FlingScrollBegin() override { return ScrollStatus(); }
+
+  void MouseMoveAt(const gfx::Point& mouse_position) override {}
+  void MouseDown() override {}
+  void MouseUp() override {}
+  void MouseLeave() override {}
+  void ScrollEnd(cc::ScrollState* scroll_state) override {}
+  void RequestUpdateForSynchronousInputHandler() override {}
+  void SetSynchronousInputHandlerRootScrollOffset(
+      const gfx::ScrollOffset& root_offset) override {}
+  void PinchGestureBegin() override {}
+  void PinchGestureUpdate(float magnify_delta,
+                          const gfx::Point& anchor) override {}
+  void PinchGestureEnd() override {}
+  void SetNeedsAnimateInput() override {}
+  bool IsCurrentlyScrollingViewport() const override { return false; }
+
+  bool IsCurrentlyScrollingLayerAt(const gfx::Point& viewport_point,
+                                   ScrollInputType type) const override {
+    return false;
+  }
+
+  TouchStartEventListenerType EventListenerTypeForTouchStartAt(
+      const gfx::Point& viewport_point) override {
+    return TouchStartEventListenerType::NO_HANDLER;
+  }
+
+  std::unique_ptr<cc::SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
+      ui::LatencyInfo* latency) override {
+    return nullptr;
+  }
+
+  cc::ScrollElasticityHelper* CreateScrollElasticityHelper() override {
+    return nullptr;
+  }
+
+  bool GetScrollOffsetForLayer(int layer_id,
+                               gfx::ScrollOffset* offset) override {
+    return false;
+  }
+
+  bool ScrollLayerTo(int layer_id, const gfx::ScrollOffset& offset) override {
+    return false;
+  }
+
+  cc::EventListenerProperties GetEventListenerProperties(
+      cc::EventListenerClass event_class) const override {
+    auto found = event_listeners_properties_.find(event_class);
+    if (found == event_listeners_properties_.end()) {
+      return cc::EventListenerProperties::kNone;
+    }
+    return found->second;
+  }
+
+  void SetEventListenerProperties(cc::EventListenerClass event_class,
+                                  cc::EventListenerProperties properties) {
+    event_listeners_properties_[event_class] = properties;
+  }
+
+  base::WeakPtr<TestInputHandler> AsWeakPtr() { return factory_.GetWeakPtr(); }
+
+ private:
+  std::map<cc::EventListenerClass, cc::EventListenerProperties>
+      event_listeners_properties_;
+
+  base::WeakPtrFactory<TestInputHandler> factory_;
+  DISALLOW_COPY_AND_ASSIGN(TestInputHandler);
+};
+
+}  // namespace
+
+class InputHandlerManagerTest : public testing::Test {
+ public:
+  void SetUp() override {
+    testing::Test::SetUp();
+
+    compositor_task_runner_ = new base::TestSimpleTaskRunner();
+
+    input_handler_manager_ = base::MakeUnique<InputHandlerManager>(
+        compositor_task_runner_, &client_, nullptr, &renderer_scheduler_);
+    input_handler_manager_->AddInputHandler(
+        kTestRoutingID, input_handler_.AsWeakPtr(), nullptr, false);
+  }
+
+ protected:
+  scoped_refptr<base::TestSimpleTaskRunner> compositor_task_runner_;
+  TestInputHandlerManagerClient client_;
+  TestRendererScheduler renderer_scheduler_;
+  TestInputHandler input_handler_;
+  base::MessageLoopForUI message_loop_;
+
+  std::unique_ptr<InputHandlerManager> input_handler_manager_;
+};
+
+TEST_F(InputHandlerManagerTest, NotifiesRendererSchedulerAboutTouchStart) {
+  input_handler_.SetEventListenerProperties(
+      cc::EventListenerClass::kTouchStartOrMove,
+      cc::EventListenerProperties::kBlockingAndPassive);
+
+  ui::WebScopedInputEvent input_event(new blink::WebTouchEvent());
+  input_event->setType(blink::WebTouchEvent::Type::TouchStart);
+  auto callback = [](InputEventAckState, ui::WebScopedInputEvent,
+                     const ui::LatencyInfo&,
+                     std::unique_ptr<ui::DidOverscrollParams>) {};
+
+  input_handler_manager_->HandleInputEvent(
+      kTestRoutingID, std::move(input_event), ui::LatencyInfo(),
+      base::Bind(callback));
+  ASSERT_TRUE(renderer_scheduler_.input_event_handled());
+}
+
+}  // namespace content