mustash: Use ui::chromeos::EventRewriter in mus

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 <stdint.h>
 
 #include <list>
 
 #include "base/command_line.h"
 #include "base/location.h"
@@ skipping 493 matching lines @@
   base::TimeTicks LeapForward(int time_in_millis) {
     tick_clock_.Advance(base::TimeDelta::FromMilliseconds(time_in_millis));
     return tick_clock_.NowTicks();
   }
 
   base::TimeTicks InFuture(int time_in_millis) {
     return tick_clock_.NowTicks() +
         base::TimeDelta::FromMilliseconds(time_in_millis);
   }
 
-  void SendScrollEvents(ui::EventProcessor* dispatcher,
+  void SendScrollEvents(ui::EventSink* sink,
                         int x_start,
                         int y_start,
                         int dx,
                         int dy,
                         int touch_id,
                         int time_step_ms,
                         int num_steps,
                         GestureEventConsumeDelegate* delegate) {
     float x = x_start;
     float y = y_start;
 
     for (int i = 0; i < num_steps; i++) {
       x += dx;
       y += dy;
       ui::TouchEvent move(
           ui::ET_TOUCH_MOVED, gfx::Point(x, y), tick_clock_.NowTicks(),
           ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH,
                              touch_id));
-      ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move);
+      ui::EventDispatchDetails details = sink->OnEventFromSource(&move);
       ASSERT_FALSE(details.dispatcher_destroyed);
       tick_clock_.Advance(base::TimeDelta::FromMilliseconds(time_step_ms));
     }
   }
 
-  void SendScrollEvent(ui::EventProcessor* dispatcher,
+  void SendScrollEvent(ui::EventSink* sink,
                        float x,
                        float y,
                        int touch_id,
                        GestureEventConsumeDelegate* delegate) {
     delegate->Reset();
     ui::TouchEvent move(
         ui::ET_TOUCH_MOVED, gfx::Point(), Now(),
         ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, touch_id));
     move.set_location_f(gfx::PointF(x, y));
     move.set_root_location_f(gfx::PointF(x, y));
-    ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move);
+    ui::EventDispatchDetails details = sink->OnEventFromSource(&move);
     ASSERT_FALSE(details.dispatcher_destroyed);
   }
 };
 
 // An event handler to keep track of events.
 class TestEventHandler : public ui::EventHandler {
  public:
   TestEventHandler()
       : touch_released_count_(0),
         touch_pressed_count_(0),
@@ skipping 484 matching lines @@
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_BEGIN,
                   ui::ET_GESTURE_TAP_DOWN);
 
   // Move the touch-point enough so that it is considered as a scroll. This
   // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures.
   // The first movement is diagonal, to ensure that we have a free scroll,
   // and not a rail scroll.
-  tes.SendScrollEvent(event_processor(), 111.5, 211.5, kTouchId,
-                      delegate.get());
+  tes.SendScrollEvent(event_sink(), 111.5, 211.5, kTouchId, delegate.get());
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_TAP_CANCEL,
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE);
   // The slop consumed 5 dips
   EXPECT_FLOAT_EQ(5.5, delegate->scroll_x());
   EXPECT_FLOAT_EQ(5.5, delegate->scroll_y());
   EXPECT_EQ(gfx::Point(1, 1).ToString(),
             delegate->scroll_begin_position().ToString());
 
   // When scrolling with a single finger, the bounding box of the gesture should
   // be empty, since it's a single point and the radius for testing is zero.
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   // Move some more to generate a few more scroll updates. Make sure that we get
   // out of the snap channel for the unified GR.
-  tes.SendScrollEvent(event_processor(), 20, 120, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 20, 120, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_FLOAT_EQ(-91.5, delegate->scroll_x());
   EXPECT_FLOAT_EQ(-91.5, delegate->scroll_y());
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
-  tes.SendScrollEvent(event_processor(), 50, 124, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 50, 124, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_EQ(30, delegate->scroll_x());
   EXPECT_EQ(4, delegate->scroll_y());
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   // Release the touch. This should end the scroll.
   delegate->Reset();
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), tes.LeapForward(50),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
@@ skipping 45 matching lines @@
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE);
   total_scroll.set_x(total_scroll.x() + delegate->scroll_x());
   total_scroll.set_y(total_scroll.y() + delegate->scroll_y());
 
   // Move the touch-point enough so that it is considered as a scroll. This
   // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures.
   // The first movement is diagonal, to ensure that we have a free scroll,
   // and not a rail scroll.
   tes.LeapForward(30);
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 130, 230, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(),
                  ui::ET_GESTURE_SCROLL_UPDATE);
   total_scroll.set_x(total_scroll.x() + delegate->scroll_x());
   total_scroll.set_y(total_scroll.y() + delegate->scroll_y());
 
   // Move some more to generate a few more scroll updates.
   tes.LeapForward(30);
