Provide access to the WindowEventDispatcher as a ui::EventProcessor.

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 559 matching lines @@
 
   base::TimeDelta LeapForward(int time_in_millis) {
     simulated_now_ += time_in_millis;
     return base::TimeDelta::FromMilliseconds(simulated_now_);
   }
 
   base::TimeDelta InFuture(int time_in_millis) {
     return base::TimeDelta::FromMilliseconds(simulated_now_ + time_in_millis);
   }
 
-  void SendScrollEvents(WindowEventDispatcher* dispatcher,
+  void SendScrollEvents(ui::EventProcessor* dispatcher,
                         float x_start,
                         float y_start,
                         int dx,
                         int dy,
                         int touch_id,
                         int time_step,
                         int num_steps,
                         GestureEventConsumeDelegate* delegate) {
     int x = x_start;
     int y = y_start;
 
     for (int i = 0; i < num_steps; i++) {
       x += dx;
       y += dy;
       ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(x, y),
                           touch_id,
                           base::TimeDelta::FromMilliseconds(simulated_now_));
       ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move);
       ASSERT_FALSE(details.dispatcher_destroyed);
       simulated_now_ += time_step;
     }
   }
 
-  void SendScrollEvent(WindowEventDispatcher* dispatcher,
+  void SendScrollEvent(ui::EventProcessor* dispatcher,
                        float x,
                        float y,
                        int touch_id,
                        GestureEventConsumeDelegate* delegate) {
     delegate->Reset();
     ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(x, y),
                         touch_id,
                         base::TimeDelta::FromMilliseconds(simulated_now_));
     ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move);
     ASSERT_FALSE(details.dispatcher_destroyed);
