gesture recognizer: Remove the touch-event queue.

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 14 matching lines @@
 #include "base/win/wrapped_window_proc.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/accessibility/browser_accessibility_win.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/renderer_host/backing_store.h"
 #include "content/browser/renderer_host/backing_store_win.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/renderer_host/ui_events_helper.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/plugin_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
@@ skipping 358 matching lines @@
 
   // Marks all active touchpoints as released.
   bool ReleaseTouchPoints();
 
   // The contained WebTouchEvent.
   const WebKit::WebTouchEvent& touch_event() { return touch_event_; }
 
   // Returns if any touches are modified in the event.
   bool is_changed() { return touch_event_.changedTouchesLength != 0; }
 
-  void QueueEvents(ui::GestureConsumer* consumer, ui::GestureRecognizer* gr) {
-    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;
-  }
-
  private:
   typedef std::map<unsigned int, int> MapType;
 
   // Adds a touch point or returns NULL if there's not enough space.
   WebKit::WebTouchPoint* AddTouchPoint(TOUCHINPUT* touch_input);
 
   // Copy details from a TOUCHINPUT to an existing WebTouchPoint, returning
   // true if the resulting point is a stationary move.
   bool UpdateTouchPoint(WebKit::WebTouchPoint* touch_point,
                         TOUCHINPUT* touch_input);
 
   // Find (or create) a mapping for _os_touch_id_.
   unsigned int GetMappedTouch(unsigned int os_touch_id);
 
   // 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_;
-
   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 483 matching lines @@
 }
 
 void RenderWidgetHostViewWin::SetBackground(const SkBitmap& background) {
   RenderWidgetHostViewBase::SetBackground(background);
   render_widget_host_->SetBackground(background);
 }
 
 void RenderWidgetHostViewWin::ProcessAckedTouchEvent(
     const WebKit::WebTouchEvent& touch,
     bool processed) {
-  DCHECK(render_widget_host_->has_touch_handler() &&
-      touch_events_enabled_);
+  DCHECK(touch_events_enabled_);
 
-  int touch_count = touch_state_->GetNextTouchCount();
-  for (int i = 0; i < touch_count; ++i) {
+  ScopedVector<ui::TouchEvent> events;
+  if (!MakeUITouchEventsFromWebTouchEvents(touch, &events))
+    return;
+
+  ui::EventResult result = processed ? ui::ER_HANDLED : ui::ER_UNHANDLED;
+  for (ScopedVector<ui::TouchEvent>::iterator iter = events.begin(),
+      end = events.end(); iter != end; ++iter)  {
     scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
-    gestures.reset(gesture_recognizer_->AdvanceTouchQueue(this, processed));
+    gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
+        *(*iter), result, this));
     ProcessGestures(gestures.get());
   }
 }
 
 void RenderWidgetHostViewWin::UpdateDesiredTouchMode() {
   // Make sure that touch events even make sense.
   static bool touch_mode = base::win::GetVersion() >= base::win::VERSION_WIN7 &&
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableTouchEvents);
 
   if (!touch_mode)
@@ skipping 21 matching lines @@
   }
 }
 
 bool RenderWidgetHostViewWin::DispatchLongPressGestureEvent(
     ui::GestureEvent* event) {
   return ForwardGestureEventToRenderer(event);
 }
 
 bool RenderWidgetHostViewWin::DispatchCancelTouchEvent(
     ui::TouchEvent* event) {
-  if (!render_widget_host_ || !touch_events_enabled_)
+  if (!render_widget_host_ || !touch_events_enabled_ ||
+      !render_widget_host_->ShouldForwardTouchEvent()) {
     return false;
+  }
   DCHECK(event->type() == WebKit::WebInputEvent::TouchCancel);
   WebKit::WebTouchEvent cancel_event;
   cancel_event.type = WebKit::WebInputEvent::TouchCancel;
   cancel_event.timeStampSeconds = event->time_stamp().InSecondsF();
   render_widget_host_->ForwardTouchEvent(cancel_event);
   return true;
 }
 
 void RenderWidgetHostViewWin::SetHasHorizontalScrollbar(
     bool has_horizontal_scrollbar) {
@@ skipping 1200 matching lines @@
     return 0;
   }
 
   if (total == 1 && (points[0].dwFlags & TOUCHEVENTF_DOWN)) {
     pointer_down_context_ = true;
     last_touch_location_ = gfx::Point(
         TOUCH_COORD_TO_PIXEL(points[0].x),
         TOUCH_COORD_TO_PIXEL(points[0].y));
   }
 
-  bool has_touch_handler = render_widget_host_->has_touch_handler() &&
+  bool should_forward = render_widget_host_->ShouldForwardTouchEvent() &&
       touch_events_enabled_;
 
   // 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()) {
+    if (should_forward) {
+      if (touch_state_->is_changed())
         render_widget_host_->ForwardTouchEvent(touch_state_->touch_event());
-        touch_state_->QueueEvents(this, gesture_recognizer_.get());
-      }
     } else {
       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(
             TouchEventFromWebTouchPoint(touch_event.touches[i], timestamp),
             ui::ER_UNHANDLED, this));
         ProcessGestures(gestures.get());
@@ skipping 852 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