-  tes.SendScrollEvent(event_processor(), 110, 211, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 110, 211, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   total_scroll.set_x(total_scroll.x() + delegate->scroll_x());
   total_scroll.set_y(total_scroll.y() + delegate->scroll_y());
 
   tes.LeapForward(30);
-  tes.SendScrollEvent(event_processor(), 140, 215, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 140, 215, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   total_scroll.set_x(total_scroll.x() + delegate->scroll_x());
   total_scroll.set_y(total_scroll.y() + delegate->scroll_y());
 
   // Release the touch. This should end the scroll.
   delegate->Reset();
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), tes.LeapForward(50),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&release);
@@ skipping 18 matching lines @@
     delegate->Reset();
     ui::TouchEvent press(
         ui::ET_TOUCH_PRESSED, gfx::Point(kPositionX, kPositionY), tes.Now(),
         ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
     DispatchEventUsingWindowDispatcher(&press);
     EXPECT_EQ(gfx::Rect(kPositionX - radius, kPositionY - radius, radius * 2,
                         radius * 2),
               delegate->bounding_box());
 
     const int kScrollAmount = 50;
-    tes.SendScrollEvents(event_processor(), kPositionX, kPositionY,
-                         1, 1, kTouchId, 1, kScrollAmount, delegate.get());
+    tes.SendScrollEvents(event_sink(), kPositionX, kPositionY, 1, 1, kTouchId,
+                         1, kScrollAmount, delegate.get());
     EXPECT_EQ(gfx::Point(1, 1).ToString(),
               delegate->scroll_begin_position().ToString());
     EXPECT_EQ(
         gfx::Rect(kPositionX + kScrollAmount - radius,
                   kPositionY + kScrollAmount - radius, radius * 2, radius * 2),
         delegate->bounding_box());
 
     // Release the touch. This should end the scroll.
     delegate->Reset();
     ui::TouchEvent release(
@@ skipping 29 matching lines @@
   // Get rid of touch slop.
   ui::TouchEvent move(
       ui::ET_TOUCH_MOVED, gfx::Point(10, 0), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
-  tes.SendScrollEvent(event_processor(), 30, 1, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 30, 1, kTouchId, delegate.get());
   EXPECT_FLOAT_EQ(0, delegate->scroll_y());
   EXPECT_FLOAT_EQ(20, delegate->scroll_x());
 
   // Get a high x velocity, while still staying on the rail
   const int kScrollAmount = 8;
-  tes.SendScrollEvents(event_processor(),
-                       1,
-                       1,
-                       100,
-                       10,
-                       kTouchId,
-                       1,
-                       kScrollAmount,
+  tes.SendScrollEvents(event_sink(), 1, 1, 100, 10, kTouchId, 1, kScrollAmount,
                        delegate.get());
 
   delegate->Reset();
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
@@ skipping 19 matching lines @@
 
   // Get rid of touch slop.
   ui::TouchEvent move(
       ui::ET_TOUCH_MOVED, gfx::Point(0, 10), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
-  tes.SendScrollEvent(event_processor(), 1, 30, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 1, 30, kTouchId, delegate.get());
   EXPECT_EQ(20, delegate->scroll_y());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
 
   // Get a high y velocity, while still staying on the rail
   const int kScrollAmount = 8;
-  tes.SendScrollEvents(event_processor(),
-                       1,
-                       6,
-                       10,
-                       100,
-                       kTouchId,
-                       1,
-                       kScrollAmount,
+  tes.SendScrollEvents(event_sink(), 1, 6, 10, 100, kTouchId, 1, kScrollAmount,
                        delegate.get());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
 
   delegate->Reset();
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, gfx::Point(101, 206), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
@@ skipping 15 matching lines @@
   std::unique_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&press);
 
   // Move the touch-point such that a non-rail scroll begins, and we're outside
   // the snap channel for the unified GR.
-  tes.SendScrollEvent(event_processor(), 50, 50, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 50, 50, kTouchId, delegate.get());
   EXPECT_EQ(50, delegate->scroll_y());
   EXPECT_EQ(50, delegate->scroll_x());
 
   const int kScrollAmount = 8;
-  tes.SendScrollEvents(event_processor(),
-                       1,
-                       1,
-                       10,
-                       100,
-                       kTouchId,
-                       1,
-                       kScrollAmount,
+  tes.SendScrollEvents(event_sink(), 1, 1, 10, 100, kTouchId, 1, kScrollAmount,
                        delegate.get());
 
   delegate->Reset();
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
@@ skipping 60 matching lines @@
       ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
 
   // We haven't pressed long enough for a long press to occur
   EXPECT_FALSE(delegate->long_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   // Scroll around, to cancel the long press
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 130, 230, kTouchId, delegate.get());
 
   // Wait until a long press event would have fired, if it hadn't been
   // cancelled.
   DelayByLongPressTimeout();
 
   EXPECT_FALSE(delegate->long_press());
   EXPECT_TRUE(delegate->tap_cancel());
 
   delegate->Reset();
   ui::TouchEvent release1(
@@ skipping 117 matching lines @@
   // Get rid of touch slop.
   ui::TouchEvent move(
       ui::ET_TOUCH_MOVED, gfx::Point(5, 0), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
 
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
-  tes.SendScrollEvent(event_processor(), 25, 0, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 25, 0, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_y());
   EXPECT_EQ(20, delegate->scroll_x());
 
-  tes.SendScrollEvent(event_processor(), 30, 6, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 30, 6, kTouchId, delegate.get());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(5, delegate->scroll_x());
   // y shouldn't change, as we're on a horizontal rail.
   EXPECT_EQ(0, delegate->scroll_y());
 
   // Send enough information that a velocity can be calculated for the gesture,
   // and we can break the rail
   const int kScrollAmount = 8;
-  tes.SendScrollEvents(event_processor(),
-                       1,
-                       1,
-                       6,
-                       100,
-                       kTouchId,
-                       1,
-                       kScrollAmount,
+  tes.SendScrollEvents(event_sink(), 1, 1, 6, 100, kTouchId, 1, kScrollAmount,
                        delegate.get());
 
-  tes.SendScrollEvent(event_processor(), 5, 0, kTouchId, delegate.get());
-  tes.SendScrollEvent(event_processor(), 10, 5, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 5, 0, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 10, 5, kTouchId, delegate.get());
 
   // The rail should be broken
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(5, delegate->scroll_x());
   EXPECT_EQ(5, delegate->scroll_y());
 }
 
 // Check that vertical scroll gestures cause scrolls on vertical rails.
 // Also tests that vertical rails can be broken.
 TEST_F(GestureRecognizerTest, GestureEventVerticalRailScroll) {
@@ skipping 12 matching lines @@
 
   // Get rid of touch slop.
   ui::TouchEvent move(
       ui::ET_TOUCH_MOVED, gfx::Point(0, 5), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
-  tes.SendScrollEvent(event_processor(), 0, 25, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 0, 25, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(20, delegate->scroll_y());
 
-  tes.SendScrollEvent(event_processor(), 6, 30, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 6, 30, kTouchId, delegate.get());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(5, delegate->scroll_y());
   // x shouldn't change, as we're on a vertical rail.
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
 
   // Send enough information that a velocity can be calculated for the gesture,
   // and we can break the rail
   const int kScrollAmount = 8;
-  tes.SendScrollEvents(event_processor(),
-                       1,
-                       6,
-                       100,
-                       1,
-                       kTouchId,
-                       1,
-                       kScrollAmount,
+  tes.SendScrollEvents(event_sink(), 1, 6, 100, 1, kTouchId, 1, kScrollAmount,
                        delegate.get());
 
-  tes.SendScrollEvent(event_processor(), 0, 5, kTouchId, delegate.get());
-  tes.SendScrollEvent(event_processor(), 5, 10, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 0, 5, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 5, 10, kTouchId, delegate.get());
 
   // The rail should be broken
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(5, delegate->scroll_x());
   EXPECT_EQ(5, delegate->scroll_y());
 }
 
 TEST_F(GestureRecognizerTest, GestureTapFollowedByScroll) {
   // We'll start by moving the touch point by (5, 5). We want all of that
   // distance to be consumed by the slop, so we set the slop radius to
@@ skipping 440 matching lines @@
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId1));
   DispatchEventUsingWindowDispatcher(&press);
   delegate->Reset();
   ui::TouchEvent press2(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId2));
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_FALSE(delegate->pinch_begin());
 
   // Touch move triggers pinch begin.
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_sink(), 130, 230, kTouchId1, delegate.get());
   EXPECT_TRUE(delegate->pinch_begin());
   EXPECT_FALSE(delegate->pinch_update());
 
   // Touch move triggers pinch update.
-  tes.SendScrollEvent(event_processor(), 160, 200, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_sink(), 160, 200, kTouchId1, delegate.get());
   EXPECT_FALSE(delegate->pinch_begin());
   EXPECT_TRUE(delegate->pinch_update());
 
   // Pinch has started, now release the second finger
   delegate->Reset();
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId1));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_TRUE(delegate->pinch_end());
 
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId2, delegate.get());
+  tes.SendScrollEvent(event_sink(), 130, 230, kTouchId2, delegate.get());
   EXPECT_TRUE(delegate->scroll_update());
 
   // Pinch again
   delegate->Reset();
   ui::TouchEvent press3(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId1));
   DispatchEventUsingWindowDispatcher(&press3);
   // Now the touch points are close. So we will go into two finger tap.
   // Move the touch-point enough to break two-finger-tap and enter pinch.
   ui::TouchEvent move2(
       ui::ET_TOUCH_MOVED, gfx::Point(101, 50), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId1));
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_TRUE(delegate->pinch_begin());
 
-  tes.SendScrollEvent(event_processor(), 350, 350, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_sink(), 350, 350, kTouchId1, delegate.get());
   EXPECT_TRUE(delegate->pinch_update());
 }
 
 TEST_F(GestureRecognizerTest, GestureEventPinchFromTap) {
   std::unique_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 3;
@@ skipping 651 matching lines @@
                            kTouchId1));
     DispatchEventUsingWindowDispatcher(&press1);
 
     delegate->Reset();
     ui::TouchEvent press2(
         ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), tes.Now(),
         ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH,
                            kTouchId2));
     DispatchEventUsingWindowDispatcher(&press2);
 
