Revert 263647 "Revert 263644 "[DevTools] Touch emulation in cont..."

trunk/src/content/browser/renderer_host/render_widget_host_unittest.cc

 // Copyright (c) 2012 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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/timer/timer.h"
@@ skipping 30 matching lines @@
 
 #if defined(USE_AURA)
 #include "content/browser/renderer_host/ui_events_helper.h"
 #include "ui/events/event.h"
 #endif
 
 using base::TimeDelta;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
+using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 
 namespace content {
 
 // TestOverscrollDelegate ------------------------------------------------------
 
 class TestOverscrollDelegate : public OverscrollControllerDelegate {
  public:
@@ skipping 131 matching lines @@
 
 class MockRenderWidgetHost : public RenderWidgetHostImpl {
  public:
   MockRenderWidgetHost(
       RenderWidgetHostDelegate* delegate,
       RenderProcessHost* process,
       int routing_id)
       : RenderWidgetHostImpl(delegate, process, routing_id, false),
         unresponsive_timer_fired_(false) {
     input_router_impl_ = static_cast<InputRouterImpl*>(input_router_.get());
+    acked_touch_event_type_ = blink::WebInputEvent::Undefined;
   }
 
   // Allow poking at a few private members.
   using RenderWidgetHostImpl::OnUpdateRect;
   using RenderWidgetHostImpl::RendererExited;
   using RenderWidgetHostImpl::last_requested_size_;
   using RenderWidgetHostImpl::is_hidden_;
   using RenderWidgetHostImpl::resize_ack_pending_;
   using RenderWidgetHostImpl::input_router_;
 
@@ skipping 42 matching lines @@
 
   void set_debounce_interval_time_ms(int delay_ms) {
     gesture_event_queue().
         set_debounce_interval_time_ms_for_testing(delay_ms);
   }
 
   bool TouchEventQueueEmpty() const {
     return touch_event_queue().empty();
   }
 
+  virtual void OnTouchEventAck(
+      const TouchEventWithLatencyInfo& event,
+      InputEventAckState ack_result) OVERRIDE {
+    // Sniff touch acks.
+    acked_touch_event_type_ = event.event.type;
+    RenderWidgetHostImpl::OnTouchEventAck(event, ack_result);
+  }
+
+  WebInputEvent::Type acked_touch_event_type() const {
+    return acked_touch_event_type_;
+  }
+
   bool ScrollStateIsContentScrolling() const {
     return scroll_state() == OverscrollController::STATE_CONTENT_SCROLLING;
   }
 
   bool ScrollStateIsOverscrolling() const {
     return scroll_state() == OverscrollController::STATE_OVERSCROLLING;
   }
 
   bool ScrollStateIsUnknown() const {
     return scroll_state() == OverscrollController::STATE_UNKNOWN;
@@ skipping 40 matching lines @@
   const GestureEventQueue& gesture_event_queue() const {
     return input_router_impl_->gesture_event_queue_;
   }
 
   GestureEventQueue& gesture_event_queue() {
     return input_router_impl_->gesture_event_queue_;
   }
 
  private:
   bool unresponsive_timer_fired_;
+  WebInputEvent::Type acked_touch_event_type_;
 
   // |input_router_impl_| and |mock_input_router_| are owned by
   // RenderWidgetHostImpl.  The handles below are provided for convenience so
   // that we don't have to reinterpret_cast it all the time.
   InputRouterImpl* input_router_impl_;
   MockInputRouter* mock_input_router_;
 
   scoped_ptr<TestOverscrollDelegate> overscroll_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(MockRenderWidgetHost);
@@ skipping 241 matching lines @@
   bool handle_wheel_event_called_;
 };
 
 // RenderWidgetHostTest --------------------------------------------------------
 
 class RenderWidgetHostTest : public testing::Test {
  public:
   RenderWidgetHostTest()
       : process_(NULL),
         handle_key_press_event_(false),
-        handle_mouse_event_(false) {
+        handle_mouse_event_(false),
+        simulated_event_time_delta_seconds_(0) {
+    last_simulated_event_time_seconds_ =
+        (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
   }
   virtual ~RenderWidgetHostTest() {
   }
 
   bool KeyPressEventCallback(const NativeWebKeyboardEvent& /* event */) {
     return handle_key_press_event_;
   }
   bool MouseEventCallback(const blink::WebMouseEvent& /* event */) {
     return handle_mouse_event_;
   }
@@ skipping 42 matching lines @@
   }
 
   void SendInputEventACK(WebInputEvent::Type type,
                          InputEventAckState ack_result) {
     scoped_ptr<IPC::Message> response(
         new InputHostMsg_HandleInputEvent_ACK(0, type, ack_result,
                                               ui::LatencyInfo()));
     host_->OnMessageReceived(*response);
   }
 
+  double GetNextSimulatedEventTimeSeconds() {
+    last_simulated_event_time_seconds_ += simulated_event_time_delta_seconds_;
+    return last_simulated_event_time_seconds_;
+  }
+
   void SimulateKeyboardEvent(WebInputEvent::Type type) {
-  WebKeyboardEvent event = SyntheticWebKeyboardEventBuilder::Build(type);
-  NativeWebKeyboardEvent native_event;
-  memcpy(&native_event, &event, sizeof(event));
+    SimulateKeyboardEvent(type, 0);
+  }
+
+  void SimulateKeyboardEvent(WebInputEvent::Type type, int modifiers) {
+    WebKeyboardEvent event = SyntheticWebKeyboardEventBuilder::Build(type);
+    event.modifiers = modifiers;
+    NativeWebKeyboardEvent native_event;
+    memcpy(&native_event, &event, sizeof(event));
     host_->ForwardKeyboardEvent(native_event);
   }
 
   void SimulateMouseEvent(WebInputEvent::Type type) {
     host_->ForwardMouseEvent(SyntheticWebMouseEventBuilder::Build(type));
   }
 
   void SimulateMouseEventWithLatencyInfo(WebInputEvent::Type type,
                                          const ui::LatencyInfo& ui_latency) {
     host_->ForwardMouseEventWithLatencyInfo(
@@ skipping 10 matching lines @@
                                          float dY,
                                          int modifiers,
                                          bool precise,
                                          const ui::LatencyInfo& ui_latency) {
     host_->ForwardWheelEventWithLatencyInfo(
         SyntheticWebMouseWheelEventBuilder::Build(dX, dY, modifiers, precise),
         ui_latency);
   }
 
   void SimulateMouseMove(int x, int y, int modifiers) {
-    host_->ForwardMouseEvent(
-        SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseMove,
-                                             x,
-                                             y,
-                                             modifiers));
+    SimulateMouseEvent(WebInputEvent::MouseMove, x, y, modifiers, false);
+  }
+
+  void SimulateMouseEvent(
+      WebInputEvent::Type type, int x, int y, int modifiers, bool pressed) {
+    WebMouseEvent event =
+        SyntheticWebMouseEventBuilder::Build(type, x, y, modifiers);
+    if (pressed)
+      event.button = WebMouseEvent::ButtonLeft;
+    event.timeStampSeconds = GetNextSimulatedEventTimeSeconds();
+    host_->ForwardMouseEvent(event);
   }
 
   void SimulateWheelEventWithPhase(WebMouseWheelEvent::Phase phase) {
     host_->ForwardWheelEvent(SyntheticWebMouseWheelEventBuilder::Build(phase));
   }
 
   // Inject provided synthetic WebGestureEvent instance.
   void SimulateGestureEventCore(const WebGestureEvent& gesture_event) {
     host_->ForwardGestureEvent(gesture_event);
   }
@@ skipping 84 matching lines @@
   base::MessageLoopForUI message_loop_;
 
   scoped_ptr<TestBrowserContext> browser_context_;
   RenderWidgetHostProcess* process_;  // Deleted automatically by the widget.
   scoped_ptr<MockRenderWidgetHostDelegate> delegate_;
   scoped_ptr<MockRenderWidgetHost> host_;
   scoped_ptr<TestView> view_;
   scoped_ptr<gfx::Screen> screen_;
   bool handle_key_press_event_;
   bool handle_mouse_event_;
+  double last_simulated_event_time_seconds_;
+  double simulated_event_time_delta_seconds_;
 
  private:
   SyntheticWebTouchEvent touch_event_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostTest);
 };
 
 #if GTEST_HAS_PARAM_TEST
 // RenderWidgetHostWithSourceTest ----------------------------------------------
 
@@ skipping 1573 matching lines @@
   EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->current_mode());
   EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->completed_mode());
 
   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
                        WebGestureEvent::Touchscreen);
   EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_delegate()->current_mode());
   EXPECT_EQ(OVERSCROLL_EAST, host_->overscroll_delegate()->completed_mode());
   process_->sink().ClearMessages();
 }
 