@@ skipping 408 matching lines @@
                        kTouchId, tes.Now());
   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(dispatcher(), 111.5, 211.5, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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.
-  tes.SendScrollEvent(dispatcher(), 91, 192, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 91, 192, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_FLOAT_EQ(-20.5, delegate->scroll_x());
   EXPECT_FLOAT_EQ(-19.5, delegate->scroll_y());
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
-  tes.SendScrollEvent(dispatcher(), 121, 196, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 121, 196, 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),
                          kTouchId,
                          tes.LeapForward(50));
@@ 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(dispatcher(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(),
                  ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_GT(delegate->scroll_velocity_x(), 0);
   EXPECT_GT(delegate->scroll_velocity_y(), 0);
   total_scroll.set_x(total_scroll.x() + delegate->scroll_x());
   total_scroll.set_y(total_scroll.y() + delegate->scroll_y());
   EXPECT_EQ((int)(29 + delegate->scroll_velocity_x() * prediction_interval),
             (int)(total_scroll.x()));
   EXPECT_EQ((int)(29 + delegate->scroll_velocity_y() * prediction_interval),
             (int)(total_scroll.y()));
 
   // Move some more to generate a few more scroll updates.
   tes.LeapForward(30);
-  tes.SendScrollEvent(dispatcher(), 110, 211, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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());
   EXPECT_EQ((int)(9 + delegate->scroll_velocity_x() * prediction_interval),
             (int)(total_scroll.x()));
   EXPECT_EQ((int)(10 + delegate->scroll_velocity_y() * prediction_interval),
             (int)(total_scroll.y()));
 
   tes.LeapForward(30);
-  tes.SendScrollEvent(dispatcher(), 140, 215, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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());
   EXPECT_EQ((int)(39 + delegate->scroll_velocity_x() * prediction_interval),
             (int)(total_scroll.x()));
   EXPECT_EQ((int)(14 + delegate->scroll_velocity_y() * prediction_interval),
             (int)(total_scroll.y()));
 
   // Release the touch. This should end the scroll.
   delegate->Reset();
@@ skipping 25 matching lines @@
                          kTouchId,
                          tes.Now());
     DispatchEventUsingWindowDispatcher(&press);
     EXPECT_EQ(gfx::Rect(kPositionX - radius,
                         kPositionY - radius,
                         radius * 2,
                         radius * 2).ToString(),
               delegate->bounding_box().ToString());
 
     const int kScrollAmount = 50;
-    tes.SendScrollEvents(dispatcher(), kPositionX, kPositionY,
+    tes.SendScrollEvents(event_processor(), 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).ToString(),
               delegate->bounding_box().ToString());
 
     // Release the touch. This should end the scroll.
@@ skipping 30 matching lines @@
 
   // Get rid of touch slop.
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(5, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
-  tes.SendScrollEvent(dispatcher(), 25, 1, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 25, 1, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_y());
   EXPECT_EQ(1, delegate->scroll_y_ordinal());
   EXPECT_EQ(20, delegate->scroll_x());
   EXPECT_EQ(20, delegate->scroll_x_ordinal());
 
   // Get a high x velocity, while still staying on the rail
-  tes.SendScrollEvents(dispatcher(), 1, 1,
+  tes.SendScrollEvents(event_processor(), 1, 1,
                    100, 10, kTouchId, 1,
                    ui::GestureConfiguration::points_buffered_for_velocity(),
                    delegate.get());
   // The y-velocity during the scroll should be 0 since this is in a horizontal
   // rail scroll.
   EXPECT_GT(delegate->scroll_velocity_x(), 0);
   EXPECT_EQ(0, delegate->scroll_velocity_y());
 
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
@@ skipping 22 matching lines @@
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(0, 5),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
-  tes.SendScrollEvent(dispatcher(), 1, 25, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 1, 25, kTouchId, delegate.get());
   EXPECT_EQ(20, delegate->scroll_y());
   EXPECT_EQ(20, delegate->scroll_y_ordinal());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(1, delegate->scroll_x_ordinal());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
   EXPECT_GT(delegate->scroll_velocity_x_ordinal(), 0);
 
   // Get a high y velocity, while still staying on the rail
-  tes.SendScrollEvents(dispatcher(), 1, 6,
+  tes.SendScrollEvents(event_processor(), 1, 6,
                        10, 100, kTouchId, 1,
                        ui::GestureConfiguration::points_buffered_for_velocity(),
                        delegate.get());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
   EXPECT_GT(delegate->scroll_velocity_y(), 0);
 
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 206),
                          kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
@@ skipping 14 matching lines @@
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Move the touch-point such that a non-rail scroll begins
-  tes.SendScrollEvent(dispatcher(), 20, 20, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 20, 20, kTouchId, delegate.get());
   EXPECT_EQ(20, delegate->scroll_y());
   EXPECT_EQ(20, delegate->scroll_x());
 
-  tes.SendScrollEvents(dispatcher(), 1, 1,
+  tes.SendScrollEvents(event_processor(), 1, 1,
                        10, 100, kTouchId, 1,
                        ui::GestureConfiguration::points_buffered_for_velocity(),
                        delegate.get());
 
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                          kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
@@ skipping 73 matching lines @@
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                         kTouchId, tes.Now());
   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(dispatcher(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
   // Wait until the timer runs out
   gesture_sequence->ForceTimeout();
   EXPECT_FALSE(delegate->long_press());
   EXPECT_TRUE(delegate->tap_cancel());
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                           kTouchId, tes.LeapForward(10));
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
@@ skipping 119 matching lines @@
 
   // Get rid of touch slop.
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(5, 0),
                       kTouchId, tes.Now());
 
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
-  tes.SendScrollEvent(dispatcher(), 25, 1, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 25, 1, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_y());
   EXPECT_EQ(20, delegate->scroll_x());
 
-  tes.SendScrollEvent(dispatcher(), 30, 6, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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
-  tes.SendScrollEvents(dispatcher(), 1, 1,
+  tes.SendScrollEvents(event_processor(), 1, 1,
                        6, 100, kTouchId, 1,
                        ui::GestureConfiguration::points_buffered_for_velocity(),
                        delegate.get());
   // Since the scroll is not longer railing, the velocity should be set for both
   // axis.
   EXPECT_GT(delegate->scroll_velocity_x(), 0);
   EXPECT_GT(delegate->scroll_velocity_y(), 0);
 
-  tes.SendScrollEvent(dispatcher(), 5, 0, kTouchId, delegate.get());
-  tes.SendScrollEvent(dispatcher(), 10, 5, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 5, 0, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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 10 matching lines @@
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(0, 5),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
-  tes.SendScrollEvent(dispatcher(), 1, 25, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 1, 25, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(20, delegate->scroll_y());
 
-  tes.SendScrollEvent(dispatcher(), 6, 30, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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
-  tes.SendScrollEvents(dispatcher(), 1, 6,
+  tes.SendScrollEvents(event_processor(), 1, 6,
                        100, 1, kTouchId, 1,
                        ui::GestureConfiguration::points_buffered_for_velocity(),
                        delegate.get());
   EXPECT_GT(delegate->scroll_velocity_x(), 0);
   EXPECT_GT(delegate->scroll_velocity_y(), 0);
 
-  tes.SendScrollEvent(dispatcher(), 0, 5, kTouchId, delegate.get());
-  tes.SendScrollEvent(dispatcher(), 5, 10, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 0, 5, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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 116 matching lines @@
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_TRUE(delegate->fling());
 }
 
 TEST_F(GestureRecognizerTest, AsynchronousGestureRecognition) {
   scoped_ptr<QueueTouchEventDelegate> queued_delegate(
-      new QueueTouchEventDelegate(dispatcher()));
+      new QueueTouchEventDelegate(host()->dispatcher()));
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 6;
   const int kTouchId2 = 4;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> queue(CreateTestWindowWithDelegate(
       queued_delegate.get(), -1234, bounds, root_window()));
 
   queued_delegate->set_window(queue.get());
 
@@ skipping 276 matching lines @@
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 301),
                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   delegate->Reset();
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_FALSE(delegate->pinch_begin());
 
   // Touch move triggers pinch begin.
-  tes.SendScrollEvent(dispatcher(), 130, 230, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get());
   EXPECT_TRUE(delegate->pinch_begin());
   EXPECT_FALSE(delegate->pinch_update());
 
   // Touch move triggers pinch update.
-  tes.SendScrollEvent(dispatcher(), 160, 200, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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),
                          kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_TRUE(delegate->pinch_end());
 
-  tes.SendScrollEvent(dispatcher(), 130, 230, kTouchId2, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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),
                         kTouchId1, tes.Now());
   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, 202),
                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_TRUE(delegate->pinch_begin());
 
-  tes.SendScrollEvent(dispatcher(), 130, 230, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get());
   EXPECT_TRUE(delegate->pinch_update());
 }
 
 TEST_F(GestureRecognizerTest, GestureEventPinchFromTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 3;
@@ skipping 218 matching lines @@
   DispatchEventUsingWindowDispatcher(&press2);
 
   // As these presses were outside the root window, they should be
   // associated with the root window.
   EXPECT_EQ(0, window_gesture_sequence->point_count());
   EXPECT_EQ(2, root_window_gesture_sequence->point_count());
 }
 
 TEST_F(GestureRecognizerTest, NoTapWithPreventDefaultedRelease) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
-      new QueueTouchEventDelegate(dispatcher()));
+      new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
 
   delegate->Reset();
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->tap_down());
   delegate->Reset();
   delegate->ReceivedAckPreventDefaulted();
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_cancel());
 }
 
 TEST_F(GestureRecognizerTest, PinchScrollWithPreventDefaultedRelease) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
-      new QueueTouchEventDelegate(dispatcher()));
+      new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId1 = 7;
   const int kTouchId2 = 5;
   gfx::Rect bounds(10, 20, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
   {
     delegate->Reset();
@@ skipping 354 matching lines @@
     delegate->Reset();
     ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                           kTouchId1, tes.Now());
     DispatchEventUsingWindowDispatcher(&press1);
 
     delegate->Reset();
     ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
                           kTouchId2, tes.Now());
     DispatchEventUsingWindowDispatcher(&press2);
 
-    tes.SendScrollEvent(dispatcher(), 130, 230, kTouchId1, delegate.get());
+    tes.SendScrollEvent(event_processor(), 130, 230, 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),
                            kTouchId2, tes.LeapForward(50));
 
     DispatchEventUsingWindowDispatcher(&release);
