Revert of Remove smiluate-touch-screen-with-mouse content flag.

content/browser/renderer_host/input/input_router_impl.cc

 // Copyright 2013 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/browser/renderer_host/input/input_router_impl.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 81 matching lines @@
     return TouchEventQueue::TOUCH_SCROLLING_MODE_ASYNC_TOUCHMOVE;
   if (modeString == switches::kTouchScrollingModeSyncTouchmove)
     return TouchEventQueue::TOUCH_SCROLLING_MODE_SYNC_TOUCHMOVE;
   if (modeString == switches::kTouchScrollingModeTouchcancel)
     return TouchEventQueue::TOUCH_SCROLLING_MODE_TOUCHCANCEL;
   if (modeString != "")
     LOG(ERROR) << "Invalid --touch-scrolling-mode option: " << modeString;
   return TouchEventQueue::TOUCH_SCROLLING_MODE_DEFAULT;
 }
 
+GestureEventWithLatencyInfo MakeGestureEvent(WebInputEvent::Type type,
+                                             double timestamp_seconds,
+                                             int x,
+                                             int y,
+                                             int modifiers,
+                                             const ui::LatencyInfo& latency) {
+  WebGestureEvent result;
+
+  result.type = type;
+  result.x = x;
+  result.y = y;
+  result.sourceDevice = WebGestureEvent::Touchscreen;
+  result.timeStampSeconds = timestamp_seconds;
+  result.modifiers = modifiers;
+
+  return GestureEventWithLatencyInfo(result, latency);
+}
+
 const char* GetEventAckName(InputEventAckState ack_result) {
   switch(ack_result) {
     case INPUT_EVENT_ACK_STATE_UNKNOWN: return "UNKNOWN";
     case INPUT_EVENT_ACK_STATE_CONSUMED: return "CONSUMED";
     case INPUT_EVENT_ACK_STATE_NOT_CONSUMED: return "NOT_CONSUMED";
     case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS: return "NO_CONSUMER_EXISTS";
     case INPUT_EVENT_ACK_STATE_IGNORED: return "IGNORED";
   }
   DLOG(WARNING) << "Unhandled InputEventAckState in GetEventAckName.";
   return "";
@@ skipping 47 matching lines @@
     case InputMsg_HandleInputEvent::ID:
       NOTREACHED() << "WebInputEvents should never be sent via SendInput.";
       return false;
     default:
       return Send(message.release());
   }
 }
 
 void InputRouterImpl::SendMouseEvent(
     const MouseEventWithLatencyInfo& mouse_event) {
+  // Order is important here; we need to convert all MouseEvents before they
+  // propagate further, e.g., to the tap suppression controller.
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSimulateTouchScreenWithMouse)) {
+    SimulateTouchGestureWithMouse(mouse_event);
+    return;
+  }
+
   if (mouse_event.event.type == WebInputEvent::MouseDown &&
       gesture_event_queue_.GetTouchpadTapSuppressionController()->
           ShouldDeferMouseDown(mouse_event))
       return;
   if (mouse_event.event.type == WebInputEvent::MouseUp &&
       gesture_event_queue_.GetTouchpadTapSuppressionController()->
           ShouldSuppressMouseUp())
       return;
 
   SendMouseEventImmediately(mouse_event);
@@ skipping 516 matching lines @@
     return;
 
   OverscrollController* controller = client_->GetOverscrollController();
   if (!controller)
     return;
 
   controller->ReceivedEventACK(
       event, (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result));
 }
 
