Prepare SyntheticPointerAction to handle touch actions for multiple fingers

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 "content/browser/renderer_host/input/synthetic_gesture_controller.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 28 matching lines @@
 #include "ui/gfx/geometry/vector2d_f.h"
 
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 
 namespace content {
 
+class MockSyntheticGestureController : public SyntheticGestureController {

[tdresser, 2016/05/19 17:57:03]

Technically this isn't a Mock. I can never keep track of what all the correct
uses for the terms fake, mock, stub, dummy etc are, but a mock implies that this
object doesn't perform actual behavior.

Let's call this TestSyntheticGestureController.

[lanwei, 2016/05/20 01:48:16]

Thanks for explaining what a mock is doing!

+ public:
+  MockSyntheticGestureController(
+      std::unique_ptr<SyntheticGestureTarget> gesture_target)
+      : SyntheticGestureController(std::move(gesture_target)) {}
+  ~MockSyntheticGestureController() override {}
+
+  int PointerIndex(int index) const {
+    return pointer_action_controller_.PointerIndex(index);
+  }
+};
+
 namespace {
 
 const int kFlushInputRateInMs = 16;
 const int kPointerAssumedStoppedTimeMs = 43;
 const float kTouchSlopInDips = 7.0f;
 const float kMinScalingSpanInDips = 27.5f;
 const int kTouchPointersLength = 16;
 
 enum TouchGestureType { TOUCH_SCROLL, TOUCH_DRAG };
 
@@ skipping 416 matching lines @@
 
 class MockSyntheticPointerActionTarget : public MockSyntheticGestureTarget {
  public:
   MockSyntheticPointerActionTarget() {}
   ~MockSyntheticPointerActionTarget() override {}
 
   gfx::PointF positions(int index) const { return positions_[index]; }
   int indexes(int index) const { return indexes_[index]; }
   WebTouchPoint::State states(int index) { return states_[index]; }
   unsigned touch_length() const { return touch_length_; }
-  WebInputEvent::Type type() const { return type_; }
 
  protected:
   gfx::PointF positions_[kTouchPointersLength];
   unsigned touch_length_;
   int indexes_[kTouchPointersLength];
   WebTouchPoint::State states_[kTouchPointersLength];
-  WebInputEvent::Type type_;
 };
 
 class MockSyntheticPointerTouchActionTarget
     : public MockSyntheticPointerActionTarget {
  public:
   MockSyntheticPointerTouchActionTarget() {}
   ~MockSyntheticPointerTouchActionTarget() override {}
 
   void DispatchInputEventToPlatform(const WebInputEvent& event) override {
     ASSERT_TRUE(WebInputEvent::isTouchEventType(event.type));
     const WebTouchEvent& touch_event = static_cast<const WebTouchEvent&>(event);
-    type_ = touch_event.type;
     for (size_t i = 0; i < touch_event.touchesLength; ++i) {
       indexes_[i] = touch_event.touches[i].id;
       positions_[i] = gfx::PointF(touch_event.touches[i].position);
       states_[i] = touch_event.touches[i].state;
     }
     touch_length_ = touch_event.touchesLength;
   }
 };
 
 class SyntheticGestureControllerTestBase {
  public:
   SyntheticGestureControllerTestBase() {}
   ~SyntheticGestureControllerTestBase() {}
 
  protected:
   template<typename MockGestureTarget>
   void CreateControllerAndTarget() {
     target_ = new MockGestureTarget();
-    controller_.reset(new SyntheticGestureController(
+    controller_.reset(new MockSyntheticGestureController(
         std::unique_ptr<SyntheticGestureTarget>(target_)));
   }
 
   void QueueSyntheticGesture(std::unique_ptr<SyntheticGesture> gesture) {
     controller_->QueueSyntheticGesture(
         std::move(gesture),
         base::Bind(
             &SyntheticGestureControllerTestBase::OnSyntheticGestureCompleted,
             base::Unretained(this)));
   }
 
+  void QueueSyntheticPointerAction(
+      const SyntheticPointerActionParams& gesture_params) {
+    controller_->QueueSyntheticPointerAction(
+        gesture_params, base::Bind(&SyntheticGestureControllerTestBase::
+                                       OnSyntheticPointerActionCompleted,
+                                   base::Unretained(this)));
+  }
+
   void FlushInputUntilComplete() {
     while (target_->flush_requested()) {
       while (target_->flush_requested()) {
         target_->ClearFlushRequest();
         time_ += base::TimeDelta::FromMilliseconds(kFlushInputRateInMs);
         controller_->Flush(time_);
       }
       controller_->OnDidFlushInput();
     }
   }
 
   void OnSyntheticGestureCompleted(SyntheticGesture::Result result) {
     DCHECK_NE(result, SyntheticGesture::GESTURE_RUNNING);
     if (result == SyntheticGesture::GESTURE_FINISHED)
       num_success_++;
     else
       num_failure_++;
   }
 
+  void OnSyntheticPointerActionCompleted(SyntheticGesture::Result result) {
+    if (result == SyntheticGesture::POINTER_ACTION_PROCESSED) {
+      num_success_++;
+      action_state_ = PROCESSED;
+    } else if (result == SyntheticGesture::POINTER_ACTION_FINISHED) {
+      num_success_++;
+      action_state_ = FINISHED;
+    } else {
+      num_failure_++;
+      action_state_ = OTHER;
+    }
+  }
+
   base::TimeDelta GetTotalTime() const { return time_ - start_time_; }
 
+  int PointerIndex(int index) const { return controller_->PointerIndex(index); }
+
+  enum PointerActionState { PROCESSED, FINISHED, OTHER };
+
   MockSyntheticGestureTarget* target_;
-  std::unique_ptr<SyntheticGestureController> controller_;
+  std::unique_ptr<MockSyntheticGestureController> controller_;
   base::TimeTicks start_time_;
   base::TimeTicks time_;
   int num_success_;
   int num_failure_;
+  PointerActionState action_state_;
 };
 
 class SyntheticGestureControllerTest
     : public SyntheticGestureControllerTestBase,
       public testing::Test {
  protected:
   void SetUp() override {
     start_time_ = base::TimeTicks::Now();
     time_ = start_time_;
     num_success_ = 0;
     num_failure_ = 0;
+    action_state_ = OTHER;
   }
 
   void TearDown() override {
     controller_.reset();
     target_ = nullptr;
     time_ = base::TimeTicks();
   }
 };
 
 class SyntheticGestureControllerTestWithParam
     : public SyntheticGestureControllerTestBase,
       public testing::TestWithParam<bool> {
  protected:
   void SetUp() override {
     start_time_ = base::TimeTicks::Now();
     time_ = start_time_;
     num_success_ = 0;
     num_failure_ = 0;
+    action_state_ = OTHER;
   }
 
   void TearDown() override {
     controller_.reset();
     target_ = nullptr;
     time_ = base::TimeTicks();
   }
 };
 
 TEST_F(SyntheticGestureControllerTest, SingleGesture) {
@@ skipping 867 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));
 }
 
 TEST_F(SyntheticGestureControllerTest, PointerTouchAction) {
   CreateControllerAndTarget<MockSyntheticPointerTouchActionTarget>();
 
-  SyntheticPointerActionParams params = SyntheticPointerActionParams(
+  SyntheticPointerActionParams params1 = SyntheticPointerActionParams(
       SyntheticPointerActionParams::PointerActionType::PRESS);
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.set_index(0);
-  params.set_position(gfx::PointF(54, 89));
+  params1.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  params1.set_index(0);
+  params1.set_position(gfx::PointF(54, 89));
   SyntheticTouchPointer synthetic_pointer;
 
-  std::unique_ptr<SyntheticPointerAction> gesture(
-      new SyntheticPointerAction(params, &synthetic_pointer));
-  QueueSyntheticGesture(std::move(gesture));
+  // Send a touch press for one finger.
+  SyntheticPointerActionParams process_params = SyntheticPointerActionParams(
+      SyntheticPointerActionParams::PointerActionType::PROCESS);
+  process_params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  QueueSyntheticPointerAction(params1);
+  QueueSyntheticPointerAction(process_params);
   FlushInputUntilComplete();
 
   MockSyntheticPointerTouchActionTarget* pointer_touch_target =
       static_cast<MockSyntheticPointerTouchActionTarget*>(target_);
-  EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchStart);
-  EXPECT_EQ(pointer_touch_target->positions(0), params.position());
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(pointer_touch_target->indexes(0), PointerIndex(0));
+  EXPECT_EQ(pointer_touch_target->positions(0), params1.position());
   EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StatePressed);
   ASSERT_EQ(pointer_touch_target->touch_length(), 1U);
+  EXPECT_EQ(PROCESSED, action_state_);
 
-  params.set_index(1);
-  params.set_position(gfx::PointF(79, 132));
-  gesture.reset(new SyntheticPointerAction(params, &synthetic_pointer));
-  QueueSyntheticGesture(std::move(gesture));
+  // Send a touch move for the first finger and a touch press for the second
+  // finger.
+  params1.set_pointer_action_type(
+      SyntheticPointerActionParams::PointerActionType::MOVE);
+  params1.set_position(gfx::PointF(133, 156));
+  QueueSyntheticPointerAction(params1);
+  SyntheticPointerActionParams params2 = SyntheticPointerActionParams(
+      SyntheticPointerActionParams::PointerActionType::PRESS);
+  params2.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  params2.set_index(1);
+  params2.set_position(gfx::PointF(79, 132));
+  QueueSyntheticPointerAction(params2);
+  QueueSyntheticPointerAction(process_params);
   FlushInputUntilComplete();
 
   pointer_touch_target =
       static_cast<MockSyntheticPointerTouchActionTarget*>(target_);
-  EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchStart);
-  EXPECT_EQ(pointer_touch_target->indexes(1), params.index());
-  EXPECT_EQ(pointer_touch_target->positions(1), params.position());
+  EXPECT_EQ(2, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(pointer_touch_target->indexes(0), PointerIndex(0));
+  EXPECT_EQ(pointer_touch_target->positions(0), params1.position());
+  EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StateMoved);
+  EXPECT_EQ(pointer_touch_target->indexes(1), PointerIndex(1));
+  EXPECT_EQ(pointer_touch_target->positions(1), params2.position());
   EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StatePressed);
   ASSERT_EQ(pointer_touch_target->touch_length(), 2U);