@@ skipping 10 matching lines @@
     delegate->Reset();
     ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                           kTouchId1, tes.Now());
     DispatchEventUsingWindowDispatcher(&press1);
 
     delegate->Reset();
     ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
                           kTouchId2, tes.Now());
     DispatchEventUsingWindowDispatcher(&press2);
 
-    tes.SendScrollEvent(dispatcher(), 101, 230, kTouchId2, delegate.get());
+    tes.SendScrollEvent(event_processor(), 101, 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),
                            kTouchId1, tes.LeapForward(50));
 
     DispatchEventUsingWindowDispatcher(&release);
@@ skipping 12 matching lines @@
   TimedEvents tes;
 
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
-  tes.SendScrollEvent(dispatcher(), 130, 230, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get());
 
   delegate->Reset();
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
 
   EXPECT_TRUE(delegate->pinch_begin());
 
   // Make sure there is enough delay before the touch is released so that it
   // is recognized as a tap.
@@ skipping 195 matching lines @@
   DispatchEventUsingWindowDispatcher(&press2);
   window->Hide();
   EXPECT_EQ(NULL,
       ui::GestureRecognizer::Get()->GetTouchLockedTarget(press1));
   EXPECT_EQ(NULL,
       ui::GestureRecognizer::Get()->GetTouchLockedTarget(press2));
 }
 
 TEST_F(GestureRecognizerTest, LongPressTimerStopsOnPreventDefaultedTouchMoves) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
