Adding Gesture Recognition to RenderWidgetHostViewWin (web client)

content/browser/renderer_host/render_widget_host_view_win.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/browser/renderer_host/render_widget_host_view_win.h"
 
 #include <algorithm>
 #include <peninputpanel_i.c>
 
 #include "base/bind.h"
@@ skipping 28 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/process_type.h"
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/win/WebInputEventFactory.h"
+#include "ui/base/gestures/gesture_recognizer.h"
 #include "ui/base/ime/composition_text.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/win/hwnd_util.h"
 #include "ui/base/win/mouse_wheel_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/gdi_util.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
+#include "ui/views/events/event.h"

[rjkroege, 2012/05/04 15:42:46]

afaik: content is not allowed to depend on views.

 #include "webkit/glue/webaccessibility.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/plugins/npapi/plugin_constants_win.h"
 #include "webkit/plugins/npapi/webplugin.h"
 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using content::BrowserThread;
 using content::RenderWidgetHost;
@@ skipping 256 matching lines @@
       is_loading_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       is_fullscreen_(false),
       ignore_mouse_movement_(true),
       composition_range_(ui::Range::InvalidRange()),
       touch_state_(this),
       pointer_down_context_(false),
       focus_on_editable_field_(false),
       received_focus_change_after_pointer_down_(false),
       touch_events_enabled_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(

[sky, 2012/05/04 16:23:40]

No scoped_ptr since you're creating all the time (I sent rationale in previous
review).