-    tes.SendScrollEvent(event_processor(), 230, 330, kTouchId1, delegate.get());
+    tes.SendScrollEvent(event_sink(), 230, 330, kTouchId1, delegate.get());
     EXPECT_FALSE(delegate->two_finger_tap());
     EXPECT_TRUE(delegate->pinch_begin());
 
     // Make sure there is enough delay before the touch is released so that it
     // is recognized as a tap.
     delegate->Reset();
     ui::TouchEvent release(
         ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), tes.LeapForward(50),
         ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH,
                            kTouchId2));
@@ skipping 16 matching lines @@
                            kTouchId1));
     DispatchEventUsingWindowDispatcher(&press1);
 
     delegate->Reset();
     ui::TouchEvent press2(
         ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), tes.Now(),
         ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH,
                            kTouchId2));
     DispatchEventUsingWindowDispatcher(&press2);
 
-    tes.SendScrollEvent(event_processor(), 301, 230, kTouchId2, delegate.get());
+    tes.SendScrollEvent(event_sink(), 301, 230, kTouchId2, delegate.get());
     EXPECT_FALSE(delegate->two_finger_tap());
     EXPECT_TRUE(delegate->pinch_begin());
 
     // Make sure there is enough delay before the touch is released so that it
     // is recognized as a tap.
     delegate->Reset();
     ui::TouchEvent release(
         ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), tes.LeapForward(50),
         ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH,
                            kTouchId1));
