Don't restart the hang renderer timeout on messages ack'd from the compositor thread.

content/renderer/mus/compositor_mus_connection_unittest.cc

 // Copyright 2016 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/mus/compositor_mus_connection.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 13 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/scheduler/test/fake_renderer_scheduler.h"
 #include "ui/events/blink/did_overscroll_params.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/mojo/event.mojom.h"
 #include "ui/events/mojo/event_constants.mojom.h"
 #include "ui/events/mojo/keyboard_codes.mojom.h"
 
 using ui::mojom::EventResult;
 
+namespace content {
+
 namespace {
 
 // Wrapper for the callback provided to
 // CompositorMusConnection:OnWindowInputEvent. This tracks whether the it was
 // called, along with the result.
 class TestCallback : public base::RefCounted<TestCallback> {
  public:
   TestCallback() : called_(false), result_(EventResult::UNHANDLED) {}
 
   bool called() { return called_; }
@@ skipping 10 matching lines @@
   ~TestCallback() {}
 
   bool called_;
   EventResult result_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCallback);
 };
 
 // Allows for overriding the behaviour of HandleInputEvent, to simulate input
 // handlers which consume events before they are sent to the renderer.
-class TestInputHandlerManager : public content::InputHandlerManager {
+class TestInputHandlerManager : public InputHandlerManager {
  public:
   TestInputHandlerManager(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-      content::InputHandlerManagerClient* client,
+      InputHandlerManagerClient* client,
       blink::scheduler::RendererScheduler* renderer_scheduler)
       : InputHandlerManager(task_runner, client, nullptr, renderer_scheduler),
         override_result_(false),
-        result_(content::InputEventAckState::INPUT_EVENT_ACK_STATE_UNKNOWN) {}
+        result_(InputEventAckState::INPUT_EVENT_ACK_STATE_UNKNOWN) {}
   ~TestInputHandlerManager() override {}
 
   // Stops overriding the behaviour of HandleInputEvent
   void ClearHandleInputEventOverride();
 
   // Overrides the behaviour of HandleInputEvent, returing |result|.
-  void SetHandleInputEventResult(content::InputEventAckState result);
+  void SetHandleInputEventResult(InputEventAckState result);
 
-  // content::InputHandlerManager:
+  // InputHandlerManager:
   void HandleInputEvent(int routing_id,
                         ui::ScopedWebInputEvent input_event,
                         const ui::LatencyInfo& latency_info,
                         const InputEventAckStateCallback& callback) override;
 
  private:
-  // If true content::InputHandlerManager::HandleInputEvent is not called.
+  // If true InputHandlerManager::HandleInputEvent is not called.
   bool override_result_;
 
   // The result to return in HandleInputEvent if |override_result_|.
-  content::InputEventAckState result_;
+  InputEventAckState result_;
 
   DISALLOW_COPY_AND_ASSIGN(TestInputHandlerManager);
 };
 
 void TestInputHandlerManager::ClearHandleInputEventOverride() {
   override_result_ = false;
 }
 
 void TestInputHandlerManager::SetHandleInputEventResult(
-    content::InputEventAckState result) {
+    InputEventAckState result) {
   override_result_ = true;
   result_ = result;
 }
 
 void TestInputHandlerManager::HandleInputEvent(
     int routing_id,
     ui::ScopedWebInputEvent input_event,
     const ui::LatencyInfo& latency_info,
     const InputEventAckStateCallback& callback) {
   if (override_result_) {
     callback.Run(result_, std::move(input_event), latency_info, nullptr);
     return;
   }
-  content::InputHandlerManager::HandleInputEvent(
-      routing_id, std::move(input_event), latency_info, callback);
+  InputHandlerManager::HandleInputEvent(routing_id, std::move(input_event),
+                                        latency_info, callback);
 }
 
 // Empty implementation of InputHandlerManagerClient.
-class TestInputHandlerManagerClient
-    : public content::InputHandlerManagerClient {
+class TestInputHandlerManagerClient : public InputHandlerManagerClient {
  public:
   TestInputHandlerManagerClient() {}
   ~TestInputHandlerManagerClient() override{};
 
-  // content::InputHandlerManagerClient:
+  // InputHandlerManagerClient:
   void SetInputHandlerManager(
-      content::InputHandlerManager* input_handler_manager) override {}
+      InputHandlerManager* input_handler_manager) override {}
   void RegisterRoutingID(int routing_id) override {}
   void UnregisterRoutingID(int routing_id) override {}
   void DidOverscroll(int routing_id,
                      const ui::DidOverscrollParams& params) override {}
   void DidStartFlinging(int routing_id) override {}
   void DidStopFlinging(int routing_id) override {}
   void DispatchNonBlockingEventToMainThread(
       int routing_id,
       ui::ScopedWebInputEvent event,
       const ui::LatencyInfo& latency_info) override {}
 
-  void NotifyInputEventHandled(
-      int routing_id,
-      blink::WebInputEvent::Type type,
-      content::InputEventAckState ack_result) override {}
+  void NotifyInputEventHandled(int routing_id,
+                               blink::WebInputEvent::Type type,
+                               InputEventAckState ack_result) override {}
   void ProcessRafAlignedInput(int routing_id) override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestInputHandlerManagerClient);
 };
 
 // Implementation of RenderWidget for testing, performs no initialization.
-class TestRenderWidget : public content::RenderWidget {
+class TestRenderWidget : public RenderWidget {
  public:
-  explicit TestRenderWidget(content::CompositorDependencies* compositor_deps)
-      : content::RenderWidget(compositor_deps,
-                              blink::WebPopupTypeNone,
-                              content::ScreenInfo(),
-                              true,
-                              false,
-                              false) {}
+  explicit TestRenderWidget(CompositorDependencies* compositor_deps)
+      : RenderWidget(compositor_deps,
+                     blink::WebPopupTypeNone,
+                     ScreenInfo(),
+                     true,
+                     false,
+                     false) {}
 
  protected:
   ~TestRenderWidget() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestRenderWidget);
 };
 
 // Test override of RenderWidgetInputHandler to allow the control of
 // HandleInputEvent. This will perform no actions on input until a
 // RenderWidgetInputHandlerDelegate is set. Once set this will always ack
 // received events.
-class TestRenderWidgetInputHandler : public content::RenderWidgetInputHandler {
+class TestRenderWidgetInputHandler : public RenderWidgetInputHandler {
  public:
-  TestRenderWidgetInputHandler(content::RenderWidget* render_widget);
+  TestRenderWidgetInputHandler(RenderWidget* render_widget);
   ~TestRenderWidgetInputHandler() override {}
 
-  void set_delegate(content::RenderWidgetInputHandlerDelegate* delegate) {
+  void set_delegate(RenderWidgetInputHandlerDelegate* delegate) {
     delegate_ = delegate;
   }
-  void set_state(content::InputEventAckState state) { state_ = state; }
+  void set_state(InputEventAckState state) { state_ = state; }
 
-  // content::RenderWidgetInputHandler:
+  // RenderWidgetInputHandler:
   void HandleInputEvent(const blink::WebInputEvent& input_event,
                         const ui::LatencyInfo& latency_info,
-                        content::InputEventDispatchType dispatch_type) override;
+                        InputEventDispatchType dispatch_type) override;
 
  private:
   // The input delegate which receives event acks.
-  content::RenderWidgetInputHandlerDelegate* delegate_;
+  RenderWidgetInputHandlerDelegate* delegate_;
 
   // The result of input handling to send to |delegate_| during the ack.
-  content::InputEventAckState state_;
+  InputEventAckState state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRenderWidgetInputHandler);
 };
 
 TestRenderWidgetInputHandler::TestRenderWidgetInputHandler(
-    content::RenderWidget* render_widget)
-    : content::RenderWidgetInputHandler(render_widget, render_widget),
+    RenderWidget* render_widget)
+    : RenderWidgetInputHandler(render_widget, render_widget),
       delegate_(nullptr),
