Don't pass touches to gesture recognizer for async acks.

ui/aura/gestures/gesture_recognizer_unittest.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 "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 319 matching lines @@
   ui::EventType wait_until_event_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(WindowEventDispatcher* dispatcher)
       : window_(NULL),
         dispatcher_(dispatcher),
-        queue_events_(true),
-        synchronous_ack_for_next_event_(AckState::PENDING) {
-  }
-  ~QueueTouchEventDelegate() override {
-    while(!queue_.empty()) {
-      delete queue_.front();
-      queue_.pop();
-    }
-  }
+        synchronous_ack_for_next_event_(AckState::PENDING) {}
+
+  ~QueueTouchEventDelegate() override {}
 
   void OnTouchEvent(ui::TouchEvent* event) override {
     event->DisableSynchronousHandling();
     if (synchronous_ack_for_next_event_ != AckState::PENDING) {
       ui::GestureRecognizer::Get()->AckSyncTouchEvent(
           event->unique_event_id(),
           synchronous_ack_for_next_event_ == AckState::CONSUMED
               ? ui::ER_CONSUMED
               : ui::ER_UNHANDLED,
           window_);
       synchronous_ack_for_next_event_ = AckState::PENDING;
     }
-    if (queue_events_)
-      queue_.push(new ui::TouchEvent(*event, window_, window_));
   }
 
   void ReceivedAck() {
     ReceivedAckImpl(false);
   }
 
   void ReceivedAckPreventDefaulted() {
     ReceivedAckImpl(true);
   }
 
   void set_window(Window* w) { window_ = w; }
-  void set_queue_events(bool queue) { queue_events_ = queue; }
   void set_synchronous_ack_for_next_event(bool consumed) {
     DCHECK(synchronous_ack_for_next_event_ == AckState::PENDING);
     synchronous_ack_for_next_event_ =
         consumed ? AckState::CONSUMED : AckState::UNCONSUMED;
   }
 
  private:
   enum class AckState {
     PENDING,
     CONSUMED,
     UNCONSUMED,
   };
 
   void ReceivedAckImpl(bool prevent_defaulted) {
-    scoped_ptr<ui::TouchEvent> event(queue_.front());
-    dispatcher_->ProcessedTouchEvent(event.get(), window_,
-        prevent_defaulted ? ui::ER_HANDLED : ui::ER_UNHANDLED);
-    queue_.pop();
+    dispatcher_->ProcessedTouchEvent(
+        window_, prevent_defaulted ? ui::ER_HANDLED : ui::ER_UNHANDLED);
   }
 
-  std::queue<ui::TouchEvent*> queue_;
   Window* window_;
   WindowEventDispatcher* dispatcher_;
-  bool queue_events_;
   AckState synchronous_ack_for_next_event_;
 
   DISALLOW_COPY_AND_ASSIGN(QueueTouchEventDelegate);
 };
 
 // A delegate that ignores gesture events but keeps track of [synthetic] mouse
 // events.
 class GestureEventSynthDelegate : public TestWindowDelegate {
  public:
   GestureEventSynthDelegate()
@@ skipping 4020 matching lines @@
   // The synchronous ack is stuck behind the pending touch move.
   EXPECT_0_EVENTS(delegate->events());
 
   delegate->ReceivedAck();
   EXPECT_2_EVENTS(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_SCROLL_UPDATE);
 }
 
 }  // namespace test
 }  // namespace aura