Synthetic pinch gesture take scale factor as parameter.

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"
@@ skipping 18 matching lines @@
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 
 namespace content {
 
 namespace {
 
 const int kFlushInputRateInMs = 16;
 const int kPointerAssumedStoppedTimeMs = 43;
-const int kTouchSlopInDips = 7;
+const float kTouchSlopInDips = 7.2f;
+const float kMinScalingSpanInDips = 27.5f;
 
 class MockSyntheticGesture : public SyntheticGesture {
  public:
   MockSyntheticGesture(bool* finished, int num_steps)
       : finished_(finished),
         num_steps_(num_steps),
         step_count_(0) {
     *finished_ = false;
   }
   virtual ~MockSyntheticGesture() {}
@@ skipping 40 matching lines @@
   }
 
   virtual base::TimeDelta PointerAssumedStoppedTime() const OVERRIDE {
     return base::TimeDelta::FromMilliseconds(pointer_assumed_stopped_time_ms_);
   }
 
   void set_pointer_assumed_stopped_time_ms(int time_ms) {
     pointer_assumed_stopped_time_ms_ = time_ms;
   }
 
-  virtual int GetTouchSlopInDips() const OVERRIDE {
+  virtual float GetTouchSlopInDips() const OVERRIDE {
     return kTouchSlopInDips;
   }
 
+  virtual float GetMinScalingSpanInDips() const OVERRIDE {
+    return kMinScalingSpanInDips;
+  }
+
   bool flush_requested() const { return flush_requested_; }
   void ClearFlushRequest() { flush_requested_ = false; }
 
  private:
   bool flush_requested_;
 
   int pointer_assumed_stopped_time_ms_;
 };
 
 class MockScrollGestureTarget : public MockSyntheticGestureTarget {
@@ skipping 70 matching lines @@
 
 class MockSyntheticPinchTouchTarget : public MockSyntheticGestureTarget {
  public:
   enum ZoomDirection {
     ZOOM_DIRECTION_UNKNOWN,
     ZOOM_IN,
     ZOOM_OUT
   };
 
   MockSyntheticPinchTouchTarget()
-      : total_num_pixels_covered_(0),
+      : initial_pointer_distance_(0),
         last_pointer_distance_(0),
         zoom_direction_(ZOOM_DIRECTION_UNKNOWN),
         started_(false) {}
   virtual ~MockSyntheticPinchTouchTarget() {}
 
   virtual 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);
       start_1_ = gfx::PointF(touch_event.touches[1].position);
       last_pointer_distance_ = (start_0_ - start_1_).Length();
+      initial_pointer_distance_ = last_pointer_distance_;
+      EXPECT_GE(initial_pointer_distance_, GetMinScalingSpanInDips());
 
       started_ = true;
     } else {
       ASSERT_NE(touch_event.type, WebInputEvent::TouchStart);
       ASSERT_NE(touch_event.type, WebInputEvent::TouchCancel);
 
       gfx::PointF current_0 = gfx::PointF(touch_event.touches[0].position);
       gfx::PointF current_1 = gfx::PointF(touch_event.touches[1].position);
 
-      total_num_pixels_covered_ =
-          (current_0 - start_0_).Length() + (current_1 - start_1_).Length();
       float pointer_distance = (current_0 - current_1).Length();
 
       if (last_pointer_distance_ != pointer_distance) {
         if (zoom_direction_ == ZOOM_DIRECTION_UNKNOWN)
           zoom_direction_ =
               ComputeZoomDirection(last_pointer_distance_, pointer_distance);
         else
           EXPECT_EQ(
               zoom_direction_,
               ComputeZoomDirection(last_pointer_distance_, pointer_distance));
       }
 
       last_pointer_distance_ = pointer_distance;
     }
   }
 
-  float total_num_pixels_covered() const { return total_num_pixels_covered_; }
   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());
+      case ZOOM_DIRECTION_UNKNOWN:
+        return 1.0f;
+      default:
+        NOTREACHED();
+        return 0.0f;
+    }
+  }
+
  private:
   ZoomDirection ComputeZoomDirection(float last_pointer_distance,
                                      float current_pointer_distance) {
     DCHECK_NE(last_pointer_distance, current_pointer_distance);
     return last_pointer_distance < current_pointer_distance ? ZOOM_IN
                                                             : ZOOM_OUT;
   }
 
-  float total_num_pixels_covered_;
+  float initial_pointer_distance_;
   float last_pointer_distance_;
   ZoomDirection zoom_direction_;
   gfx::PointF start_0_;
   gfx::PointF start_1_;
   bool started_;
 };
 
 class MockSyntheticTapGestureTarget : public MockSyntheticGestureTarget {
  public:
   MockSyntheticTapGestureTarget() : state_(NOT_STARTED) {}
@@ skipping 615 matching lines @@
   EXPECT_EQ(AddTouchSlopToVector(params.distances[0] + params.distances[1],
                                  target_),
             scroll_target->start_to_end_distance() - gfx::Vector2dF(0, 0.001f));
 }
 
 TEST_F(SyntheticGestureControllerTest, PinchGestureTouchZoomIn) {
   CreateControllerAndTarget<MockSyntheticPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.zoom_in = true;
-  params.total_num_pixels_covered = 345;
+  params.scale_factor = 2.3f;
   params.anchor.SetPoint(54, 89);
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
   QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
   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_EQ(params.total_num_pixels_covered + 2 * target_->GetTouchSlopInDips(),
-            pinch_target->total_num_pixels_covered());
+  EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
 }
 
 TEST_F(SyntheticGestureControllerTest, PinchGestureTouchZoomOut) {
   CreateControllerAndTarget<MockSyntheticPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.zoom_in = false;
-  params.total_num_pixels_covered = 456;
+  params.scale_factor = 0.4f;
   params.anchor.SetPoint(-12, 93);
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
   QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
   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_EQ(params.total_num_pixels_covered + 2 * target_->GetTouchSlopInDips(),
-            pinch_target->total_num_pixels_covered());
+  EXPECT_FLOAT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
 }
 
-TEST_F(SyntheticGestureControllerTest, PinchGestureTouchZeroPixelsCovered) {
+TEST_F(SyntheticGestureControllerTest, PinchGestureTouchNoScaling) {
   CreateControllerAndTarget<MockSyntheticPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.zoom_in = true;
-  params.total_num_pixels_covered = 0;
+  params.scale_factor = 1.0f;
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
   QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
   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(0, pinch_target->total_num_pixels_covered());
+  EXPECT_EQ(params.scale_factor, pinch_target->ComputeScaleFactor());
 }
 
 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