-      state_(content::InputEventAckState::INPUT_EVENT_ACK_STATE_UNKNOWN) {}
+      state_(InputEventAckState::INPUT_EVENT_ACK_STATE_UNKNOWN) {}
 
 void TestRenderWidgetInputHandler::HandleInputEvent(
     const blink::WebInputEvent& input_event,
     const ui::LatencyInfo& latency_info,
-    content::InputEventDispatchType dispatch_type) {
+    InputEventDispatchType dispatch_type) {
   if (delegate_) {
-    std::unique_ptr<content::InputEventAck> ack(
-        new content::InputEventAck(input_event.type, state_));
+    std::unique_ptr<InputEventAck> ack(new InputEventAck(
+        InputEventAckSource::COMPOSITOR_THREAD, input_event.type, state_));
     delegate_->OnInputEventAck(std::move(ack));
   }
 }
 
 }  // namespace
 
-namespace content {
-
 // Test suite for CompositorMusConnection, this does not setup a full renderer
 // environment. This does not establish a connection to a mus server, nor does
 // it initialize one.
 class CompositorMusConnectionTest : public testing::Test {
  public:
   CompositorMusConnectionTest() {}
   ~CompositorMusConnectionTest() override {}
 
   // Returns a valid key event, so that it can be converted to a web event by
   // CompositorMusConnection.
@@ skipping 115 matching lines @@
   TestRenderWidgetInputHandler* input_handler = render_widget_input_handler();
   input_handler->set_delegate(connection());
   input_handler->set_state(
       InputEventAckState::INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   ui::TestWindow test_window;
   std::unique_ptr<ui::Event> event(GenerateKeyEvent());
   scoped_refptr<TestCallback> test_callback(new TestCallback);
   std::unique_ptr<base::Callback<void(EventResult)>> ack_callback(
       new base::Callback<void(EventResult)>(
-          base::Bind(&::TestCallback::ResultCallback, test_callback)));
+          base::Bind(&TestCallback::ResultCallback, test_callback)));
 
   OnWindowInputEvent(&test_window, *event.get(), &ack_callback);
   // OnWindowInputEvent is expected to clear the callback if it plans on
   // handling the ack.
   EXPECT_FALSE(ack_callback.get());
 
   VerifyAndRunQueues(true, true);
 
   // The ack callback should have been called
   EXPECT_TRUE(test_callback->called());
   EXPECT_EQ(EventResult::UNHANDLED, test_callback->result());
 }
 
 // Tests that for events which the renderer will ack, and consume, that
 // CompositorMusConnection consumes the ack during OnWindowInputEvent, and calls
 // it with the correct state once processed.
 TEST_F(CompositorMusConnectionTest, Consumed) {
   TestRenderWidgetInputHandler* input_handler = render_widget_input_handler();
   input_handler->set_delegate(connection());
   input_handler->set_state(InputEventAckState::INPUT_EVENT_ACK_STATE_CONSUMED);
 
   ui::TestWindow test_window;
   std::unique_ptr<ui::Event> event(GenerateKeyEvent());
   scoped_refptr<TestCallback> test_callback(new TestCallback);
   std::unique_ptr<base::Callback<void(EventResult)>> ack_callback(
       new base::Callback<void(EventResult)>(
-          base::Bind(&::TestCallback::ResultCallback, test_callback)));
+          base::Bind(&TestCallback::ResultCallback, test_callback)));
 
   OnWindowInputEvent(&test_window, *event.get(), &ack_callback);
   // OnWindowInputEvent is expected to clear the callback if it plans on
   // handling the ack.
   EXPECT_FALSE(ack_callback.get());
 
   VerifyAndRunQueues(true, true);
 
   // The ack callback should have been called
   EXPECT_TRUE(test_callback->called());
   EXPECT_EQ(EventResult::HANDLED, test_callback->result());
 }
 
 // Tests that when the RenderWidgetInputHandler does not ack before a new event
 // arrives, that only the most recent ack is fired.
 TEST_F(CompositorMusConnectionTest, LostAck) {
   ui::TestWindow test_window;
   std::unique_ptr<ui::Event> event1(GenerateKeyEvent());
   scoped_refptr<TestCallback> test_callback1(new TestCallback);
   std::unique_ptr<base::Callback<void(EventResult)>> ack_callback1(
       new base::Callback<void(EventResult)>(
-          base::Bind(&::TestCallback::ResultCallback, test_callback1)));
+          base::Bind(&TestCallback::ResultCallback, test_callback1)));
 
   OnWindowInputEvent(&test_window, *event1.get(), &ack_callback1);
   EXPECT_FALSE(ack_callback1.get());
   // When simulating the timeout the ack is never enqueued
   VerifyAndRunQueues(true, false);
 
   // Setting a delegate will lead to the next event being acked. Having a
   // cleared queue simulates the input handler timing out on an event.
   TestRenderWidgetInputHandler* input_handler = render_widget_input_handler();
   input_handler->set_delegate(connection());
   input_handler->set_state(InputEventAckState::INPUT_EVENT_ACK_STATE_CONSUMED);
 
   std::unique_ptr<ui::Event> event2(GenerateKeyEvent());
   scoped_refptr<TestCallback> test_callback2(new TestCallback);
   std::unique_ptr<base::Callback<void(EventResult)>> ack_callback2(
       new base::Callback<void(EventResult)>(
-          base::Bind(&::TestCallback::ResultCallback, test_callback2)));
+          base::Bind(&TestCallback::ResultCallback, test_callback2)));
   OnWindowInputEvent(&test_window, *event2.get(), &ack_callback2);
   EXPECT_FALSE(ack_callback2.get());
 
   VerifyAndRunQueues(true, true);
 
   // Only the most recent ack was called.
   EXPECT_FALSE(test_callback1->called());
   EXPECT_TRUE(test_callback2->called());
   EXPECT_EQ(EventResult::HANDLED, test_callback2->result());
 }
 
 // Tests that when an input handler consumes the event, that
 // CompositorMusConnection will consume the ack, but call as UNHANDLED.
 TEST_F(CompositorMusConnectionTest, InputHandlerConsumes) {
   input_handler_manager()->SetHandleInputEventResult(
       InputEventAckState::INPUT_EVENT_ACK_STATE_CONSUMED);
   ui::TestWindow test_window;
   std::unique_ptr<ui::Event> event(GenerateKeyEvent());
   scoped_refptr<TestCallback> test_callback(new TestCallback);
   std::unique_ptr<base::Callback<void(EventResult)>> ack_callback(
       new base::Callback<void(EventResult)>(
-          base::Bind(&::TestCallback::ResultCallback, test_callback)));
+          base::Bind(&TestCallback::ResultCallback, test_callback)));
 
   OnWindowInputEvent(&test_window, *event.get(), &ack_callback);
 
   EXPECT_FALSE(ack_callback.get());
   VerifyAndRunQueues(false, false);
   EXPECT_TRUE(test_callback->called());
   EXPECT_EQ(EventResult::UNHANDLED, test_callback->result());
 }
 
 // Tests that when the renderer will not ack an event, that
 // CompositorMusConnection will consume the ack, but call as UNHANDLED.
 TEST_F(CompositorMusConnectionTest, RendererWillNotSendAck) {
   ui::TestWindow test_window;
   ui::PointerEvent event(
       ui::ET_POINTER_DOWN, gfx::Point(), gfx::Point(), ui::EF_NONE, 0, 0,
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE),
       ui::EventTimeForNow());
 
   scoped_refptr<TestCallback> test_callback(new TestCallback);
   std::unique_ptr<base::Callback<void(EventResult)>> ack_callback(
       new base::Callback<void(EventResult)>(
-          base::Bind(&::TestCallback::ResultCallback, test_callback)));
+          base::Bind(&TestCallback::ResultCallback, test_callback)));
 
   OnWindowInputEvent(&test_window, event, &ack_callback);
   EXPECT_FALSE(ack_callback.get());
 
   VerifyAndRunQueues(true, false);
   EXPECT_TRUE(test_callback->called());
   EXPECT_EQ(EventResult::UNHANDLED, test_callback->result());
 }
 
 // Tests that when a touch event id provided, that CompositorMusConnection
 // consumes the ack.
 TEST_F(CompositorMusConnectionTest, TouchEventConsumed) {
   TestRenderWidgetInputHandler* input_handler = render_widget_input_handler();
   input_handler->set_delegate(connection());
   input_handler->set_state(InputEventAckState::INPUT_EVENT_ACK_STATE_CONSUMED);
 
   ui::TestWindow test_window;
   ui::PointerEvent event(
       ui::ET_POINTER_DOWN, gfx::Point(), gfx::Point(), ui::EF_NONE, 0, 0,
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
       ui::EventTimeForNow());
 
   scoped_refptr<TestCallback> test_callback(new TestCallback);
   std::unique_ptr<base::Callback<void(EventResult)>> ack_callback(
       new base::Callback<void(EventResult)>(
-          base::Bind(&::TestCallback::ResultCallback, test_callback)));
+          base::Bind(&TestCallback::ResultCallback, test_callback)));
 
   OnWindowInputEvent(&test_window, event, &ack_callback);
   // OnWindowInputEvent is expected to clear the callback if it plans on
   // handling the ack.
   EXPECT_FALSE(ack_callback.get());
 
   VerifyAndRunQueues(true, true);
 
   // The ack callback should have been called
   EXPECT_TRUE(test_callback->called());
   EXPECT_EQ(EventResult::HANDLED, test_callback->result());
 }
 
 }  // namespace content