Enable pinch-zoom telemetry on Mac

content/browser/renderer_host/input/synthetic_gesture_controller_unittest.cc

 // Copyright 2013 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/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "content/browser/renderer_host/input/synthetic_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_controller.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target.h"
 #include "content/browser/renderer_host/input/synthetic_pinch_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_smooth_drag_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_smooth_move_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_smooth_scroll_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_tap_gesture.h"
+#include "content/browser/renderer_host/input/synthetic_touchpad_pinch_gesture.h"
+#include "content/browser/renderer_host/input/synthetic_touchscreen_pinch_gesture.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
 #include "content/common/input/synthetic_smooth_drag_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/common/input/synthetic_tap_gesture_params.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/test/test_render_view_host.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
@@ skipping 185 matching lines @@
         start_to_end_distance_ = mouse_point - start_;
       last_mouse_point_ = mouse_point;
     }
   }
 
  private:
   bool started_;
   gfx::PointF start_, last_mouse_point_;
 };
 
-class MockSyntheticPinchTouchTarget : public MockSyntheticGestureTarget {
+class MockSyntheticTouchscreenPinchTouchTarget
+    : public MockSyntheticGestureTarget {
  public:
   enum ZoomDirection {
     ZOOM_DIRECTION_UNKNOWN,
     ZOOM_IN,
     ZOOM_OUT
   };
 
-  MockSyntheticPinchTouchTarget()
+  MockSyntheticTouchscreenPinchTouchTarget()
       : initial_pointer_distance_(0),
         last_pointer_distance_(0),
         zoom_direction_(ZOOM_DIRECTION_UNKNOWN),
         started_(false) {}
-  ~MockSyntheticPinchTouchTarget() override {}
+  ~MockSyntheticTouchscreenPinchTouchTarget() override {}
 
   void DispatchInputEventToPlatform(const WebInputEvent& event) override {
     ASSERT_TRUE(WebInputEvent::isTouchEventType(event.type));
     const WebTouchEvent& touch_event = static_cast<const WebTouchEvent&>(event);
     ASSERT_EQ(touch_event.touchesLength, 2U);
 
     if (!started_) {
       ASSERT_EQ(touch_event.type, WebInputEvent::TouchStart);
 
       start_0_ = gfx::PointF(touch_event.touches[0].position);
@@ skipping 19 matching lines @@
         else
           EXPECT_EQ(
               zoom_direction_,
               ComputeZoomDirection(last_pointer_distance_, pointer_distance));
       }
 
       last_pointer_distance_ = pointer_distance;
     }
   }
 
+  SyntheticGestureParams::GestureSourceType
+  GetDefaultSyntheticGestureSourceType() const override {
+    return SyntheticGestureParams::TOUCH_INPUT;
+  }
+
   ZoomDirection zoom_direction() const { return zoom_direction_; }
 
   float ComputeScaleFactor() const {
     switch (zoom_direction_) {
       case ZOOM_IN:
         return last_pointer_distance_ /
                (initial_pointer_distance_ + 2 * GetTouchSlopInDips());
       case ZOOM_OUT:
         return last_pointer_distance_ /
                (initial_pointer_distance_ - 2 * GetTouchSlopInDips());
@@ skipping 14 matching lines @@
   }
 
   float initial_pointer_distance_;
   float last_pointer_distance_;
   ZoomDirection zoom_direction_;
   gfx::PointF start_0_;
   gfx::PointF start_1_;
   bool started_;
 };
 
+class MockSyntheticTouchpadPinchTouchTarget
+    : public MockSyntheticGestureTarget {
+ public:
+  enum ZoomDirection { ZOOM_DIRECTION_UNKNOWN, ZOOM_IN, ZOOM_OUT };
+
+  MockSyntheticTouchpadPinchTouchTarget()
+      : zoom_direction_(ZOOM_DIRECTION_UNKNOWN),
+        started_(false),
+        ended_(false),
+        scale_factor_(1.0f) {}
+  ~MockSyntheticTouchpadPinchTouchTarget() override {}
+
+  void DispatchInputEventToPlatform(const WebInputEvent& event) override {
+    EXPECT_TRUE(WebInputEvent::isGestureEventType(event.type));
+    const blink::WebGestureEvent& gesture_event =
+        static_cast<const blink::WebGestureEvent&>(event);
+
+    if (gesture_event.type == WebInputEvent::GesturePinchBegin) {
+      EXPECT_FALSE(started_);
+      EXPECT_FALSE(ended_);
+      started_ = true;
+    } else if (gesture_event.type == WebInputEvent::GesturePinchEnd) {
+      EXPECT_TRUE(started_);
+      EXPECT_FALSE(ended_);
+      ended_ = true;
+    } else {
+      EXPECT_EQ(WebInputEvent::GesturePinchUpdate, gesture_event.type);
+      EXPECT_TRUE(started_);
+      EXPECT_FALSE(ended_);
+      const float scale = gesture_event.data.pinchUpdate.scale;
+      if (scale != 1.0f) {
+        if (zoom_direction_ == ZOOM_DIRECTION_UNKNOWN) {
+          zoom_direction_ = scale > 1.0f ? ZOOM_IN : ZOOM_OUT;
+        } else if (zoom_direction_ == ZOOM_IN) {
+          EXPECT_GT(scale, 1.0f);
+        } else {
+          EXPECT_EQ(ZOOM_OUT, zoom_direction_);
+          EXPECT_LT(scale, 1.0f);
+        }
+
+        scale_factor_ *= scale;
+      }
+    }
+  }
+
+  SyntheticGestureParams::GestureSourceType
+  GetDefaultSyntheticGestureSourceType() const override {
+    return SyntheticGestureParams::MOUSE_INPUT;
+  }
+
+  ZoomDirection zoom_direction() const { return zoom_direction_; }
+
+  float scale_factor() const { return scale_factor_; }
+
+ private:
+  ZoomDirection zoom_direction_;
+  bool started_;
+  bool ended_;
+  float scale_factor_;
+};
+
 class MockSyntheticTapGestureTarget : public MockSyntheticGestureTarget {
  public:
   MockSyntheticTapGestureTarget() : state_(NOT_STARTED) {}
   ~MockSyntheticTapGestureTarget() override {}
 
   bool GestureFinished() const { return state_ == FINISHED; }
   gfx::PointF position() const { return position_; }
   base::TimeDelta GetDuration() const { return stop_time_ - start_time_; }
 
  protected:
@@ skipping 775 matching lines @@
   params.anchor.SetPoint(432, 89);
   params.distances.push_back(gfx::Vector2d(0, -234));
   params.speed_in_pixels_s = 800;
 
   scoped_ptr<SyntheticSmoothScrollGesture> gesture(
       new SyntheticSmoothScrollGesture(params));
   const base::TimeTicks timestamp;
   gesture->ForwardInputEvents(timestamp, target_);
 }
 
-TEST_F(SyntheticGestureControllerTest, PinchGestureTouchZoomIn) {
-  CreateControllerAndTarget<MockSyntheticPinchTouchTarget>();
+TEST_F(SyntheticGestureControllerTest,
+       TouchscreenTouchpadPinchGestureTouchZoomIn) {
+  CreateControllerAndTarget<MockSyntheticTouchscreenPinchTouchTarget>();
+
+  SyntheticPinchGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  params.scale_factor = 2.3f;
+  params.anchor.SetPoint(54, 89);
+
+  scoped_ptr<SyntheticTouchscreenPinchGesture> gesture(
+      new SyntheticTouchscreenPinchGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockSyntheticTouchscreenPinchTouchTarget* pinch_target =
+      static_cast<MockSyntheticTouchscreenPinchTouchTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(pinch_target->zoom_direction(),
+            MockSyntheticTouchscreenPinchTouchTarget::ZOOM_IN);
+  EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
+}
+
+TEST_F(SyntheticGestureControllerTest,
+       TouchscreenTouchpadPinchGestureTouchZoomOut) {
+  CreateControllerAndTarget<MockSyntheticTouchscreenPinchTouchTarget>();
+
+  SyntheticPinchGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  params.scale_factor = 0.4f;
+  params.anchor.SetPoint(-12, 93);
+
+  scoped_ptr<SyntheticTouchscreenPinchGesture> gesture(
+      new SyntheticTouchscreenPinchGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockSyntheticTouchscreenPinchTouchTarget* pinch_target =
+      static_cast<MockSyntheticTouchscreenPinchTouchTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(pinch_target->zoom_direction(),
+            MockSyntheticTouchscreenPinchTouchTarget::ZOOM_OUT);
+  EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
+}
+
+TEST_F(SyntheticGestureControllerTest,
+       TouchscreenTouchpadPinchGestureTouchNoScaling) {
+  CreateControllerAndTarget<MockSyntheticTouchscreenPinchTouchTarget>();
+
+  SyntheticPinchGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  params.scale_factor = 1.0f;
+
+  scoped_ptr<SyntheticTouchscreenPinchGesture> gesture(
+      new SyntheticTouchscreenPinchGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockSyntheticTouchscreenPinchTouchTarget* pinch_target =
+      static_cast<MockSyntheticTouchscreenPinchTouchTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(pinch_target->zoom_direction(),
+            MockSyntheticTouchscreenPinchTouchTarget::ZOOM_DIRECTION_UNKNOWN);
+  EXPECT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
+}
+
+TEST_F(SyntheticGestureControllerTest, TouchpadPinchGestureTouchZoomIn) {
+  CreateControllerAndTarget<MockSyntheticTouchpadPinchTouchTarget>();
+
+  SyntheticPinchGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
+  params.scale_factor = 2.3f;
+  params.anchor.SetPoint(54, 89);
+
+  scoped_ptr<SyntheticTouchpadPinchGesture> gesture(
+      new SyntheticTouchpadPinchGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockSyntheticTouchpadPinchTouchTarget* pinch_target =
+      static_cast<MockSyntheticTouchpadPinchTouchTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(pinch_target->zoom_direction(),
+            MockSyntheticTouchpadPinchTouchTarget::ZOOM_IN);
+  EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->scale_factor());
+}
+
+TEST_F(SyntheticGestureControllerTest, TouchpadPinchGestureTouchZoomOut) {
+  CreateControllerAndTarget<MockSyntheticTouchpadPinchTouchTarget>();
+
+  SyntheticPinchGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
+  params.scale_factor = 0.4f;
+  params.anchor.SetPoint(-12, 93);
+
+  scoped_ptr<SyntheticTouchpadPinchGesture> gesture(
+      new SyntheticTouchpadPinchGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockSyntheticTouchpadPinchTouchTarget* pinch_target =
+      static_cast<MockSyntheticTouchpadPinchTouchTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(pinch_target->zoom_direction(),
+            MockSyntheticTouchpadPinchTouchTarget::ZOOM_OUT);
+  EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->scale_factor());
+}
+
+TEST_F(SyntheticGestureControllerTest, TouchpadPinchGestureTouchNoScaling) {
+  CreateControllerAndTarget<MockSyntheticTouchpadPinchTouchTarget>();
+
+  SyntheticPinchGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
+  params.scale_factor = 1.0f;
+
+  scoped_ptr<SyntheticTouchpadPinchGesture> gesture(
+      new SyntheticTouchpadPinchGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
+
+  MockSyntheticTouchpadPinchTouchTarget* pinch_target =
+      static_cast<MockSyntheticTouchpadPinchTouchTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(pinch_target->zoom_direction(),
+            MockSyntheticTouchpadPinchTouchTarget::ZOOM_DIRECTION_UNKNOWN);
+  EXPECT_EQ(params.scale_factor, pinch_target->scale_factor());
+}
+
+// Ensure that if SyntheticPinchGesture is instantiated with TOUCH_INPUT it
+// correctly creates a touchscreen gesture.
+TEST_F(SyntheticGestureControllerTest, PinchGestureExplicitTouch) {
+  CreateControllerAndTarget<MockSyntheticTouchscreenPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;

[jdduke (slow), 2015/09/22 21:58:49]

What are we validating in these 4 tests? I guess we validate the touch vs
gesture output in the targets?

[ericrk, 2015/09/22 22:08:49]

The targets will fail if they receive the wrong events (touch vs pinch gesture)
- does this seem OK? Or should i find a way to be more explicit?

   params.scale_factor = 2.3f;
   params.anchor.SetPoint(54, 89);
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
-
-  MockSyntheticPinchTouchTarget* pinch_target =
-      static_cast<MockSyntheticPinchTouchTarget*>(target_);
-  EXPECT_EQ(1, num_success_);
-  EXPECT_EQ(0, num_failure_);
-  EXPECT_EQ(pinch_target->zoom_direction(),
-            MockSyntheticPinchTouchTarget::ZOOM_IN);
-  EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
 }
 
-TEST_F(SyntheticGestureControllerTest, PinchGestureTouchZoomOut) {
-  CreateControllerAndTarget<MockSyntheticPinchTouchTarget>();
+// Ensure that if SyntheticPinchGesture is instantiated with MOUSE_INPUT it
+// correctly creates a touchpad gesture.
+TEST_F(SyntheticGestureControllerTest, PinchGestureExplicitMouse) {
+  CreateControllerAndTarget<MockSyntheticTouchpadPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.scale_factor = 0.4f;
-  params.anchor.SetPoint(-12, 93);
+  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
+  params.scale_factor = 2.3f;
+  params.anchor.SetPoint(54, 89);
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
-
-  MockSyntheticPinchTouchTarget* pinch_target =
-      static_cast<MockSyntheticPinchTouchTarget*>(target_);
-  EXPECT_EQ(1, num_success_);
-  EXPECT_EQ(0, num_failure_);
-  EXPECT_EQ(pinch_target->zoom_direction(),
-            MockSyntheticPinchTouchTarget::ZOOM_OUT);
-  EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
 }
 
-TEST_F(SyntheticGestureControllerTest, PinchGestureTouchNoScaling) {
-  CreateControllerAndTarget<MockSyntheticPinchTouchTarget>();
+// Ensure that if SyntheticPinchGesture is instantiated with DEFAULT_INPUT it
+// correctly creates a touchscreen gesture for a touchscreen controller.
+TEST_F(SyntheticGestureControllerTest, PinchGestureDefaultTouch) {
+  CreateControllerAndTarget<MockSyntheticTouchscreenPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.scale_factor = 1.0f;
+  params.gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
+  params.scale_factor = 2.3f;
+  params.anchor.SetPoint(54, 89);
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
   QueueSyntheticGesture(gesture.Pass());
   FlushInputUntilComplete();
+}
 
-  MockSyntheticPinchTouchTarget* pinch_target =
-      static_cast<MockSyntheticPinchTouchTarget*>(target_);
-  EXPECT_EQ(1, num_success_);
-  EXPECT_EQ(0, num_failure_);
-  EXPECT_EQ(pinch_target->zoom_direction(),
-            MockSyntheticPinchTouchTarget::ZOOM_DIRECTION_UNKNOWN);
-  EXPECT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
+// Ensure that if SyntheticPinchGesture is instantiated with DEFAULT_INPUT it
+// correctly creates a touchpad gesture for a touchpad controller.
+TEST_F(SyntheticGestureControllerTest, PinchGestureDefaultMouse) {
+  CreateControllerAndTarget<MockSyntheticTouchpadPinchTouchTarget>();
+
+  SyntheticPinchGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
+  params.scale_factor = 2.3f;
+  params.anchor.SetPoint(54, 89);
+
+  scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
+  QueueSyntheticGesture(gesture.Pass());
+  FlushInputUntilComplete();
 }
 
 TEST_F(SyntheticGestureControllerTest, TapGestureTouch) {
   CreateControllerAndTarget<MockSyntheticTapTouchTarget>();
 
   SyntheticTapGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   params.duration_ms = 123;
   params.position.SetPoint(87, -124);
 
@@ skipping 31 matching lines @@
   EXPECT_TRUE(tap_target->GestureFinished());
   EXPECT_EQ(tap_target->position(), params.position);
   EXPECT_EQ(tap_target->GetDuration().InMilliseconds(), params.duration_ms);
   EXPECT_GE(GetTotalTime(),
             base::TimeDelta::FromMilliseconds(params.duration_ms));
 }
 
 }  // namespace
 
 }  // namespace content