Revert 263644 "[DevTools] Touch emulation in content."

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),
-        simulated_event_time_delta_seconds_(0) {
-    last_simulated_event_time_seconds_ =
-        (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
+        handle_mouse_event_(false) {
   }
   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) {
-    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));
+  WebKeyboardEvent event = SyntheticWebKeyboardEventBuilder::Build(type);
+  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) {
-    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);
+    host_->ForwardMouseEvent(
+        SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseMove,
+                                             x,
+                                             y,
+                                             modifiers));
   }
 
   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