[Android] Out with the Android GR, in with the new unified C++ GR

ui/events/gesture_detection/gesture_provider_unittest.cc

 // Copyright 2014 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/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/events/gesture_detection/gesture_event_params.h"
+#include "ui/events/gesture_detection/gesture_event_data.h"
 #include "ui/events/gesture_detection/gesture_provider.h"
 #include "ui/events/gesture_detection/mock_motion_event.h"
 #include "ui/events/gesture_detection/motion_event.h"
 #include "ui/gfx/geometry/point_f.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace ui {
 namespace {
@@ skipping 27 matching lines @@
   }
 
   static MockMotionEvent ObtainMotionEvent(base::TimeTicks event_time,
                                            MotionEvent::Action action) {
     return ObtainMotionEvent(event_time, action, kFakeCoordX, kFakeCoordY);
   }
 
   // Test
   virtual void SetUp() OVERRIDE {
     gesture_provider_.reset(new GestureProvider(GetDefaultConfig(), this));
-    gesture_provider_->UpdateMultiTouchSupport(false);
+    gesture_provider_->SetMultiTouchSupportEnabled(false);
   }
 
   virtual void TearDown() OVERRIDE {
     gestures_.clear();
     gesture_provider_.reset();
   }
 
   // GestureProviderClient