+  EXPECT_EQ(PROCESSED, action_state_);
 
-  params.set_pointer_action_type(
-      SyntheticPointerActionParams::PointerActionType::MOVE);
-  params.set_position(gfx::PointF(133, 156));
-  gesture.reset(new SyntheticPointerAction(params, &synthetic_pointer));
-  QueueSyntheticGesture(std::move(gesture));
+  // Send touch releases for both fingers.
+  params1.set_pointer_action_type(
+      SyntheticPointerActionParams::PointerActionType::RELEASE);
+  QueueSyntheticPointerAction(params1);
+  params2.set_pointer_action_type(
+      SyntheticPointerActionParams::PointerActionType::RELEASE);
+  QueueSyntheticPointerAction(params2);
+  QueueSyntheticPointerAction(process_params);
   FlushInputUntilComplete();
 
-  pointer_touch_target =
-      static_cast<MockSyntheticPointerTouchActionTarget*>(target_);
-  EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchMove);
-  EXPECT_EQ(pointer_touch_target->positions(1), params.position());
-  EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StateMoved);
+  EXPECT_EQ(3, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(pointer_touch_target->indexes(0), PointerIndex(0));
+  EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StateReleased);
+  EXPECT_EQ(pointer_touch_target->indexes(1), PointerIndex(1));
+  EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StateReleased);
   ASSERT_EQ(pointer_touch_target->touch_length(), 2U);
+  EXPECT_EQ(PROCESSED, action_state_);
 
-  params.set_pointer_action_type(
-      SyntheticPointerActionParams::PointerActionType::RELEASE);
-  gesture.reset(new SyntheticPointerAction(params, &synthetic_pointer));
-  QueueSyntheticGesture(std::move(gesture));
+  // Send a finish action to notify synthetic gesture controller the whole
+  // pointer action sequence has been handled.
+  SyntheticPointerActionParams finish_params = SyntheticPointerActionParams(
+      SyntheticPointerActionParams::PointerActionType::FINISH);
+  finish_params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  QueueSyntheticPointerAction(finish_params);
   FlushInputUntilComplete();
 
-  pointer_touch_target =
-      static_cast<MockSyntheticPointerTouchActionTarget*>(target_);
-  EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchEnd);
-  EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StateReleased);
+  EXPECT_EQ(4, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(FINISHED, action_state_);
 }
 
 }  // namespace
 
 }  // namespace content