Corrected issues with queued touch events. This fixes gestures 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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/threading/thread.h"
 #include "base/win/metro.h"
@@ skipping 472 matching lines @@
     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 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];
   }
 
  private:
@@ skipping 18 matching lines @@
   bool ReleaseTouchPoints();
 
   // The contained WebTouchEvent.
   const WebKit::WebTouchEvent& touch_event() { return touch_event_.data(); }
   const LocalTouchEvent* ui_touch_event() { return &touch_event_; }
 
   // Returns if any touches are modified in the event.
   bool is_changed() { return touch_event_.data().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));
     }
   }
 
+  int GetNextTouchCount() {
+    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_;
+
   LocalTouchEvent 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 615 matching lines @@
   callback.Run(result);
 }
 
 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());
+
+  DCHECK(render_widget_host_->has_touch_handler() &&
+      touch_events_enabled_);
+
+  int touch_count = touch_state_->GetNextTouchCount();
+  for (int i = 0; i < touch_count; ++i) {
+    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.
@@ skipping 354 matching lines @@
 void RenderWidgetHostViewWin::OnSetFocus(HWND window) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnSetFocus");
   if (!render_widget_host_)
     return;
 
   if (GetBrowserAccessibilityManager())
     GetBrowserAccessibilityManager()->GotFocus();
 
   render_widget_host_->GotFocus();
   render_widget_host_->SetActive(true);
-
-  if (touch_state_->ReleaseTouchPoints() && touch_events_enabled_)
-    render_widget_host_->ForwardTouchEvent(touch_state_->touch_event());
 }
 
 void RenderWidgetHostViewWin::OnKillFocus(HWND window) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnKillFocus");
   if (!render_widget_host_)
     return;
 
   render_widget_host_->SetActive(false);
   render_widget_host_->Blur();
-
-  if (touch_state_->ReleaseTouchPoints() && touch_events_enabled_)
-    render_widget_host_->ForwardTouchEvent(touch_state_->touch_event());
 }
 
 void RenderWidgetHostViewWin::OnCaptureChanged(HWND window) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnCaptureChanged");
   if (render_widget_host_)
     render_widget_host_->LostCapture();
 }
 
 void RenderWidgetHostViewWin::OnCancelMode() {
   TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnCancelMode");
@@ skipping 674 matching lines @@
     return 0;
   }
 
   bool has_touch_handler = render_widget_host_->has_touch_handler() &&
       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 (touch_state_->is_changed()) {
         render_widget_host_->ForwardTouchEvent(touch_state_->touch_event());
-      touch_state_->QueueEvents(this,gesture_recognizer_.get());
+        touch_state_->QueueEvents(this, gesture_recognizer_.get());
+      }
     } else {
-      // TODO: This probably needs to be updated to call Next()
-      scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
-      gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
-          *touch_state_->ui_touch_event(), ui::TOUCH_STATUS_UNKNOWN, this));
-      ProcessGestures(gestures.get());
+      const LocalTouchEvent* touch_event = touch_state_->ui_touch_event();
+      for (size_t i = 0; i < touch_event->data().touchesLength; ++i) {
+        scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
+        gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
+            touch_event->Index(i), ui::TOUCH_STATUS_UNKNOWN, this));
+        ProcessGestures(gestures.get());
+      }
     }
   }
 
   CloseTouchInputHandle((HTOUCHINPUT)lparam);
 
   return 0;
 }
 
 void RenderWidgetHostViewWin::ProcessGestures(
     ui::GestureRecognizer::Gestures* gestures) {
@@ skipping 845 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;
 }