+void InputRouterImpl::SimulateTouchGestureWithMouse(
+    const MouseEventWithLatencyInfo& event) {
+  const WebMouseEvent& mouse_event = event.event;
+  int x = mouse_event.x, y = mouse_event.y;
+  float dx = mouse_event.movementX, dy = mouse_event.movementY;
+  static int startX = 0, startY = 0;
+
+  switch (mouse_event.button) {
+    case WebMouseEvent::ButtonLeft:
+      if (mouse_event.type == WebInputEvent::MouseDown) {
+        startX = x;
+        startY = y;
+        SendGestureEvent(MakeGestureEvent(
+            WebInputEvent::GestureScrollBegin, mouse_event.timeStampSeconds,
+            x, y, 0, event.latency));
+      }
+      if (dx != 0 || dy != 0) {
+        GestureEventWithLatencyInfo gesture_event = MakeGestureEvent(
+            WebInputEvent::GestureScrollUpdate, mouse_event.timeStampSeconds,
+            x, y, 0, event.latency);
+        gesture_event.event.data.scrollUpdate.deltaX = dx;
+        gesture_event.event.data.scrollUpdate.deltaY = dy;
+        SendGestureEvent(gesture_event);
+      }
+      if (mouse_event.type == WebInputEvent::MouseUp) {
+        SendGestureEvent(MakeGestureEvent(
+            WebInputEvent::GestureScrollEnd, mouse_event.timeStampSeconds,
+            x, y, 0, event.latency));
+      }
+      break;
+    case WebMouseEvent::ButtonMiddle:
+      if (mouse_event.type == WebInputEvent::MouseDown) {
+        startX = x;
+        startY = y;
+        SendGestureEvent(MakeGestureEvent(
+            WebInputEvent::GestureShowPress, mouse_event.timeStampSeconds,
+            x, y, 0, event.latency));
+        SendGestureEvent(MakeGestureEvent(
+            WebInputEvent::GestureTapDown, mouse_event.timeStampSeconds,
+            x, y, 0, event.latency));
+      }
+      if (mouse_event.type == WebInputEvent::MouseUp) {
+        SendGestureEvent(MakeGestureEvent(
+            WebInputEvent::GestureTap, mouse_event.timeStampSeconds,
+            x, y, 0, event.latency));
+      }
+      break;
+    case WebMouseEvent::ButtonRight:
+      if (mouse_event.type == WebInputEvent::MouseDown) {
+        startX = x;
+        startY = y;
+        SendGestureEvent(MakeGestureEvent(
+            WebInputEvent::GestureScrollBegin, mouse_event.timeStampSeconds,
+            x, y, 0, event.latency));
+        SendGestureEvent(MakeGestureEvent(
+            WebInputEvent::GesturePinchBegin, mouse_event.timeStampSeconds,
+            x, y, 0, event.latency));
+      }
+      if (dx != 0 || dy != 0) {
+        dx = pow(dy < 0 ? 0.998f : 1.002f, fabs(dy));
+        GestureEventWithLatencyInfo gesture_event = MakeGestureEvent(
+            WebInputEvent::GesturePinchUpdate, mouse_event.timeStampSeconds,
+            startX, startY, 0, event.latency);
+        gesture_event.event.data.pinchUpdate.scale = dx;
+        SendGestureEvent(gesture_event);
+      }
+      if (mouse_event.type == WebInputEvent::MouseUp) {
+        SendGestureEvent(MakeGestureEvent(
+            WebInputEvent::GesturePinchEnd, mouse_event.timeStampSeconds,
+            x, y, 0, event.latency));
+        SendGestureEvent(MakeGestureEvent(
+            WebInputEvent::GestureScrollEnd, mouse_event.timeStampSeconds,
+            x, y, 0, event.latency));
+      }
+      break;
+    case WebMouseEvent::ButtonNone:
+      break;
+  }
+}
+
 void InputRouterImpl::UpdateTouchAckTimeoutEnabled() {
   if (!touch_ack_timeout_supported_) {
     touch_event_queue_.SetAckTimeoutEnabled(false, base::TimeDelta());
     return;
   }
 
   // Mobile sites tend to be well-behaved with respect to touch handling, so
   // they have less need for the touch timeout fallback.
   const bool fixed_page_scale = (current_view_flags_ & FIXED_PAGE_SCALE) != 0;
   const bool mobile_viewport = (current_view_flags_ & MOBILE_VIEWPORT) != 0;
@@ skipping 31 matching lines @@
          select_range_pending_ ||
          move_caret_pending_;
 }
 
 bool InputRouterImpl::IsInOverscrollGesture() const {
   OverscrollController* controller = client_->GetOverscrollController();
   return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
 }
 
 }  // namespace content