+          gesture_recognizer_(ui::GestureRecognizer::Create(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(sys_color_change_listener_(this)) {
   render_widget_host_->SetView(this);
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
@@ skipping 585 matching lines @@
   callback.Run(false);
 }
 
 void RenderWidgetHostViewWin::SetBackground(const SkBitmap& background) {
   content::RenderWidgetHostViewBase::SetBackground(background);
   render_widget_host_->SetBackground(background);
 }
 
 void RenderWidgetHostViewWin::ProcessTouchAck(
     WebKit::WebInputEvent::Type type, bool processed) {
+  scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
+  gestures.reset(gesture_recognizer_->AdvanceTouchQueue(this, processed));
+  ProcessGestures(gestures.get());
+
   if (type == WebKit::WebInputEvent::TouchStart)
     UpdateDesiredTouchMode(processed);
 }
 
 void RenderWidgetHostViewWin::SetToGestureMode() {
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
   UnregisterTouchWindow(m_hWnd);
   // Single finger panning is consistent with other windows applications.
   const DWORD gesture_allow = GC_PAN_WITH_SINGLE_FINGER_VERTICALLY |
@@ skipping 35 matching lines @@
   // state. If we want touch mode, then we attempt to register for touch
   // events, and otherwise to unregister.
   if (touch_mode) {
     touch_mode = SetToTouchMode();
   }
   if (!touch_mode) {
     SetToGestureMode();
   }
 }
 
+ui::GestureEvent* RenderWidgetHostViewWin::CreateGestureEvent(

[rjkroege, 2012/05/04 15:42:46]

my intuition is that this class is not the right place to put this code.

+    ui::EventType type,
+    const gfx::Point& location,
+    int flags,
+    const base::Time& time,
+    float param_first,
+    float param_second,
+    unsigned int touch_id_bitfield) {
+  return new views::GestureEvent(type, location.x(), location.y(), flags, time,
+      param_first, param_second, touch_id_bitfield);
+}
+
+ui::TouchEvent* RenderWidgetHostViewWin::CreateTouchEvent(
+    ui::EventType type,
+    const gfx::Point& location,
+    int touch_id,
+    const base::TimeDelta& time_stamp) {
+  return new views::TouchEvent(
+      type, location.x(), location.y(), 0, touch_id, 0, 0, 0, 0);
+}
+
+bool RenderWidgetHostViewWin::DispatchLongPressGestureEvent(
+    ui::GestureEvent* event) {
+  return ForwardGestureEventToRenderer( WebKit::WebInputEvent::GestureLongPress,
+      reinterpret_cast< const views::GestureEvent *>(event));
+}
+
+bool RenderWidgetHostViewWin::DispatchCancelTouchEvent(
+    ui::TouchEvent* event) {
+  if (!render_widget_host_)
+    return false;
+
+  WebKit::WebTouchEvent generatedEvent;
+  generatedEvent.changedTouchesLength = 1;
+  generatedEvent.changedTouches[0].id = event->GetTouchId();
+  generatedEvent.type = WebKit::WebInputEvent::TouchCancel;
+  render_widget_host_->ForwardTouchEvent(generatedEvent);
+  return true;
+}
+
 void RenderWidgetHostViewWin::SetHasHorizontalScrollbar(
     bool has_horizontal_scrollbar) {
 }
 
 void RenderWidgetHostViewWin::SetScrollOffsetPinning(
     bool is_pinned_to_left, bool is_pinned_to_right) {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewWin, private:
@@ skipping 884 matching lines @@
                                               LPARAM lparam, BOOL& handled) {
   // TODO(jschuh): Add support for an arbitrary number of touchpoints.
   size_t total = std::min(static_cast<int>(LOWORD(wparam)),
       static_cast<int>(WebKit::WebTouchEvent::touchesLengthCap));
   TOUCHINPUT points[WebKit::WebTouchEvent::touchesLengthCap];
 
   if (!total || !GetTouchInputInfo((HTOUCHINPUT)lparam, total,
                                    points, sizeof(TOUCHINPUT))) {
     return 0;
   }
-
   for (size_t start = 0; start < total;) {
     start += touch_state_.UpdateTouchPoints(points + start, total - start);
     if (touch_state_.is_changed())
       render_widget_host_->ForwardTouchEvent(touch_state_.touch_event());

[rjkroege, 2012/05/04 15:42:46]

are the touch-ids normalized here?

   }
 
+  // Send a copy of the touch events on to the gesture recognizer.
+  for (size_t index = 0; index < total; ++index) {
+    // Create a views::TouchEvent
+    bool hasAreaInfo =
+        (points[index].dwMask & TOUCHINPUTMASKF_CONTACTAREA) != 0;
+
+    DWORD flags = points[index].dwFlags;
+    ui::EventType eventType = ui::ET_TOUCH_STATIONARY;
+
+    if ((flags & TOUCHEVENTF_UP) != 0)
+      eventType = ui::ET_TOUCH_RELEASED;
+    else if ((flags & TOUCHEVENTF_MOVE) != 0) {
+      eventType = ui::ET_TOUCH_MOVED;
+      // Ignore this touch if there is a backlog.

[rjkroege, 2012/05/04 15:42:46]

why? you drop the moves on the floor?

wouldn't the right model be to coalesce the moves like mousemoves before sending
the touches to webkit but sending every event sent to webkit to the GR.

The GR ought to be very fast compared to a trip to WebKit and so should have no
trouble keeping up?

+      if (!gesture_recognizer_->IsQueueEmpty(this))
+        continue;
+    }
+    else if ((flags & TOUCHEVENTF_DOWN) != 0)
+      eventType = ui::ET_TOUCH_PRESSED;
+
+    views::TouchEvent touchEvent( eventType,
+        TOUCH_COORD_TO_PIXEL( points[index].x),
+        TOUCH_COORD_TO_PIXEL( points[index].y),
+        0, // flags are not used.
+        points[index].dwID,
+        hasAreaInfo ? points[index].cxContact : 0.0,
+        hasAreaInfo ? points[index].cyContact : 0.0,
+        0.0, // angle is unknown?
+        0.0); // force is 0?
+    GestureConsumer* consumer = this;
+    gesture_recognizer_->QueueTouchEventForGesture(
+      consumer, touchEvent);
+  }
+
   CloseTouchInputHandle((HTOUCHINPUT)lparam);
 
   return 0;
 }
 
+void RenderWidgetHostViewWin::ProcessGestures(
+    ui::GestureRecognizer::Gestures* gestures) {
+  if ((gestures == 0) || gestures->empty())
+    return;
+
+  for (ui::GestureRecognizer::Gestures::iterator g_it = gestures->begin();

[rjkroege, 2012/05/04 15:42:46]

we have code that knows how to make Web events out of aura events. Maybe it
should make Web events out of ui events instead? then this code wouldn't need to
be here too?

+      g_it != gestures->end();
+      ++g_it) {
+    views::GestureEvent *gesture =
+        reinterpret_cast<views::GestureEvent *>( *g_it);
+    switch (gesture->type()) {
+    case ui::ET_GESTURE_SCROLL_BEGIN:
+      ForwardGestureEventToRenderer(WebKit::WebInputEvent::GestureScrollBegin,
+          gesture);
+      break;
+    case ui::ET_GESTURE_SCROLL_END:
+      ForwardGestureEventToRenderer(WebKit::WebInputEvent::GestureScrollEnd,
+          gesture);
+      break;
+    case ui::ET_GESTURE_SCROLL_UPDATE:
+      ForwardGestureEventToRenderer(WebKit::WebInputEvent::GestureScrollUpdate,
+          gesture);
+      break;
+    case ui::ET_GESTURE_PINCH_BEGIN:
+      ForwardGestureEventToRenderer(WebKit::WebInputEvent::GesturePinchBegin,
+          gesture);
+      break;
+    case ui::ET_GESTURE_PINCH_END:
+      ForwardGestureEventToRenderer(WebKit::WebInputEvent::GesturePinchEnd,
+          gesture);
+      break;
+    case ui::ET_GESTURE_PINCH_UPDATE:
+      ForwardGestureEventToRenderer(WebKit::WebInputEvent::GesturePinchUpdate,
+          gesture);
+      break;
+    case ui::ET_GESTURE_LONG_PRESS:
+      ForwardGestureEventToRenderer(WebKit::WebInputEvent::GestureLongPress,
+          gesture);
+      break;
+    case ui::ET_GESTURE_THREE_FINGER_SWIPE:
+      // TODO: Add this code when three finger swipes are added.
+      //ForwardGestureEventToRenderer(
+      //    WebKit::WebInputEvent::GestureThreeFingerSwipe, gesture);
+      break;
+    case ui::ET_GESTURE_TAP:
+      if (!ForwardGestureEventToRenderer(WebKit::WebInputEvent::GestureTap,
+          gesture))
+        ForwardMouseEventToRenderer(WM_LBUTTONUP, 0,
+            MAKELONG(gesture->x(),gesture->y()));
+      break;
+    case ui::ET_GESTURE_TAP_DOWN:

[rjkroege, 2012/05/04 15:42:46]

Something looks wrong here. Taps from the GR are handled in WebKit. I would
expect this to do the wrong thing.

+      if (!ForwardGestureEventToRenderer(WebKit::WebInputEvent::GestureTapDown,
+            gesture))
+        ForwardMouseEventToRenderer(WM_LBUTTONDOWN, 0,
+            MAKELONG(gesture->x(),gesture->y()));
+      break;
+    case ui::ET_GESTURE_DOUBLE_TAP:
+      if (!ForwardGestureEventToRenderer(
+            WebKit::WebInputEvent::GestureDoubleTap, gesture))
+        ForwardMouseEventToRenderer(WM_LBUTTONDBLCLK, 0,

[rjkroege, 2012/05/04 15:42:46]

Same comment

+            MAKELONG(gesture->x(),gesture->y()));
+      break;
+    }
+  }
+}
+
 LRESULT RenderWidgetHostViewWin::OnMouseActivate(UINT message,
                                                  WPARAM wparam,
                                                  LPARAM lparam,
                                                  BOOL& handled) {
   if (!render_widget_host_)
     return MA_NOACTIVATE;
 
   if (!IsActivatable())
     return MA_NOACTIVATE;
 
@@ skipping 523 matching lines @@
   GetClientRect(&ti.rect);
   SendMessage(tooltip_hwnd_, message, NULL, reinterpret_cast<LPARAM>(&ti));
 }
 
 void RenderWidgetHostViewWin::ResetTooltip() {
   if (::IsWindow(tooltip_hwnd_))
     ::DestroyWindow(tooltip_hwnd_);
   tooltip_hwnd_ = NULL;
 }
 
+bool RenderWidgetHostViewWin::ForwardGestureEventToRenderer(
+    WebKit::WebInputEvent::Type eventType,
+    const views::GestureEvent* gesture) {
+  if (!render_widget_host_)
+    return false;
+
+  WebKit::WebGestureEvent generatedEvent;
+  generatedEvent.x = gesture->x();
+  generatedEvent.y = gesture->y();
+  generatedEvent.deltaX = gesture->delta_x();
+  generatedEvent.deltaY = gesture->delta_y();
+  generatedEvent.timeStampSeconds =
+      gesture->time_stamp().UnixEpoch().ToDoubleT();
+  generatedEvent.type = eventType;
+  render_widget_host_->ForwardGestureEvent(generatedEvent);
+  return true;
+}
+
 void RenderWidgetHostViewWin::ForwardMouseEventToRenderer(UINT message,
                                                           WPARAM wparam,
                                                           LPARAM lparam) {
   if (!render_widget_host_)
     return;
 
   WebMouseEvent event(
       WebInputEventFactory::mouseEvent(m_hWnd, message, wparam, lparam));
 
   if (mouse_locked_) {
@@ skipping 232 matching lines @@
 void RenderWidgetHostViewWin::ResetPointerDownContext() {
   // If the default focus on the page is on an edit field and we did not
   // receive a focus change in the context of a pointer down message, it means
   // that the pointer down message occurred on the edit field and we should
   // display the on screen keyboard
   if (!received_focus_change_after_pointer_down_ && virtual_keyboard_)
     DisplayOnScreenKeyboardIfNeeded();
   received_focus_change_after_pointer_down_ = false;
   pointer_down_context_ = false;
 }