-  virtual void OnGestureEvent(const GestureEventParams& gesture) OVERRIDE {
+  virtual void OnGestureEvent(const GestureEventData& gesture) OVERRIDE {
     if (gesture.type == GESTURE_SCROLL_BEGIN)
-      active_scroll_begin_event_.reset(new GestureEventParams(gesture));
+      active_scroll_begin_event_.reset(new GestureEventData(gesture));
     gestures_.push_back(gesture);
   }
 
   bool HasReceivedGesture(GestureEventType type) const {
     for (size_t i = 0; i < gestures_.size(); ++i) {
       if (gestures_[i].type == type)
         return true;
     }
     return false;
   }
 
-  const GestureEventParams& GetMostRecentGestureEvent() const {
+  const GestureEventData& GetMostRecentGestureEvent() const {
     EXPECT_FALSE(gestures_.empty());
     return gestures_.back();
   }
 
   const GestureEventType GetMostRecentGestureEventType() const {
     EXPECT_FALSE(gestures_.empty());
     return gestures_.back().type;
   }
 
   size_t GetReceivedGestureCount() const { return gestures_.size(); }
 
-  const GestureEventParams& GetReceivedGesture(size_t index) const {
+  const GestureEventData& GetReceivedGesture(size_t index) const {
     EXPECT_LT(index, GetReceivedGestureCount());
     return gestures_[index];
   }
 
-  const GestureEventParams* GetActiveScrollBeginEvent() const {
+  const GestureEventData* GetActiveScrollBeginEvent() const {
     return active_scroll_begin_event_ ? active_scroll_begin_event_.get() : NULL;
   }
 
   const GestureProvider::Config& GetDefaultConfig() const {
     static GestureProvider::Config sConfig;
     return sConfig;
   }
 
   int GetTouchSlop() const {
     return GetDefaultConfig().gesture_detector_config.scaled_touch_slop;
@@ skipping 43 matching lines @@
     EXPECT_TRUE(HasReceivedGesture(GESTURE_SCROLL_END));
     EXPECT_EQ(GESTURE_SCROLL_END, GetMostRecentGestureEventType());
   }
 
   static void Wait(base::TimeDelta delay) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::MessageLoop::QuitClosure(), delay);
     base::MessageLoop::current()->Run();
   }
 
-  std::vector<GestureEventParams> gestures_;
+  std::vector<GestureEventData> gestures_;
   scoped_ptr<GestureProvider> gesture_provider_;
-  scoped_ptr<GestureEventParams> active_scroll_begin_event_;
+  scoped_ptr<GestureEventData> active_scroll_begin_event_;
   base::MessageLoopForUI message_loop_;
 };
 
 // Verify that a DOWN followed shortly by an UP will trigger a single tap.
-TEST_F(GestureProviderTest, GestureSingleTap) {
+TEST_F(GestureProviderTest, GestureTapTap) {
   base::TimeTicks event_time = base::TimeTicks::Now();
 
-  gesture_provider_->UpdateDoubleTapSupportForPlatform(false);
+  gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 2,
                             MotionEvent::ACTION_UP);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
-  EXPECT_EQ(GESTURE_SINGLE_TAP_CONFIRMED, GetMostRecentGestureEventType());
+  EXPECT_EQ(GESTURE_TAP, GetMostRecentGestureEventType());
 }
 
 // Verify that a DOWN followed shortly by an UP will trigger
-// a GESTURE_SINGLE_TAP_UNCONFIRMED event if double-tap is enabled.
-TEST_F(GestureProviderTest, GestureSingleTapWithDelay) {
+// a GESTURE_TAP_UNCONFIRMED event if double-tap is enabled.
+TEST_F(GestureProviderTest, GestureTapTapWithDelay) {
   base::TimeTicks event_time = base::TimeTicks::Now();
 
-  gesture_provider_->UpdateDoubleTapSupportForPlatform(true);
+  gesture_provider_->SetDoubleTapSupportForPlatformEnabled(true);
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 2,
                             MotionEvent::ACTION_UP);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
-  EXPECT_EQ(GESTURE_SINGLE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
-  EXPECT_FALSE(HasReceivedGesture(GESTURE_SINGLE_TAP_CONFIRMED));
+  EXPECT_EQ(GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
+  EXPECT_FALSE(HasReceivedGesture(GESTURE_TAP));
 }
 
 // Verify that a DOWN followed by a MOVE will trigger fling (but not LONG).
 TEST_F(GestureProviderTest, GestureFlingAndCancelLongPress) {
   base::TimeTicks event_time = TimeTicks::Now();
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
@@ skipping 48 matching lines @@
                             kFakeCoordY * 5);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(gesture_provider_->IsScrollInProgress());
   EXPECT_TRUE(HasReceivedGesture(GESTURE_SCROLL_BEGIN));
   EXPECT_EQ(GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
   ASSERT_EQ(4U, GetReceivedGestureCount());
   ASSERT_EQ(GESTURE_SCROLL_BEGIN, GetReceivedGesture(2).type);
 
   // We don't want to take a dependency here on exactly how hints are calculated
   // for a fling (eg. may depend on velocity), so just validate the direction.
-  int hint_x = GetReceivedGesture(2).data.scroll_begin.delta_x_hint;
-  int hint_y = GetReceivedGesture(2).data.scroll_begin.delta_y_hint;
+  int hint_x = GetReceivedGesture(2).details.scroll_begin.delta_x_hint;
+  int hint_y = GetReceivedGesture(2).details.scroll_begin.delta_y_hint;
   EXPECT_TRUE(hint_x > 0 && hint_y > 0 && hint_x > hint_y)
       << "ScrollBegin hint should be in positive X axis";
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 3,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX * 10,
                             kFakeCoordY * 10);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_FALSE(gesture_provider_->IsScrollInProgress());
   EXPECT_EQ(GESTURE_FLING_START, GetMostRecentGestureEventType());
@@ skipping 56 matching lines @@
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX,
                             kFakeCoordY);
   gesture_provider_->OnTouchEvent(event);
-  EXPECT_EQ(GESTURE_SINGLE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
+  EXPECT_EQ(GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 2,
                             MotionEvent::ACTION_DOWN,
                             kFakeCoordX,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 
   // Moving a very small amount of distance should not trigger the double tap
   // drag zoom mode.
@@ skipping 18 matching lines @@
 
   MockMotionEvent event =
       ObtainMotionEvent(down_time_1, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(down_time_1 + kFiveMilliseconds,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX,
                             kFakeCoordY);
   gesture_provider_->OnTouchEvent(event);
-  EXPECT_EQ(GESTURE_SINGLE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
+  EXPECT_EQ(GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(
       down_time_2, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(down_time_2 + kFiveMilliseconds,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX,
                             kFakeCoordY + 100);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(HasReceivedGesture(GESTURE_SCROLL_BEGIN));
-  const GestureEventParams* scroll_begin_gesture = GetActiveScrollBeginEvent();
+  const GestureEventData* scroll_begin_gesture = GetActiveScrollBeginEvent();
   ASSERT_TRUE(!!scroll_begin_gesture);
-  EXPECT_EQ(0, scroll_begin_gesture->data.scroll_begin.delta_x_hint);
-  EXPECT_EQ(100, scroll_begin_gesture->data.scroll_begin.delta_y_hint);
+  EXPECT_EQ(0, scroll_begin_gesture->details.scroll_begin.delta_x_hint);
+  EXPECT_EQ(100, scroll_begin_gesture->details.scroll_begin.delta_y_hint);
   EXPECT_EQ(GESTURE_PINCH_BEGIN, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(down_time_2 + kFiveMilliseconds * 2,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX,
                             kFakeCoordY + 200);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(HasReceivedGesture(GESTURE_SCROLL_UPDATE));
   EXPECT_EQ(GESTURE_PINCH_UPDATE, GetMostRecentGestureEventType());
 
@@ skipping 11 matching lines @@
   const base::TimeTicks down_time_2 = down_time_1 + kFiveMilliseconds * 20;
 
   MockMotionEvent event =
       ObtainMotionEvent(down_time_1, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(down_time_1 + kFiveMilliseconds,
                             MotionEvent::ACTION_UP);
   gesture_provider_->OnTouchEvent(event);
-  EXPECT_EQ(GESTURE_SINGLE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
+  EXPECT_EQ(GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(down_time_2, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
   EXPECT_TRUE(HasReceivedGesture(GESTURE_TAP_CANCEL));
 
   event = ObtainMotionEvent(down_time_2 + kFiveMilliseconds * 10,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX,
                             kFakeCoordY - 30);
@@ skipping 41 matching lines @@
                             kFakeCoordX - delta_x / 2,
                             kFakeCoordY - delta_y / 2);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 2,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX - delta_x,
                             kFakeCoordY - delta_y);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
-  // Make sure the reported gesture event has all the expected data.
+  // Make sure the reported gesture event has all the expected details.
   ASSERT_LT(0U, GetReceivedGestureCount());
-  GestureEventParams gesture = GetMostRecentGestureEvent();
+  GestureEventData gesture = GetMostRecentGestureEvent();
   EXPECT_EQ(GESTURE_SCROLL_UPDATE, gesture.type);
   EXPECT_EQ(event_time + kFiveMilliseconds * 2, gesture.time);
   EXPECT_EQ(kFakeCoordX - delta_x, gesture.x);
   EXPECT_EQ(kFakeCoordY - delta_y, gesture.y);
 
   // No horizontal delta because of snapping.
-  EXPECT_EQ(0, gesture.data.scroll_update.delta_x);
-  EXPECT_EQ(-delta_y / 2, gesture.data.scroll_update.delta_y);
+  EXPECT_EQ(0, gesture.details.scroll_update.delta_x);
+  EXPECT_EQ(-delta_y / 2, gesture.details.scroll_update.delta_y);
 }
 
 // Generate a scroll gesture and verify that the resulting scroll begin event
 // has the expected hint values.
 TEST_F(GestureProviderTest, ScrollBeginValues) {
   const int delta_x = 13;
   const int delta_y = 89;
 
   const base::TimeTicks event_time = TimeTicks::Now();
 
@@ skipping 10 matching lines @@
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_FALSE(gesture_provider_->IsScrollInProgress());
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 2,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX + delta_x,
                             kFakeCoordY + delta_y);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(gesture_provider_->IsScrollInProgress());
 
-  const GestureEventParams* scroll_begin_gesture = GetActiveScrollBeginEvent();
+  const GestureEventData* scroll_begin_gesture = GetActiveScrollBeginEvent();
   ASSERT_TRUE(!!scroll_begin_gesture);
-  EXPECT_EQ(delta_x, scroll_begin_gesture->data.scroll_begin.delta_x_hint);
-  EXPECT_EQ(delta_y, scroll_begin_gesture->data.scroll_begin.delta_y_hint);
+  EXPECT_EQ(delta_x, scroll_begin_gesture->details.scroll_begin.delta_x_hint);
+  EXPECT_EQ(delta_y, scroll_begin_gesture->details.scroll_begin.delta_y_hint);
 }
 
 TEST_F(GestureProviderTest, LongPressAndTapCancelledWhenScrollBegins) {
   base::TimeTicks event_time = base::TimeTicks::Now();
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   event = ObtainMotionEvent(event_time + kFiveMilliseconds,
                             MotionEvent::ACTION_MOVE,
@@ skipping 67 matching lines @@
 
   MockMotionEvent event = ObtainMotionEvent(
       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX,
                             kFakeCoordY);
   gesture_provider_->OnTouchEvent(event);
-  EXPECT_EQ(GESTURE_SINGLE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
+  EXPECT_EQ(GESTURE_TAP_UNCONFIRMED, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 2,
                             MotionEvent::ACTION_DOWN,
                             kFakeCoordX,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
   EXPECT_TRUE(gesture_provider_->IsDoubleTapInProgress());
 
   const base::TimeDelta long_press_timeout =
@@ skipping 30 matching lines @@
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 2,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX,
                             kFakeCoordY + scaled_touch_slop + scroll_delta);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   EXPECT_EQ(GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
-  GestureEventParams gesture = GetMostRecentGestureEvent();
-  EXPECT_EQ(0, gesture.data.scroll_update.delta_x);
-  EXPECT_EQ(scroll_delta, gesture.data.scroll_update.delta_y);
+  GestureEventData gesture = GetMostRecentGestureEvent();
+  EXPECT_EQ(0, gesture.details.scroll_update.delta_x);
+  EXPECT_EQ(scroll_delta, gesture.details.scroll_update.delta_y);
 }
 
 TEST_F(GestureProviderTest, NoDoubleTapWhenExplicitlyDisabled) {
-  gesture_provider_->UpdateDoubleTapSupportForPlatform(false);
+  gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
 
   base::TimeTicks event_time = base::TimeTicks::Now();
   MockMotionEvent event = ObtainMotionEvent(
       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(1U, GetReceivedGestureCount());
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
-  EXPECT_EQ(GESTURE_SINGLE_TAP_CONFIRMED, GetMostRecentGestureEventType());
+  EXPECT_EQ(GESTURE_TAP, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 2,
                             MotionEvent::ACTION_DOWN,
                             kFakeCoordX,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 3,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
-  EXPECT_EQ(GESTURE_SINGLE_TAP_CONFIRMED, GetMostRecentGestureEventType());
+  EXPECT_EQ(GESTURE_TAP, GetMostRecentGestureEventType());
 }
 
 TEST_F(GestureProviderTest, NoDoubleTapDragZoomWhenDisabledOnPlatform) {
   const base::TimeTicks down_time_1 = TimeTicks::Now();
   const base::TimeTicks down_time_2 = down_time_1 + kFiveMilliseconds * 20;
 
-  gesture_provider_->UpdateDoubleTapSupportForPlatform(false);
+  gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
 
   MockMotionEvent event =
       ObtainMotionEvent(down_time_1, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(down_time_1 + kFiveMilliseconds,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX,
                             kFakeCoordY);
   gesture_provider_->OnTouchEvent(event);
@@ skipping 30 matching lines @@
   EXPECT_FALSE(HasReceivedGesture(GESTURE_PINCH_END));
 }
 
 // Verify that double tap drag zoom feature is not invoked when the gesture
 // handler is told to disable double tap gesture detection.
 // The second tap sequence should be treated just as the first would be.
 TEST_F(GestureProviderTest, NoDoubleTapDragZoomWhenDisabledOnPage) {
   const base::TimeTicks down_time_1 = TimeTicks::Now();
   const base::TimeTicks down_time_2 = down_time_1 + kFiveMilliseconds * 20;
 
-  gesture_provider_->UpdateDoubleTapSupportForPage(false);
+  gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
 
   MockMotionEvent event =
       ObtainMotionEvent(down_time_1, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(down_time_1 + kFiveMilliseconds,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX,
                             kFakeCoordY);
   gesture_provider_->OnTouchEvent(event);
@@ skipping 49 matching lines @@
   event = ObtainMotionEvent(down_time_2 + kFiveMilliseconds,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX,
                             kFakeCoordY + 100);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(HasReceivedGesture(GESTURE_SCROLL_BEGIN));
   EXPECT_EQ(GESTURE_PINCH_BEGIN, GetMostRecentGestureEventType());
 
   // Simulate setting a fixed page scale (or a mobile viewport);
   // this should not disrupt the current double-tap gesture.
-  gesture_provider_->UpdateDoubleTapSupportForPage(false);
+  gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
 
   // Double tap zoom updates should continue.
   event = ObtainMotionEvent(down_time_2 + kFiveMilliseconds * 2,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX,
                             kFakeCoordY + 200);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(HasReceivedGesture(GESTURE_SCROLL_UPDATE));
   EXPECT_EQ(GESTURE_PINCH_UPDATE, GetMostRecentGestureEventType());
   event = ObtainMotionEvent(down_time_2 + kFiveMilliseconds * 3,
@@ skipping 44 matching lines @@
                             kFakeCoordY + 200);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_FALSE(HasReceivedGesture(GESTURE_PINCH_END));
 }
 
 // Verify that pinch zoom sends the proper event sequence.
 TEST_F(GestureProviderTest, PinchZoom) {
   base::TimeTicks event_time = base::TimeTicks::Now();
   const int scaled_touch_slop = GetTouchSlop();
 
-  gesture_provider_->UpdateMultiTouchSupport(true);
+  gesture_provider_->SetMultiTouchSupportEnabled(true);
 
   int secondary_coord_x = kFakeCoordX + 20 * scaled_touch_slop;
   int secondary_coord_y = kFakeCoordY + 20 * scaled_touch_slop;
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(event_time,
@@ skipping 85 matching lines @@
                             MotionEvent::ACTION_UP);
   EXPECT_FALSE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 3,
                             MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 }
 
 }  // namespace ui