@@ skipping 15 matching lines @@
 
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   std::unique_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
   ui::TouchEvent press1(
       ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId1));
   DispatchEventUsingWindowDispatcher(&press1);
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_sink(), 130, 230, kTouchId1, delegate.get());
 
   delegate->Reset();
   ui::TouchEvent press2(
       ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId2));
   DispatchEventUsingWindowDispatcher(&press2);
 
   EXPECT_FALSE(delegate->pinch_begin());
 
   // Make sure there is enough delay before the touch is released so that it
@@ skipping 254 matching lines @@
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
   TimedEvents tes;
 
   delegate->Reset();
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&press);
   // Scroll around, to cancel the long press
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 130, 230, kTouchId, delegate.get());
 
   delegate->Reset();
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->tap_down());
 
   // Wait long enough that long press would have fired if the touchmove hadn't
   // prevented it.
   DelayByLongPressTimeout();
 
   delegate->Reset();
@@ skipping 44 matching lines @@
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Move the touch-point enough so that it would normally be considered a
   // scroll. But since the touch-moves will be consumed, the scroll should not
   // start.
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_TRUE(delegate->scroll_begin());
 
   // Release the touch back at the start point. This should end without causing
@@ skipping 27 matching lines @@
 
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   std::unique_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
   ui::TouchEvent press1(
       ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId1));
   DispatchEventUsingWindowDispatcher(&press1);
