Make SyntheticPointerAction to flush the pointer action sequence

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 460 matching lines @@
         break;
     }
   }
 };
 
 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;
   }
+
+  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_; }
+
+ private:
+  gfx::PointF positions_[kTouchPointersLength];
+  unsigned touch_length_;
+  int indexes_[kTouchPointersLength];
+  WebTouchPoint::State states_[kTouchPointersLength];
+};
+
+class MockSyntheticPointerMouseActionTarget
+    : public MockSyntheticPointerActionTarget {
+ public:
+  MockSyntheticPointerMouseActionTarget() {}
+  ~MockSyntheticPointerMouseActionTarget() override {}
+
+  void DispatchInputEventToPlatform(const WebInputEvent& event) override {
+    ASSERT_TRUE(WebInputEvent::isMouseEventType(event.type));
+    const WebMouseEvent& mouse_event = static_cast<const WebMouseEvent&>(event);
+    type_ = mouse_event.type;
+    position_ = gfx::PointF(mouse_event.x, mouse_event.y);
+    clickCount_ = mouse_event.clickCount;
+    button_ = mouse_event.button;
+  }
+
+  gfx::PointF position() const { return position_; }
+  int clickCount() const { return clickCount_; }
+  WebMouseEvent::Button button() const { return button_; }
+
+ private:
+  gfx::PointF position_;
+  int clickCount_;
+  WebMouseEvent::Button button_;
 };
 
 class SyntheticGestureControllerTestBase {
  public:
   SyntheticGestureControllerTestBase() {}
   ~SyntheticGestureControllerTestBase() {}
 
  protected:
   template<typename MockGestureTarget>
   void CreateControllerAndTarget() {
@@ skipping 943 matching lines @@
       static_cast<MockSyntheticTapMouseTarget*>(target_);
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   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>();
+  std::unique_ptr<SyntheticPointer> synthetic_pointer =
+      SyntheticPointer::Create(SyntheticGestureParams::TOUCH_INPUT);
+  SyntheticPointerAction::IndexMap index_map;
+  std::fill(index_map.begin(), index_map.end(), -1);
+  SyntheticPointerActionListParams action_list_params;
+  action_list_params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+
+  SyntheticPointerActionParams params0 = SyntheticPointerActionParams(
+      SyntheticGestureParams::TOUCH_INPUT,
+      SyntheticPointerActionParams::PointerActionType::PRESS);
+  SyntheticPointerActionParams params1 = SyntheticPointerActionParams(
+      SyntheticGestureParams::TOUCH_INPUT,
+      SyntheticPointerActionParams::PointerActionType::PRESS);
+  params0.set_index(0);
+  params0.set_position(gfx::PointF(54, 89));
+  params1.set_index(1);
+  params1.set_position(gfx::PointF(79, 132));
+  action_list_params.param_list.push_back(params0);
+  action_list_params.param_list.push_back(params1);
+  std::unique_ptr<SyntheticPointerAction> gesture(new SyntheticPointerAction(
+      action_list_params, synthetic_pointer.get(), &index_map));

[tdresser, 2016/10/31 14:22:57]

We use a single SyntheticPointer for two separate presses? That's a bit
confusing. Should SyntheticPointer be SyntheticPointerType?

Should we have a test which mixes touch and mouse input?

[lanwei, 2016/12/04 18:08:01]

We are planing to support multiple pointer types in one action sequence, but the
implementation will be in the later patch. This patch will only support one
pointer type.

[lanwei, 2016/12/04 18:08:02]

Done.

+  QueueSyntheticGesture(std::move(gesture));
+  FlushInputUntilComplete();
+
+  MockSyntheticPointerTouchActionTarget* pointer_touch_target =
+      static_cast<MockSyntheticPointerTouchActionTarget*>(target_);
+  ASSERT_EQ(pointer_touch_target->touch_length(), 2u);
+  EXPECT_EQ(pointer_touch_target->indexes(0), params0.index());
+  EXPECT_EQ(pointer_touch_target->positions(0), params0.position());
+  EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StatePressed);
+  EXPECT_EQ(pointer_touch_target->indexes(1), params1.index());
+  EXPECT_EQ(pointer_touch_target->positions(1), params1.position());
+  EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StatePressed);
+
+  action_list_params.param_list.clear();
+  params0.set_pointer_action_type(
+      SyntheticPointerActionParams::PointerActionType::RELEASE);
+  params1.set_pointer_action_type(
+      SyntheticPointerActionParams::PointerActionType::MOVE);
+  params1.set_position(gfx::PointF(183, 239));
+  action_list_params.param_list.push_back(params0);
+  action_list_params.param_list.push_back(params1);
+  gesture.reset(new SyntheticPointerAction(
+      action_list_params, synthetic_pointer.get(), &index_map));
+  QueueSyntheticGesture(std::move(gesture));
+  FlushInputUntilComplete();
+
+  ASSERT_EQ(pointer_touch_target->touch_length(), 2u);
+  EXPECT_EQ(pointer_touch_target->indexes(0), params0.index());
+  EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StateReleased);
+  EXPECT_EQ(pointer_touch_target->indexes(1), params1.index());
+  EXPECT_EQ(pointer_touch_target->positions(1), params1.position());
+  EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StateMoved);
+
+  action_list_params.param_list.clear();
+  params1.set_pointer_action_type(
+      SyntheticPointerActionParams::PointerActionType::RELEASE);
+  action_list_params.param_list.push_back(params1);
+  gesture.reset(new SyntheticPointerAction(
+      action_list_params, synthetic_pointer.get(), &index_map));
+  QueueSyntheticGesture(std::move(gesture));
+  FlushInputUntilComplete();
+
+  ASSERT_EQ(pointer_touch_target->touch_length(), 2u);
+  EXPECT_EQ(pointer_touch_target->indexes(1), params1.index());
+  EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StateReleased);
+}
+
+TEST_F(SyntheticGestureControllerTest, PointerMouseAction) {
+  CreateControllerAndTarget<MockSyntheticPointerMouseActionTarget>();
+  std::unique_ptr<SyntheticPointer> synthetic_pointer =
+      SyntheticPointer::Create(SyntheticGestureParams::MOUSE_INPUT);
+  SyntheticPointerAction::IndexMap index_map;
+  std::fill(index_map.begin(), index_map.end(), -1);
+  SyntheticPointerActionListParams action_list_params;
+  action_list_params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
+
+  SyntheticPointerActionParams action_params = SyntheticPointerActionParams(
+      SyntheticGestureParams::MOUSE_INPUT,
+      SyntheticPointerActionParams::PointerActionType::MOVE);
+  action_params.set_index(0);
+  action_params.set_position(gfx::PointF(54, 89));
+  action_list_params.param_list.push_back(action_params);
+  std::unique_ptr<SyntheticPointerAction> gesture(new SyntheticPointerAction(
+      action_list_params, synthetic_pointer.get(), &index_map));
+  QueueSyntheticGesture(std::move(gesture));
+  FlushInputUntilComplete();
+
+  MockSyntheticPointerMouseActionTarget* pointer_mouse_target =
+      static_cast<MockSyntheticPointerMouseActionTarget*>(target_);
+  EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseMove);
+  EXPECT_EQ(pointer_mouse_target->position(), action_params.position());
+  EXPECT_EQ(pointer_mouse_target->clickCount(), 0);
+  EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::NoButton);
+
+  action_list_params.param_list[0].set_pointer_action_type(
+      SyntheticPointerActionParams::PointerActionType::PRESS);
+  action_list_params.param_list[0].set_position(gfx::PointF(183, 239));
+  gesture.reset(new SyntheticPointerAction(
+      action_list_params, synthetic_pointer.get(), &index_map));
+  QueueSyntheticGesture(std::move(gesture));
+  FlushInputUntilComplete();
+
+  EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseDown);
+  EXPECT_EQ(pointer_mouse_target->position(), gfx::PointF(183, 239));
+  EXPECT_EQ(pointer_mouse_target->clickCount(), 1);
+  EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::Left);
+
+  action_list_params.param_list[0].set_pointer_action_type(
+      SyntheticPointerActionParams::PointerActionType::MOVE);
+  action_list_params.param_list[0].set_position(gfx::PointF(254, 279));
+  gesture.reset(new SyntheticPointerAction(
+      action_list_params, synthetic_pointer.get(), &index_map));
+  QueueSyntheticGesture(std::move(gesture));
+  FlushInputUntilComplete();
+
+  EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseMove);
+  EXPECT_EQ(pointer_mouse_target->position(), gfx::PointF(254, 279));
+  EXPECT_EQ(pointer_mouse_target->clickCount(), 1);
+  EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::Left);
+
+  action_list_params.param_list[0].set_pointer_action_type(
+      SyntheticPointerActionParams::PointerActionType::RELEASE);
+  gesture.reset(new SyntheticPointerAction(
+      action_list_params, synthetic_pointer.get(), &index_map));
+  QueueSyntheticGesture(std::move(gesture));
+  FlushInputUntilComplete();
+
+  EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseUp);
+  EXPECT_EQ(pointer_mouse_target->clickCount(), 1);
+  EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::Left);
+}
+
 }  // namespace
 
 }  // namespace content