+std::string GetInputMessageTypes(RenderWidgetHostProcess* process) {
+  const WebInputEvent* event = NULL;
+  ui::LatencyInfo latency_info;
+  bool is_keyboard_shortcut;
+  std::string result;
+  for (size_t i = 0; i < process->sink().message_count(); ++i) {
+    const IPC::Message *message = process->sink().GetMessageAt(i);
+    EXPECT_EQ(InputMsg_HandleInputEvent::ID, message->type());
+    EXPECT_TRUE(InputMsg_HandleInputEvent::Read(
+        message, &event, &latency_info, &is_keyboard_shortcut));
+    if (i != 0)
+      result += " ";
+    result += WebInputEventTraits::GetName(event->type);
+  }
+  process->sink().ClearMessages();
+  return result;
+}
+
+TEST_F(RenderWidgetHostTest, TouchEmulator) {
+  simulated_event_time_delta_seconds_ = 0.1;
+  host_->DisableGestureDebounce();
+  // Immediately ack all touches instead of sending them to the renderer.
+  host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false));
+  host_->OnMessageReceived(
+      ViewHostMsg_SetTouchEventEmulationEnabled(0, true, true));
+  process_->sink().ClearMessages();
+  view_->set_bounds(gfx::Rect(0, 0, 400, 200));
+  view_->Show();
+
+  SimulateMouseEvent(WebInputEvent::MouseMove, 10, 10, 0, false);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Mouse press becomes touch start which in turn becomes tap.
+  SimulateMouseEvent(WebInputEvent::MouseDown, 10, 10, 0, true);
+  EXPECT_EQ(WebInputEvent::TouchStart, host_->acked_touch_event_type());
+  EXPECT_EQ("GestureTapDown", GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GestureTapDown,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  // Mouse drag generates touch move, cancels tap and starts scroll.
+  SimulateMouseEvent(WebInputEvent::MouseMove, 10, 30, 0, true);
+  EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
+  EXPECT_EQ(
+      "GestureTapCancel GestureScrollBegin GestureScrollUpdate",
+      GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GestureTapCancel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendInputEventACK(WebInputEvent::GestureScrollBegin,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Mouse drag with shift becomes pinch.
+  SimulateMouseEvent(
+      WebInputEvent::MouseMove, 10, 40, WebInputEvent::ShiftKey, true);
+  EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
+  EXPECT_EQ("GesturePinchBegin",
+            GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GesturePinchBegin,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  SimulateMouseEvent(
+      WebInputEvent::MouseMove, 10, 50, WebInputEvent::ShiftKey, true);
+  EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
+  EXPECT_EQ("GesturePinchUpdate",
+            GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GesturePinchUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Mouse drag without shift becomes scroll again.
+  SimulateMouseEvent(WebInputEvent::MouseMove, 10, 60, 0, true);
+  EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
+  EXPECT_EQ("GesturePinchEnd GestureScrollUpdate",
+            GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  SimulateMouseEvent(WebInputEvent::MouseMove, 10, 70, 0, true);
+  EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
+  EXPECT_EQ("GestureScrollUpdate",
+            GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  SimulateMouseEvent(WebInputEvent::MouseUp, 10, 70, 0, true);
+  EXPECT_EQ(WebInputEvent::TouchEnd, host_->acked_touch_event_type());
+  EXPECT_EQ("GestureScrollEnd", GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GestureScrollEnd,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Mouse move does nothing.
+  SimulateMouseEvent(WebInputEvent::MouseMove, 10, 80, 0, false);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Another mouse down continues scroll.
+  SimulateMouseEvent(WebInputEvent::MouseDown, 10, 80, 0, true);
+  EXPECT_EQ(WebInputEvent::TouchStart, host_->acked_touch_event_type());
+  EXPECT_EQ("GestureTapDown", GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GestureTapDown,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  SimulateMouseEvent(WebInputEvent::MouseMove, 10, 100, 0, true);
+  EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
+  EXPECT_EQ(
+      "GestureTapCancel GestureScrollBegin GestureScrollUpdate",
+      GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GestureTapCancel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendInputEventACK(WebInputEvent::GestureScrollBegin,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Another pinch.
+  SimulateMouseEvent(
+      WebInputEvent::MouseMove, 10, 110, WebInputEvent::ShiftKey, true);
+  EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
+  EXPECT_EQ("GesturePinchBegin",
+            GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GesturePinchBegin,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  SimulateMouseEvent(
+      WebInputEvent::MouseMove, 10, 120, WebInputEvent::ShiftKey, true);
+  EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
+  EXPECT_EQ("GesturePinchUpdate",
+            GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GesturePinchUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Turn off emulation during a pinch.
+  host_->OnMessageReceived(
+      ViewHostMsg_SetTouchEventEmulationEnabled(0, false, false));
+  EXPECT_EQ(WebInputEvent::TouchCancel, host_->acked_touch_event_type());
+  EXPECT_EQ("GesturePinchEnd GestureScrollEnd",
+            GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GesturePinchEnd,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendInputEventACK(WebInputEvent::GestureScrollEnd,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Mouse event should pass untouched.
+  SimulateMouseEvent(
+      WebInputEvent::MouseMove, 10, 10, WebInputEvent::ShiftKey, true);
+  EXPECT_EQ("MouseMove", GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::MouseMove,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Turn on emulation.
+  host_->OnMessageReceived(
+      ViewHostMsg_SetTouchEventEmulationEnabled(0, true, true));
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Another touch.
+  SimulateMouseEvent(WebInputEvent::MouseDown, 10, 10, 0, true);
+  EXPECT_EQ(WebInputEvent::TouchStart, host_->acked_touch_event_type());
+  EXPECT_EQ("GestureTapDown", GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GestureTapDown,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+
+  // Scroll.
+  SimulateMouseEvent(WebInputEvent::MouseMove, 10, 30, 0, true);
+  EXPECT_EQ(WebInputEvent::TouchMove, host_->acked_touch_event_type());
+  EXPECT_EQ(
+      "GestureTapCancel GestureScrollBegin GestureScrollUpdate",
+      GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GestureTapCancel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  SendInputEventACK(WebInputEvent::GestureScrollBegin,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  SendInputEventACK(WebInputEvent::GestureScrollUpdate,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  // Turn off emulation during a scroll.
+  host_->OnMessageReceived(
+      ViewHostMsg_SetTouchEventEmulationEnabled(0, false, false));
+  EXPECT_EQ(WebInputEvent::TouchCancel, host_->acked_touch_event_type());
+
+  EXPECT_EQ("GestureScrollEnd", GetInputMessageTypes(process_));
+  SendInputEventACK(WebInputEvent::GestureScrollEnd,
+                    INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, process_->sink().message_count());
+}
+
 #define TEST_InputRouterRoutes_NOARGS(INPUTMSG) \
   TEST_F(RenderWidgetHostTest, InputRouterRoutes##INPUTMSG) { \
     host_->SetupForInputRouterTest(); \
     host_->INPUTMSG(); \
     EXPECT_TRUE(host_->mock_input_router()->send_event_called_); \
   }
 
 TEST_InputRouterRoutes_NOARGS(Focus);
 TEST_InputRouterRoutes_NOARGS(Blur);
 TEST_InputRouterRoutes_NOARGS(LostCapture);
@@ skipping 220 matching lines @@
 
   // Tests RWHI::ForwardTouchEventWithLatencyInfo().
   PressTouchPoint(0, 1);
   SendTouchEvent();
   CheckLatencyInfoComponentInMessage(
       process_, GetLatencyComponentId(), WebInputEvent::TouchStart);
   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
 }
 
 }  // namespace content