-      new QueueTouchEventDelegate(dispatcher()));
+      new QueueTouchEventDelegate(host()->dispatcher()));
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
   TimedEvents tes;
 
   TimerTestGestureRecognizer* gesture_recognizer =
       new TimerTestGestureRecognizer();
   TimerTestGestureSequence* gesture_sequence =
       static_cast<TimerTestGestureSequence*>(
           gesture_recognizer->GetGestureSequenceForTesting(window.get()));
 
   ScopedGestureRecognizerSetter gr_setter(gesture_recognizer);
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   // Scroll around, to cancel the long press
-  tes.SendScrollEvent(dispatcher(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
 
   delegate->Reset();
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_TRUE(gesture_sequence->IsTimerRunning());
 
   delegate->Reset();
   delegate->ReceivedAckPreventDefaulted();
   EXPECT_FALSE(gesture_sequence->IsTimerRunning());
   gesture_sequence->ForceTimeout();
@@ skipping 42 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(dispatcher(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Release the touch back at the start point. This should end without causing
   // a tap.
@@ skipping 22 matching lines @@
   TimedEvents tes;
 
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
-  tes.SendScrollEvent(dispatcher(), 131, 231, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_processor(), 131, 231, kTouchId1, delegate.get());
 
   // First finger touches down and moves.
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   delegate->Reset();
   // Second finger touches down and moves.
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
                         kTouchId2, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&press2);
-  tes.SendScrollEvent(dispatcher(), 161, 231, kTouchId2, delegate.get());
+  tes.SendScrollEvent(event_processor(), 161, 231, kTouchId2, delegate.get());
 
   // PinchBegin & ScrollBegin were not sent if the touch-move events were
   // consumed.
   EXPECT_FALSE(delegate->pinch_begin());
   EXPECT_FALSE(delegate->scroll_begin());
 
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->two_finger_tap());
 
   // Should be no PinchUpdate & ScrollUpdate.
   EXPECT_FALSE(delegate->pinch_update());
   EXPECT_FALSE(delegate->pinch_end());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   delegate->Reset();
   // Moves First finger again, no PinchUpdate & ScrollUpdate.
-  tes.SendScrollEvent(dispatcher(), 161, 261, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_processor(), 161, 261, kTouchId1, delegate.get());
 
   EXPECT_FALSE(delegate->pinch_update());
   EXPECT_FALSE(delegate->pinch_end());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Stops consuming touch-move.
   delegate->set_consume_touch_move(false);
 
   delegate->Reset();
   // Making a pinch gesture.
-  tes.SendScrollEvent(dispatcher(), 161, 251, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_processor(), 161, 251, kTouchId1, delegate.get());
   // If touch moves are ever consumed, we should not see PinchBegin/Update
   // even touch moves become not consumed.
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_FALSE(delegate->pinch_begin());
   EXPECT_FALSE(delegate->pinch_update());
   EXPECT_FALSE(delegate->pinch_end());
 
   delegate->Reset();
-  tes.SendScrollEvent(dispatcher(), 161, 241, kTouchId2, delegate.get());
+  tes.SendScrollEvent(event_processor(), 161, 241, kTouchId2, delegate.get());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_FALSE(delegate->pinch_begin());
   EXPECT_FALSE(delegate->pinch_update());
   EXPECT_FALSE(delegate->pinch_end());
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
@@ skipping 40 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(dispatcher(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Now, stop consuming touch-move events, and move the touch-point again.
   delegate->set_consume_touch_move(false);
-  tes.SendScrollEvent(dispatcher(), 159, 259, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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_update());
   EXPECT_FALSE(delegate->scroll_end());
   // No scroll has occurred, because an early touch move was consumed.
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(0, 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(dispatcher(), 110, 211, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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(dispatcher(), 140, 215, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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 320 matching lines @@
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                        kTouchId, tes.Now());
 
   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, the scroll should not
   // start.
-  tes.SendScrollEvent(dispatcher(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 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_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 }
 
 TEST_F(GestureRecognizerTest,
@@ skipping 108 matching lines @@
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                         kTouchId, tes.Now());
   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(dispatcher(), 130, 230, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
   // Wait until the timer runs out
   gesture_sequence->ForceTimeout();
   EXPECT_FALSE(delegate->show_press());
   EXPECT_TRUE(delegate->tap_cancel());
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                           kTouchId, tes.LeapForward(10));
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->show_press());
@@ skipping 28 matching lines @@
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_TRUE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->tap());
 }
 
 // Test that consuming the first move touch event prevents a scroll.
 TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveScrollTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
-      new QueueTouchEventDelegate(dispatcher()));
+      new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   delegate->ReceivedAck();
 
   ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(2, 2),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   delegate->ReceivedAckPreventDefaulted();
 
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(20, 20),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   delegate->ReceivedAck();
 
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
 }
 
 // Test that consuming the first touch move event of a touch point doesn't
 // prevent pinching once an additional touch has been pressed.
 TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMovePinchTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
-      new QueueTouchEventDelegate(dispatcher()));
+      new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId1 = 7;
   const int kTouchId2 = 4;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
@@ skipping 36 matching lines @@
   delegate->ReceivedAck();
 
   EXPECT_TRUE(delegate->pinch_update());
   EXPECT_EQ(10, delegate->scroll_x());
   EXPECT_EQ(10, delegate->scroll_y());
 }
 
 // Test that consuming the first move touch doesn't prevent a tap.
 TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveTapTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
-      new QueueTouchEventDelegate(dispatcher()));
+      new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   delegate->ReceivedAck();
 
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(2, 2),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->ReceivedAckPreventDefaulted();
 
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(2, 2),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   delegate->ReceivedAck();
 
   EXPECT_TRUE(delegate->tap());
 }
 
 // Test that consuming the first move touch doesn't prevent a long press.
 TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveLongPressTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
-      new QueueTouchEventDelegate(dispatcher()));
+      new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
 
@@ skipping 72 matching lines @@
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(1, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_x_hint());
   delegate->Reset();
 
 }
 
 TEST_F(GestureRecognizerTest, ScrollAlternatelyConsumedTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
-      new QueueTouchEventDelegate(dispatcher()));
+      new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 3000;
   const int kWindowHeight = 3000;
   const int kTouchId = 2;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
 
@@ skipping 36 matching lines @@
     DispatchEventUsingWindowDispatcher(&move3);
     delegate->ReceivedAckPreventDefaulted();
     EXPECT_FALSE(delegate->scroll_begin());
     EXPECT_FALSE(delegate->scroll_update());
     delegate->Reset();
   }
 }
 
 }  // namespace test
 }  // namespace aura