-  tes.SendScrollEvent(event_processor(), 131, 231, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_sink(), 131, 231, kTouchId1, delegate.get());
 
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_TAP_CANCEL,
                   ui::ET_GESTURE_SCROLL_BEGIN);
 
   delegate->Reset();
   // Second finger touches down and moves.
   ui::TouchEvent press2(
       ui::ET_TOUCH_PRESSED, gfx::Point(130, 201), tes.LeapForward(50),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId2));
   DispatchEventUsingWindowDispatcher(&press2);
-  tes.SendScrollEvent(event_processor(), 161, 231, kTouchId2, delegate.get());
+  tes.SendScrollEvent(event_sink(), 161, 231, kTouchId2, delegate.get());
   EXPECT_0_EVENTS(delegate->events());
 
   delegate->Reset();
   // Move first finger again, no PinchUpdate & ScrollUpdate.
-  tes.SendScrollEvent(event_processor(), 161, 261, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_sink(), 161, 261, kTouchId1, delegate.get());
   EXPECT_0_EVENTS(delegate->events());
 
   // Stops consuming touch-move.
   delegate->set_consume_touch_move(false);
 
   delegate->Reset();
   // Making a pinch gesture.
-  tes.SendScrollEvent(event_processor(), 161, 260, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_sink(), 161, 260, kTouchId1, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
 
   delegate->Reset();
-  tes.SendScrollEvent(event_processor(), 161, 261, kTouchId2, delegate.get());
+  tes.SendScrollEvent(event_sink(), 161, 261, kTouchId2, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
 
   delegate->Reset();
   ui::TouchEvent release1(
       ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId1));
   ui::TouchEvent release2(
       ui::ET_TOUCH_RELEASED, gfx::Point(130, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId2));
   DispatchEventUsingWindowDispatcher(&release1);
@@ skipping 28 matching lines @@
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Move the touch-point enough so that it would normally be considered a
   // scroll. But since the touch-moves will be consumed, the scroll should not
   // start.
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Consuming the first touch move event won't prevent all future scrolling.
   EXPECT_TRUE(delegate->scroll_begin());
 
   // Now, stop consuming touch-move events, and move the touch-point again.
   delegate->set_consume_touch_move(false);
-  tes.SendScrollEvent(event_processor(), 159, 259, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 159, 259, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Scroll not prevented by consumed first touch move.
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(29, delegate->scroll_x());
   EXPECT_EQ(29, delegate->scroll_y());
   EXPECT_EQ(gfx::Point(0, 0).ToString(),
             delegate->scroll_begin_position().ToString());
 
   // Start consuming touch-move events again.
   delegate->set_consume_touch_move(true);
 
   // Move some more to generate a few more scroll updates.
-  tes.SendScrollEvent(event_processor(), 110, 211, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 110, 211, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_y());
 
-  tes.SendScrollEvent(event_processor(), 140, 215, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 140, 215, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_y());
 
@@ skipping 361 matching lines @@
 
   delegate->set_consume_touch_move(false);
   DispatchEventUsingWindowDispatcher(&press);
   delegate->set_consume_touch_move(true);
   delegate->Reset();
   // Move the touch-point enough so that it would normally be considered a
   // scroll. But since the touch-moves will be consumed, no scrolling should
   // occur.
   // With the unified gesture detector, we will receive a scroll begin gesture,
   // whereas with the aura gesture recognizer we won't.
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 }
 
 TEST_F(GestureRecognizerTest, CancelAllActiveTouches) {
   std::unique_ptr<GestureEventConsumeDelegate> delegate(
@@ skipping 116 matching lines @@
       ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), tes.Now(),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
 
   // We haven't pressed long enough for a show press to occur
   EXPECT_FALSE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   // Scroll around, to cancel the show press
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_sink(), 130, 230, kTouchId, delegate.get());
   // Wait until the timer runs out
   DelayByShowPressTimeout();
   EXPECT_FALSE(delegate->show_press());
   EXPECT_TRUE(delegate->tap_cancel());
 
   delegate->Reset();
   ui::TouchEvent release1(
       ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), tes.LeapForward(10),
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, kTouchId));
   DispatchEventUsingWindowDispatcher(&release1);
@@ skipping 777 matching lines @@
   EXPECT_FALSE(queued_delegate2->long_press());
 
   queued_delegate->Reset();
   queued_delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_SHOW_PRESS);
   EXPECT_TRUE(queued_delegate->show_press());
   EXPECT_FALSE(queued_delegate->tap_down());
 }
 
 }  // namespace test
 }  // namespace aura