gestures: Cleanup touch-event handling code in Windows.

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 <map>
 #include <peninputpanel_i.c>
 #include <stack>
@@ skipping 33 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/event.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"
@@ skipping 234 matching lines @@
 
 inline void SetTouchType(TOUCHINPUT* point, int type) {
   point->dwFlags = (point->dwFlags & kTouchMask) | type;
 }
 
 template <class IINTERFACE, class PAYLOAD>
 class WrappedObject : public IINTERFACE {
  public:
   WrappedObject() {
   }
-  WrappedObject(const PAYLOAD &copy)
-      : data_(copy) {
-  }
   const PAYLOAD& data() const {
     return data_;
   }
   PAYLOAD& data() {
     return data_;
   }
 
  private:
   PAYLOAD data_;
 
@@ skipping 131 matching lines @@
   // |touch_ids_bitfield_| is the set of touch_ids associate with this gesture.
   // This value is stored as a bitfield because the number of touch ids varies,
   // but we currently don't need more than 32 touches at a time.
   const unsigned int touch_ids_bitfield_;
 
   ui::EventType type_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalGestureEvent);
 };
 
-class LocalTouchEvent :
-    public WrappedObject<ui::TouchEvent, WebKit::WebTouchEvent> {
+class TouchEventFromWebTouchPoint : public ui::TouchEventImpl {
  public:
-  LocalTouchEvent() : index_(0) {}
-  LocalTouchEvent(
-      ui::EventType type,
-      const gfx::Point& location,
-      int touch_id,
-      base::TimeDelta time_stamp) :
-      index_(0) {
-    data().type = ConvertToWebInputEvent(type);
-    data().timeStampSeconds = time_stamp.InSecondsF();
+  TouchEventFromWebTouchPoint(const WebKit::WebTouchPoint& touch_point,
+                              base::TimeDelta& timestamp)
+      : ui::TouchEventImpl(ConvertToUIEvent(touch_point.state),
+                           touch_point.position,
+                           touch_point.id,
+                           timestamp) {
+    set_radius(touch_point.radiusX, touch_point.radiusY);
+    set_rotation_angle(touch_point.rotationAngle);
+    set_force(touch_point.force);
   }
 
-  LocalTouchEvent(const WebKit::WebTouchEvent& copy,
-      ui::EventType type,
-      base::TimeDelta time_stamp,
-      size_t index = 0) :
-      WrappedObject<ui::TouchEvent, WebKit::WebTouchEvent>(copy),
-      index_(index) {
-    data().type = ConvertToWebInputEvent(type);
-    DCHECK(copy.touchesLength > index) << "Undefined touch point.";
-    data().timeStampSeconds = time_stamp.InSecondsF();
-  }
-
-  // TODO: make these functions non-virtual post http://crbug.com/125937
-  virtual ui::EventType GetEventType() const OVERRIDE {
-    return ConvertToUIEvent(data().touches[index_].state);
-  }
-  virtual gfx::Point GetLocation() const OVERRIDE {
-    return data().touches[index_].position;
-  }
-  virtual int GetTouchId() const OVERRIDE {
-    return data().touches[index_].id;
-  }
-  virtual int GetEventFlags() const OVERRIDE {
-    return 0;
-  }
-  virtual base::TimeDelta GetTimestamp() const OVERRIDE {
-    return base::TimeDelta::FromMilliseconds( 1000 * data().timeStampSeconds);
-  }
-  void SetTimestamp(base::TimeDelta t) {
-    data().timeStampSeconds = t.InSecondsF();
-  }
-  virtual float RadiusX() const OVERRIDE {
-    return data().touches[index_].radiusX;
-  }
-  virtual float RadiusY() const OVERRIDE {
-    return data().touches[index_].radiusY;
-  }
-  virtual float RotationAngle() const OVERRIDE {
-    return data().touches[index_].rotationAngle;
-  }
-  virtual float Force() const OVERRIDE {
-    return data().touches[index_].force;
-  }
-
-  // Returns a copy of the touch event at the specified index.
-  const LocalTouchEvent& Index( size_t index) const {
-    const int touch_history_size = 40;
-    static LocalTouchEvent touch_history[touch_history_size];
-    static int touch_history_index;
-    int current = (touch_history_index++ % touch_history_size);
-    touch_history[current].data() = data();
-    touch_history[current].index_ = index;
-    return touch_history[current];
-  }
+  virtual ~TouchEventFromWebTouchPoint() {}
 
  private:
-  size_t index_;
-
-  DISALLOW_COPY_AND_ASSIGN(LocalTouchEvent);
+  DISALLOW_COPY_AND_ASSIGN(TouchEventFromWebTouchPoint);
 };
 
 }  // namespace
 
 const wchar_t kRenderWidgetHostHWNDClass[] = L"Chrome_RenderWidgetHostHWND";
 
 // Wrapper for maintaining touchstate associated with a WebTouchEvent.
 class WebTouchState {
  public:
   explicit WebTouchState(const RenderWidgetHostViewWin* window);
 
   // Updates the current touchpoint state with the supplied touches.
   // Touches will be consumed only if they are of the same type (e.g. down,
   // up, move). Returns the number of consumed touches.
   size_t UpdateTouchPoints(TOUCHINPUT* points, size_t count);
 
   // Marks all active touchpoints as released.
   bool ReleaseTouchPoints();
 
   // The contained WebTouchEvent.
-  const WebKit::WebTouchEvent& touch_event() { return touch_event_.data(); }
-  const LocalTouchEvent* ui_touch_event() { return &touch_event_; }
+  const WebKit::WebTouchEvent& touch_event() { return touch_event_; }
 
   // Returns if any touches are modified in the event.
-  bool is_changed() { return touch_event_.data().changedTouchesLength != 0; }
+  bool is_changed() { return touch_event_.changedTouchesLength != 0; }
 
   void QueueEvents(ui::GestureConsumer* consumer, ui::GestureRecognizer* gr) {
-    if (touch_event_.data().touchesLength > 0)
-      touch_count_.push(touch_event_.data().touchesLength);
-    for (size_t i = 0; i < touch_event_.data().touchesLength; ++i) {
-        gr->QueueTouchEventForGesture(consumer, touch_event_.Index(i));
+    if (touch_event_.touchesLength > 0)
+      touch_count_.push(touch_event_.touchesLength);
+    base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds(
+        touch_event_.timeStampSeconds * 1000);
+    for (size_t i = 0; i < touch_event_.touchesLength; ++i) {
+      gr->QueueTouchEventForGesture(consumer,
+          TouchEventFromWebTouchPoint(touch_event_.touches[i], timestamp));
     }
   }
 
   int GetNextTouchCount() {
     DCHECK(!touch_count_.empty());
     int result = touch_count_.top();
     touch_count_.pop();
     return result;
   }
 
@@ skipping 13 matching lines @@
 
   // Remove any mappings that are no longer in use.
   void RemoveExpiredMappings();
 
   // The gesture recognizer processes touch events one at a time, but WebKit
   // (ForwardTouchEvent) takes a set of touch events. |touchCount_| tracks how
   // many individual touch events were sent to ForwardTouchEvent, so we can
   // send the correct number of AdvanceTouchQueue's
   std::stack<int> touch_count_;
 
-  LocalTouchEvent touch_event_;
+  WebKit::WebTouchEvent touch_event_;
   const RenderWidgetHostViewWin* const window_;
 
   // Maps OS touch Id's into an internal (WebKit-friendly) touch-id.
   // WebKit expects small consecutive integers, starting at 0.
   MapType touch_map_;
 
   DISALLOW_COPY_AND_ASSIGN(WebTouchState);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 698 matching lines @@
     unsigned int touch_id_bitfield) {
   return new LocalGestureEvent(m_hWnd, details, location, flags, time,
       touch_id_bitfield);
 }
 
 ui::TouchEvent* RenderWidgetHostViewWin::CreateTouchEvent(
     ui::EventType type,
     const gfx::Point& location,
     int touch_id,
     base::TimeDelta time_stamp) {
-  return new LocalTouchEvent(type, location, touch_id, time_stamp);
+  return new ui::TouchEventImpl(type, location, touch_id, time_stamp);
 }
 
 bool RenderWidgetHostViewWin::DispatchLongPressGestureEvent(
     ui::GestureEvent* event) {
   return ForwardGestureEventToRenderer(event);
 }
 
 bool RenderWidgetHostViewWin::DispatchCancelTouchEvent(
     ui::TouchEvent* event) {
   if (!render_widget_host_ || !touch_events_enabled_)
     return false;
   DCHECK(event->GetEventType() == WebKit::WebInputEvent::TouchCancel);
-  LocalTouchEvent touchEvent(event->GetEventType(),
-    event->GetLocation(), event->GetTouchId(), event->GetTimestamp());
-  render_widget_host_->ForwardTouchEvent(touchEvent.data());
+  WebKit::WebTouchEvent cancel_event;
+  cancel_event.type = WebKit::WebInputEvent::TouchCancel;
+  cancel_event.timeStampSeconds = event->GetTimestamp().InSecondsF();
+  render_widget_host_->ForwardTouchEvent(cancel_event);
   return true;
 }
 
 void RenderWidgetHostViewWin::SetHasHorizontalScrollbar(
     bool has_horizontal_scrollbar) {
 }
 
 void RenderWidgetHostViewWin::SetScrollOffsetPinning(
     bool is_pinned_to_left, bool is_pinned_to_right) {
 }
@@ skipping 751 matching lines @@
 WebTouchState::WebTouchState(const RenderWidgetHostViewWin* window)
     : window_(window) { }
 
 size_t WebTouchState::UpdateTouchPoints(
     TOUCHINPUT* points, size_t count) {
   // First we reset all touch event state. This involves removing any released
   // touchpoints and marking the rest as stationary. After that we go through
   // and alter/add any touchpoints (from the touch input buffer) that we can
   // coalesce into a single message. The return value is the number of consumed
   // input message.
-  WebKit::WebTouchPoint* point = touch_event_.data().touches;
-  WebKit::WebTouchPoint* end = point + touch_event_.data().touchesLength;
+  WebKit::WebTouchPoint* point = touch_event_.touches;
+  WebKit::WebTouchPoint* end = point + touch_event_.touchesLength;
   while (point < end) {
     if (point->state == WebKit::WebTouchPoint::StateReleased) {
       *point = *(--end);
-      --touch_event_.data().touchesLength;
+      --touch_event_.touchesLength;
     } else {
       point->state = WebKit::WebTouchPoint::StateStationary;
       point++;
     }
   }
-  touch_event_.data().changedTouchesLength = 0;
+  touch_event_.changedTouchesLength = 0;
 
   // Consume all events of the same type and add them to the changed list.
   int last_type = 0;
   for (size_t i = 0; i < count; ++i) {
     unsigned int mapped_id = GetMappedTouch(points[i].dwID);
 
     WebKit::WebTouchPoint* point = NULL;
-    for (unsigned j = 0; j < touch_event_.data().touchesLength; ++j) {
-      if (static_cast<DWORD>(touch_event_.data().touches[j].id) == mapped_id) {
-        point =  &touch_event_.data().touches[j];
+    for (unsigned j = 0; j < touch_event_.touchesLength; ++j) {
+      if (static_cast<DWORD>(touch_event_.touches[j].id) == mapped_id) {
+        point =  &touch_event_.touches[j];
         break;
       }
     }
 
     // Use a move instead if we see a down on a point we already have.
     int type = GetTouchType(points[i]);
     if (point && type == TOUCHEVENTF_DOWN)
       SetTouchType(&points[i], TOUCHEVENTF_MOVE);
 
     // Stop processing when the event type changes.
-    if (touch_event_.data().changedTouchesLength && type != last_type)
+    if (touch_event_.changedTouchesLength && type != last_type)
       return i;
 
-    touch_event_.SetTimestamp(
-        base::TimeDelta::FromMilliseconds(points[i].dwTime));
+    touch_event_.timeStampSeconds = points[i].dwTime / 1000.0;
 
     last_type = type;
     switch (type) {
       case TOUCHEVENTF_DOWN: {
         if (!(point = AddTouchPoint(&points[i])))
           continue;
-        touch_event_.data().type = WebKit::WebInputEvent::TouchStart;
+        touch_event_.type = WebKit::WebInputEvent::TouchStart;
         break;
       }
 
       case TOUCHEVENTF_UP: {
         if (!point)  // Just throw away a stray up.
           continue;
         point->state = WebKit::WebTouchPoint::StateReleased;
         UpdateTouchPoint(point, &points[i]);
-        touch_event_.data().type = WebKit::WebInputEvent::TouchEnd;
+        touch_event_.type = WebKit::WebInputEvent::TouchEnd;
         break;
       }
 
       case TOUCHEVENTF_MOVE: {
         if (point) {
           point->state = WebKit::WebTouchPoint::StateMoved;
           // Don't update the message if the point didn't really move.
           if (UpdateTouchPoint(point, &points[i]))
             continue;
-          touch_event_.data().type = WebKit::WebInputEvent::TouchMove;
-        } else if (touch_event_.data().changedTouchesLength) {
+          touch_event_.type = WebKit::WebInputEvent::TouchMove;
+        } else if (touch_event_.changedTouchesLength) {
           RemoveExpiredMappings();
           // Can't add a point if we're already handling move events.
           return i;
         } else {
           // Treat a move with no existing point as a down.
           if (!(point = AddTouchPoint(&points[i])))
             continue;
           last_type = TOUCHEVENTF_DOWN;
           SetTouchType(&points[i], TOUCHEVENTF_DOWN);
-          touch_event_.data().type = WebKit::WebInputEvent::TouchStart;
+          touch_event_.type = WebKit::WebInputEvent::TouchStart;
         }
         break;
       }
 
       default:
         NOTREACHED();
         continue;
     }
-    touch_event_.data().changedTouches[
-        touch_event_.data().changedTouchesLength++] = *point;
+    touch_event_.changedTouches[touch_event_.changedTouchesLength++] = *point;
   }
 
   RemoveExpiredMappings();
   return count;
 }
 
 void WebTouchState::RemoveExpiredMappings() {
   WebTouchState::MapType new_map;
   for (MapType::iterator it = touch_map_.begin();
       it != touch_map_.end();
       ++it) {
-    WebKit::WebTouchPoint* point = touch_event_.data().touches;
-    WebKit::WebTouchPoint* end = point + touch_event_.data().touchesLength;
+    WebKit::WebTouchPoint* point = touch_event_.touches;
+    WebKit::WebTouchPoint* end = point + touch_event_.touchesLength;
     while (point < end) {
       if ((point->id == it->second) &&
           (point->state != WebKit::WebTouchPoint::StateReleased)) {
         new_map.insert(*it);
         break;
       }
       point++;
     }
   }
   touch_map_.swap(new_map);
 }
 
 
 bool WebTouchState::ReleaseTouchPoints() {
-  if (touch_event_.data().touchesLength == 0)
+  if (touch_event_.touchesLength == 0)
     return false;
   // Mark every active touchpoint as released.
-  touch_event_.data().type = WebKit::WebInputEvent::TouchEnd;
-  touch_event_.data().changedTouchesLength = touch_event_.data().touchesLength;
-  for (unsigned int i = 0; i < touch_event_.data().touchesLength; ++i) {
-    touch_event_.data().touches[i].state = WebKit::WebTouchPoint::StateReleased;
-    touch_event_.data().changedTouches[i].state =
+  touch_event_.type = WebKit::WebInputEvent::TouchEnd;
+  touch_event_.changedTouchesLength = touch_event_.touchesLength;
+  for (unsigned int i = 0; i < touch_event_.touchesLength; ++i) {
+    touch_event_.touches[i].state = WebKit::WebTouchPoint::StateReleased;
+    touch_event_.changedTouches[i].state =
         WebKit::WebTouchPoint::StateReleased;
   }
 
   return true;
 }
 
 WebKit::WebTouchPoint* WebTouchState::AddTouchPoint(
     TOUCHINPUT* touch_input) {
-  DCHECK(touch_event_.data().touchesLength <
+  DCHECK(touch_event_.touchesLength <
       WebKit::WebTouchEvent::touchesLengthCap);
-  if (touch_event_.data().touchesLength >=
+  if (touch_event_.touchesLength >=
       WebKit::WebTouchEvent::touchesLengthCap)
     return NULL;
   WebKit::WebTouchPoint* point =
-      &touch_event_.data().touches[touch_event_.data().touchesLength++];
+      &touch_event_.touches[touch_event_.touchesLength++];
   point->state = WebKit::WebTouchPoint::StatePressed;
   point->id = GetMappedTouch(touch_input->dwID);
   UpdateTouchPoint(point, touch_input);
   return point;
 }
 
 bool WebTouchState::UpdateTouchPoint(
     WebKit::WebTouchPoint* touch_point,
     TOUCHINPUT* touch_input) {
   CPoint coordinates(TOUCH_COORD_TO_PIXEL(touch_input->x),
@@ skipping 58 matching lines @@
 
   // Send a copy of the touch events on to the gesture recognizer.
   for (size_t start = 0; start < total;) {
     start += touch_state_->UpdateTouchPoints(points + start, total - start);
     if (has_touch_handler) {
       if (touch_state_->is_changed()) {
         render_widget_host_->ForwardTouchEvent(touch_state_->touch_event());
         touch_state_->QueueEvents(this, gesture_recognizer_.get());
       }
     } else {
-      const LocalTouchEvent* touch_event = touch_state_->ui_touch_event();
-      for (size_t i = 0; i < touch_event->data().touchesLength; ++i) {
+      const WebKit::WebTouchEvent& touch_event = touch_state_->touch_event();
+      base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds(
+          touch_event.timeStampSeconds * 1000);
+      for (size_t i = 0; i < touch_event.touchesLength; ++i) {
         scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
         gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
-            touch_event->Index(i), ui::TOUCH_STATUS_UNKNOWN, this));
+            TouchEventFromWebTouchPoint(touch_event.touches[i], timestamp),
+            ui::TOUCH_STATUS_UNKNOWN, this));
         ProcessGestures(gestures.get());
       }
     }
   }
 
   CloseTouchInputHandle((HTOUCHINPUT)lparam);
 
   return 0;
 }
 
@@ skipping 836 matching lines @@
   // 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;
 }
 
 }  // namespace content