pepper: Make sure gesture events are mapped to touch events correctly in fullscreen.

content/renderer/render_widget_fullscreen_pepper.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 "content/renderer/render_widget_fullscreen_pepper.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 47 matching lines @@
  private:
   // MouseLockDispatcher implementation.
   virtual void SendLockMouseRequest(bool unlocked_by_target) OVERRIDE;
   virtual void SendUnlockMouseRequest() OVERRIDE;
 
   RenderWidgetFullscreenPepper* widget_;
 
   DISALLOW_COPY_AND_ASSIGN(FullscreenMouseLockDispatcher);
 };
 
+WebMouseEvent WebMouseEventFromGestureEvent(const WebGestureEvent& gesture) {
+  WebMouseEvent mouse;
+
+  switch (gesture.type) {
+    case WebInputEvent::GestureScrollBegin:
+      mouse.type = WebInputEvent::MouseDown;
+      break;
+
+    case WebInputEvent::GestureScrollUpdate:
+      mouse.type = WebInputEvent::MouseMove;
+      break;
+
+    case WebInputEvent::GestureFlingStart:
+      if (gesture.sourceDevice != WebGestureEvent::Touchscreen)
+        break;

[piman, 2013/02/01 19:19:52]

I don't understand this.
A FlingStart should be a Mouse Up (fallthrough) but only on a touch screen? 

Definitely needs a comment because that is far from obvious. Also, I'd prefer
not to rely on conditional fallthrough, it's really hard to read, so prefer
something like:

if (gesture.sourceDevice == WebGestureEvent::Touchscreen) {
  // A Fling Start on a touch screen should be a mouse up because yaddi yadda...
  mouse.type = WebInputEvent::MouseUp;
  break;
} else {
  // Otherwise ignore the event.
  return mouse;
}

[sadrul, 2013/02/01 19:58:05]

Done.

+    case WebInputEvent::GestureScrollEnd:
+      mouse.type = WebInputEvent::MouseUp;
+      break;
+
+    default:
+      break;
+  }
+
+  if (mouse.type == WebInputEvent::Undefined)
+    return mouse;
+
+  mouse.timeStampSeconds = gesture.timeStampSeconds;
+  mouse.modifiers = gesture.modifiers | WebInputEvent::LeftButtonDown;
+  mouse.button = WebMouseEvent::ButtonLeft;
+  mouse.clickCount = (mouse.type == WebInputEvent::MouseDown ||
+                      mouse.type == WebInputEvent::MouseUp);
+
+  mouse.x = gesture.x;
+  mouse.y = gesture.y;
+  mouse.windowX = gesture.globalX;
+  mouse.windowY = gesture.globalY;
+  mouse.globalX = gesture.globalX;
+  mouse.globalY = gesture.globalY;
+
+  return mouse;
+}
+
 FullscreenMouseLockDispatcher::FullscreenMouseLockDispatcher(
     RenderWidgetFullscreenPepper* widget) : widget_(widget) {
 }
 
 FullscreenMouseLockDispatcher::~FullscreenMouseLockDispatcher() {
 }
 
 void FullscreenMouseLockDispatcher::SendLockMouseRequest(
     bool unlocked_by_target) {
   widget_->Send(new ViewHostMsg_LockMouse(widget_->routing_id(), false,
@@ skipping 67 matching lines @@
     NOTIMPLEMENTED();
   }
 
   virtual bool handleInputEvent(const WebInputEvent& event) {
     if (!widget_->plugin())
       return false;
 
     // This cursor info is ignored, we always set the cursor directly from
     // RenderWidgetFullscreenPepper::DidChangeCursor.
     WebCursorInfo cursor;
-    bool result = widget_->plugin()->HandleInputEvent(event, &cursor);
 
-    // For normal web pages, WebCore::EventHandler converts selected
-    // gesture events into mouse and wheel events. We don't have a WebView
-    // so do this translation here.
-    if (!result && WebInputEvent::isGestureEventType(event.type)) {
+    // Pepper plugins do not accept gesture events. So do not send the gesture
+    // events directly to the plugin. Instead, try to convert them to equivalent
+    // mouse events, and then send to the plugin.
+    if (WebInputEvent::isGestureEventType(event.type)) {
+      bool result = false;
+      const WebGestureEvent* gesture_event =
+          static_cast<const WebGestureEvent*>(&event);
       switch (event.type) {
-        case WebInputEvent::GestureScrollUpdate: {
-          const WebGestureEvent* gesture_event =
-              static_cast<const WebGestureEvent*>(&event);
-          WebMouseWheelEvent wheel_event;
-          wheel_event.timeStampSeconds = gesture_event->timeStampSeconds;
-          wheel_event.type = WebInputEvent::MouseWheel;
-          wheel_event.modifiers = gesture_event->modifiers;
+        case WebInputEvent::GestureTap: {
+          WebMouseEvent mouse;
 
-          wheel_event.x = gesture_event->x;
-          wheel_event.y = gesture_event->y;
-          wheel_event.windowX = gesture_event->globalX;
-          wheel_event.windowY = gesture_event->globalX;
-          wheel_event.globalX = gesture_event->globalX;
-          wheel_event.globalY = gesture_event->globalY;
-          wheel_event.movementX = 0;
-          wheel_event.movementY = 0;
+          mouse.timeStampSeconds = gesture_event->timeStampSeconds;
+          mouse.type = WebInputEvent::MouseMove;
+          mouse.modifiers = gesture_event->modifiers;
 
-          wheel_event.deltaX = gesture_event->data.scrollUpdate.deltaX;
-          wheel_event.deltaY = gesture_event->data.scrollUpdate.deltaY;
-          wheel_event.wheelTicksX =
-              gesture_event->data.scrollUpdate.deltaX / kTickDivisor;
-          wheel_event.wheelTicksY =
-              gesture_event->data.scrollUpdate.deltaY / kTickDivisor;
-          wheel_event.hasPreciseScrollingDeltas = 1;
-          wheel_event.phase = WebMouseWheelEvent::PhaseNone;
-          wheel_event.momentumPhase = WebMouseWheelEvent::PhaseNone;
+          mouse.x = gesture_event->x;
+          mouse.y = gesture_event->y;
+          mouse.windowX = gesture_event->globalX;
+          mouse.windowY = gesture_event->globalY;
+          mouse.globalX = gesture_event->globalX;
+          mouse.globalY = gesture_event->globalY;
+          mouse.movementX = 0;
+          mouse.movementY = 0;
+          result |= widget_->plugin()->HandleInputEvent(mouse, &cursor);
 
-          result |= widget_->plugin()->HandleInputEvent(wheel_event, &cursor);
+          mouse.type = WebInputEvent::MouseDown;
+          mouse.button = WebMouseEvent::ButtonLeft;
+          mouse.clickCount = gesture_event->data.tap.tapCount;
+          result |= widget_->plugin()->HandleInputEvent(mouse, &cursor);
+
+          mouse.type = WebInputEvent::MouseUp;
+          result |= widget_->plugin()->HandleInputEvent(mouse, &cursor);
           break;
         }
-        case WebInputEvent::GestureTap: {
-          const WebGestureEvent* gesture_event =
-              static_cast<const WebGestureEvent*>(&event);
-          WebMouseEvent mouseEvent;
 
-          mouseEvent.timeStampSeconds = gesture_event->timeStampSeconds;
-          mouseEvent.type = WebInputEvent::MouseMove;
-          mouseEvent.modifiers = gesture_event->modifiers;
-
-          mouseEvent.x = gesture_event->x;
-          mouseEvent.y = gesture_event->y;
-          mouseEvent.windowX = gesture_event->globalX;
-          mouseEvent.windowY = gesture_event->globalX;
-          mouseEvent.globalX = gesture_event->globalX;
-          mouseEvent.globalY = gesture_event->globalY;
-          mouseEvent.movementX = 0;
-          mouseEvent.movementY = 0;
-          result |= widget_->plugin()->HandleInputEvent(mouseEvent, &cursor);
-
-          mouseEvent.type = WebInputEvent::MouseDown;
-          mouseEvent.button = WebMouseEvent::ButtonLeft;
-          mouseEvent.clickCount = gesture_event->data.tap.tapCount;
-          result |= widget_->plugin()->HandleInputEvent(mouseEvent, &cursor);
-
-          mouseEvent.type = WebInputEvent::MouseUp;
-          result |= widget_->plugin()->HandleInputEvent(mouseEvent, &cursor);
+        default: {
+          // This works for pepper plugins. However, this may break scrolling in
+          // fullscreen PDF. So, we should continue to generate wheel events for

[piman, 2013/02/01 19:19:52]

fullscreen PDF doesn't use this codepath (only used for Flash), I don't think
this comment is necessary.

[sadrul, 2013/02/01 19:58:05]

Whoops. This comment was for myself to check the PDF scrolling behaviour. I
forgot to remove it before uploading for review. Removed.

+          // GestureScrollUpdate if the plugin accepts raw touch events. A
+          // better solution would be to make sure the browser sends touch
+          // events if the plugin accepts raw events, and convert those touch
+          // events to mouse events (and continue to generate wheel events out
+          // of GestureScrollUpdate events).
+          WebMouseEvent mouse = WebMouseEventFromGestureEvent(*gesture_event);
+          if (mouse.type != WebInputEvent::Undefined)
+            result |= widget_->plugin()->HandleInputEvent(mouse, &cursor);
           break;
         }
-        default:
-          break;
       }
+      return result;
     }
 
+    bool result = widget_->plugin()->HandleInputEvent(event, &cursor);
+
     // For normal web pages, WebViewImpl does input event translations and
     // generates context menu events. Since we don't have a WebView, we need to
     // do the necessary translation ourselves.
     if (WebInputEvent::isMouseEventType(event.type)) {
       const WebMouseEvent& mouse_event =
           reinterpret_cast<const WebMouseEvent&>(event);
       bool send_context_menu_event = false;
       // On Mac/Linux, we handle it on mouse down.
       // On Windows, we handle it on mouse up.
 #if defined(OS_WIN)
@@ skipping 442 matching lines @@
 RenderWidgetFullscreenPepper::GetParentContextForPlatformContext3D() {
   if (!context_) {
     CreateContext();
   }
   if (!context_)
     return NULL;
   return context_;
 }
 
 }  // namespace content