Rename SyntheticPointer to SyntheticPointerDriver

content/browser/renderer_host/input/synthetic_pointer_action_unittest.cc

 // Copyright 2016 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/time/time.h"
 #include "content/browser/renderer_host/input/synthetic_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target.h"
 #include "content/browser/renderer_host/input/synthetic_pointer_action.h"
-#include "content/browser/renderer_host/input/synthetic_touch_pointer.h"
+#include "content/browser/renderer_host/input/synthetic_touch_driver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_f.h"
 
 using blink::WebInputEvent;
 using blink::WebTouchEvent;
 using blink::WebMouseEvent;
 using blink::WebTouchPoint;
 
@@ skipping 92 matching lines @@
  private:
   gfx::PointF position_;
   int clickCount_;
   WebMouseEvent::Button button_;
 };
 
 class SyntheticPointerActionTest : public testing::Test {
  public:
   SyntheticPointerActionTest() {
     action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-    std::fill(index_map_.begin(), index_map_.end(), -1);
     num_success_ = 0;
     num_failure_ = 0;
   }
   ~SyntheticPointerActionTest() override {}
 
  protected:
   template <typename MockGestureTarget>
   void CreateSyntheticPointerActionTarget() {
     target_.reset(new MockGestureTarget());
-    synthetic_pointer_ = SyntheticPointer::Create(
+    synthetic_pointer_driver_ = SyntheticPointerDriver::Create(
         target_->GetDefaultSyntheticGestureSourceType());
   }
 
   void ForwardSyntheticPointerAction() {
     pointer_action_.reset(new SyntheticPointerAction(
-        std::move(action_param_list_), synthetic_pointer_.get(), &index_map_));
+        action_param_list_.get(), synthetic_pointer_driver_.get()));
 
     SyntheticGesture::Result result = pointer_action_->ForwardInputEvents(
         base::TimeTicks::Now(), target_.get());
 
     if (result == SyntheticGesture::GESTURE_FINISHED)
       num_success_++;
     else
       num_failure_++;
   }
 
   int num_success_;
   int num_failure_;
   std::unique_ptr<MockSyntheticPointerActionTarget> target_;
   std::unique_ptr<SyntheticGesture> pointer_action_;
-  std::unique_ptr<SyntheticPointer> synthetic_pointer_;
+  std::unique_ptr<SyntheticPointerDriver> synthetic_pointer_driver_;
   std::unique_ptr<std::vector<SyntheticPointerActionParams>> action_param_list_;
-  SyntheticPointerAction::IndexMap index_map_;
 };
 
 TEST_F(SyntheticPointerActionTest, PointerTouchAction) {
   CreateSyntheticPointerActionTarget<MockSyntheticPointerTouchActionTarget>();
 
   // Send a touch press for one finger.
   SyntheticPointerActionParams params0 = SyntheticPointerActionParams(
-      SyntheticPointerActionParams::PointerActionType::PRESS);
-  params0.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params0.set_index(0);
+      SyntheticPointerActionParams::PointerActionType::PRESS,
+      SyntheticGestureParams::TOUCH_INPUT);
   params0.set_position(gfx::PointF(54, 89));
   action_param_list_->push_back(params0);
   ForwardSyntheticPointerAction();
 
   MockSyntheticPointerTouchActionTarget* pointer_touch_target =
       static_cast<MockSyntheticPointerTouchActionTarget*>(target_.get());
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchStart);
   EXPECT_EQ(pointer_touch_target->indexes(0), 0);
-  EXPECT_EQ(index_map_[0], 0);
+  EXPECT_EQ(action_param_list_->at(0).index(), 0);
   EXPECT_EQ(pointer_touch_target->positions(0), gfx::PointF(54, 89));
   EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StatePressed);
   ASSERT_EQ(pointer_touch_target->touch_length(), 1U);
 
   // Send a touch move for the first finger and a touch press for the second
   // finger.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params0.set_pointer_action_type(
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::MOVE);
-  params0.set_position(gfx::PointF(133, 156));
+  action_param_list_->at(0).set_position(gfx::PointF(133, 156));
   SyntheticPointerActionParams params1 = SyntheticPointerActionParams(
-      SyntheticPointerActionParams::PointerActionType::PRESS);
-  params1.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params1.set_index(1);
+      SyntheticPointerActionParams::PointerActionType::PRESS,
+      SyntheticGestureParams::TOUCH_INPUT);
   params1.set_position(gfx::PointF(79, 132));
-  action_param_list_->push_back(params0);
   action_param_list_->push_back(params1);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(2, num_success_);
   EXPECT_EQ(0, num_failure_);
   // The type of the SyntheticWebTouchEvent is the action of the last finger.
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchStart);
   EXPECT_EQ(pointer_touch_target->indexes(0), 0);
-  EXPECT_EQ(index_map_[0], 0);
+  EXPECT_EQ(action_param_list_->at(0).index(), 0);
   EXPECT_EQ(pointer_touch_target->positions(0), gfx::PointF(133, 156));
   EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StateMoved);
   EXPECT_EQ(pointer_touch_target->indexes(1), 1);
-  EXPECT_EQ(index_map_[1], 1);
+  EXPECT_EQ(action_param_list_->at(1).index(), 1);
   EXPECT_EQ(pointer_touch_target->positions(1), gfx::PointF(79, 132));
   EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StatePressed);
   ASSERT_EQ(pointer_touch_target->touch_length(), 2U);
 
   // Send a touch move for the second finger.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params1.set_pointer_action_type(
+  action_param_list_->at(1).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::MOVE);
-  params1.set_position(gfx::PointF(87, 253));
-  action_param_list_->push_back(params1);
+  action_param_list_->at(1).set_position(gfx::PointF(87, 253));
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(3, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchMove);
   EXPECT_EQ(pointer_touch_target->indexes(1), 1);
-  EXPECT_EQ(index_map_[1], 1);
+  EXPECT_EQ(action_param_list_->at(1).index(), 1);
   EXPECT_EQ(pointer_touch_target->positions(1), gfx::PointF(87, 253));
   EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StateMoved);
   ASSERT_EQ(pointer_touch_target->touch_length(), 2U);
 
   // Send touch releases for both fingers.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params0.set_pointer_action_type(
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::RELEASE);
-  params1.set_pointer_action_type(
+  action_param_list_->at(1).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::RELEASE);
-  action_param_list_->push_back(params0);
-  action_param_list_->push_back(params1);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(4, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchEnd);
   EXPECT_EQ(pointer_touch_target->indexes(0), 0);
-  EXPECT_EQ(index_map_[0], -1);
+  EXPECT_EQ(action_param_list_->at(0).index(), -1);
   EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StateReleased);
   EXPECT_EQ(pointer_touch_target->indexes(1), 1);
-  EXPECT_EQ(index_map_[1], -1);
+  EXPECT_EQ(action_param_list_->at(1).index(), -1);
   EXPECT_EQ(pointer_touch_target->states(1), WebTouchPoint::StateReleased);
   ASSERT_EQ(pointer_touch_target->touch_length(), 2U);
 }
 
-TEST_F(SyntheticPointerActionTest, PointerTouchActionIndexInvalid) {
+TEST_F(SyntheticPointerActionTest, PointerTouchActionWithIdle) {
   CreateSyntheticPointerActionTarget<MockSyntheticPointerTouchActionTarget>();
-
-  // Users sent a wrong index for the touch action.
+  int count_success = 1;
+  // Send a touch press for one finger.
   SyntheticPointerActionParams params0 = SyntheticPointerActionParams(
-      SyntheticPointerActionParams::PointerActionType::PRESS);
-  params0.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params0.set_index(-1);
+      SyntheticPointerActionParams::PointerActionType::PRESS,
+      SyntheticGestureParams::TOUCH_INPUT);
   params0.set_position(gfx::PointF(54, 89));
   action_param_list_->push_back(params0);
   ForwardSyntheticPointerAction();
 
-  EXPECT_EQ(0, num_success_);
-  EXPECT_EQ(1, num_failure_);
-
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params0.set_index(0);
-  action_param_list_->push_back(params0);
-  ForwardSyntheticPointerAction();
-
   MockSyntheticPointerTouchActionTarget* pointer_touch_target =
       static_cast<MockSyntheticPointerTouchActionTarget*>(target_.get());
-  EXPECT_EQ(1, num_success_);
-  EXPECT_EQ(1, num_failure_);
+  EXPECT_EQ(count_success++, num_success_);
+  EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchStart);
   EXPECT_EQ(pointer_touch_target->indexes(0), 0);
-  EXPECT_EQ(index_map_[0], 0);
+  EXPECT_EQ(action_param_list_->at(0).index(), 0);
   EXPECT_EQ(pointer_touch_target->positions(0), gfx::PointF(54, 89));
   EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StatePressed);
   ASSERT_EQ(pointer_touch_target->touch_length(), 1U);
+
+  SyntheticPointerActionParams params1;
+  params1.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  action_param_list_->push_back(params1);

[Navid Zolghadr, 2016/11/21 17:56:46]

Not related to your patch and change here. Just want to confirm something here.
If we have one finger down and keep pressing and releasing the second finger we
are increasing the id of the second finger and eventually we hit the maximum id
cap (kTouchesLengthCap) and we fail the press action. Right?

[lanwei, 2016/11/23 19:59:23]

Yes, you are right. The implementation is here
content/common/input/synthetic_web_input_event_builders.cc
If it is not reasonable, we can change it.

[Navid Zolghadr, 2016/11/23 20:08:21]

Nope. That should be fine for now. This patch didn't change that behavior
anyway.

[tdresser, 2016/11/28 15:12:03]

We do need to fix this before we try to get external consumers using this API.
Lan, can you file a bug?

[lanwei, 2016/11/28 19:17:55]

Done.

+  for (int i = 0; i < 3; ++i) {
+    // Send a touch press for the second finger and not move the first finger.
+    action_param_list_->at(0).set_pointer_action_type(
+        SyntheticPointerActionParams::PointerActionType::IDLE);
+    action_param_list_->at(1).set_pointer_action_type(
+        SyntheticPointerActionParams::PointerActionType::PRESS);
+    action_param_list_->at(1).set_position(gfx::PointF(123, 69));
+    int index = 1 + i;
+    ForwardSyntheticPointerAction();
+
+    EXPECT_EQ(count_success++, num_success_);
+    EXPECT_EQ(0, num_failure_);
+    // The type of the SyntheticWebTouchEvent is the action of the last finger.
+    EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchStart);
+    EXPECT_EQ(pointer_touch_target->indexes(index), index);
+    EXPECT_EQ(action_param_list_->at(1).index(), index);
+    EXPECT_EQ(pointer_touch_target->positions(index), gfx::PointF(123, 69));
+    EXPECT_EQ(pointer_touch_target->states(index), WebTouchPoint::StatePressed);
+    ASSERT_EQ(pointer_touch_target->touch_length(), index + 1U);
+
+    // Send a touch release for the second finger and not move the first finger.
+    action_param_list_->at(0).set_pointer_action_type(
+        SyntheticPointerActionParams::PointerActionType::IDLE);
+    action_param_list_->at(1).set_pointer_action_type(
+        SyntheticPointerActionParams::PointerActionType::RELEASE);
+
+    ForwardSyntheticPointerAction();
+
+    EXPECT_EQ(count_success++, num_success_);
+    EXPECT_EQ(0, num_failure_);
+    // The type of the SyntheticWebTouchEvent is the action of the last finger.
+    EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchEnd);
+    EXPECT_EQ(pointer_touch_target->indexes(index), index);
+    EXPECT_EQ(action_param_list_->at(1).index(), -1);
+    EXPECT_EQ(pointer_touch_target->states(index),
+              WebTouchPoint::StateReleased);
+    ASSERT_EQ(pointer_touch_target->touch_length(), index + 1U);
+  }
 }
 
 TEST_F(SyntheticPointerActionTest, PointerTouchActionSourceTypeInvalid) {
   CreateSyntheticPointerActionTarget<MockSyntheticPointerTouchActionTarget>();
 
   // Users' gesture source type does not match with the touch action.
-  SyntheticPointerActionParams params0 = SyntheticPointerActionParams(
-      SyntheticPointerActionParams::PointerActionType::PRESS);
-  params0.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
-  params0.set_index(0);
-  params0.set_position(gfx::PointF(54, 89));
-  action_param_list_->push_back(params0);
+  SyntheticPointerActionParams params = SyntheticPointerActionParams(
+      SyntheticPointerActionParams::PointerActionType::PRESS,
+      SyntheticGestureParams::MOUSE_INPUT);
+  params.set_position(gfx::PointF(54, 89));
+  action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(0, num_success_);
   EXPECT_EQ(1, num_failure_);
 
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params0.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  action_param_list_->push_back(params0);
+  params = SyntheticPointerActionParams(
+      SyntheticPointerActionParams::PointerActionType::PRESS,
+      SyntheticGestureParams::TOUCH_INPUT);
+  params.set_position(gfx::PointF(54, 89));
+  action_param_list_->at(0) = params;
   ForwardSyntheticPointerAction();
 
   MockSyntheticPointerTouchActionTarget* pointer_touch_target =
       static_cast<MockSyntheticPointerTouchActionTarget*>(target_.get());
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(1, num_failure_);
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchStart);
   EXPECT_EQ(pointer_touch_target->indexes(0), 0);
-  EXPECT_EQ(index_map_[0], 0);
+  EXPECT_EQ(action_param_list_->at(0).index(), 0);
   EXPECT_EQ(pointer_touch_target->positions(0), gfx::PointF(54, 89));
   EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StatePressed);
   ASSERT_EQ(pointer_touch_target->touch_length(), 1U);
 }
 
 TEST_F(SyntheticPointerActionTest, PointerTouchActionTypeInvalid) {
   CreateSyntheticPointerActionTarget<MockSyntheticPointerTouchActionTarget>();
 
   // Cannot send a touch move or touch release without sending a touch press
   // first.
-  SyntheticPointerActionParams params0 = SyntheticPointerActionParams(
-      SyntheticPointerActionParams::PointerActionType::MOVE);
-  params0.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params0.set_index(0);
-  params0.set_position(gfx::PointF(54, 89));
-  action_param_list_->push_back(params0);
+  SyntheticPointerActionParams params = SyntheticPointerActionParams(
+      SyntheticPointerActionParams::PointerActionType::MOVE,
+      SyntheticGestureParams::TOUCH_INPUT);
+  params.set_position(gfx::PointF(54, 89));
+  action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(0, num_success_);
   EXPECT_EQ(1, num_failure_);
 
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params0.set_pointer_action_type(
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::RELEASE);
-  action_param_list_->push_back(params0);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(0, num_success_);
   EXPECT_EQ(2, num_failure_);
 
   // Send a touch press for one finger.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params0.set_pointer_action_type(
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::PRESS);
-  action_param_list_->push_back(params0);
   ForwardSyntheticPointerAction();
 
   MockSyntheticPointerTouchActionTarget* pointer_touch_target =
       static_cast<MockSyntheticPointerTouchActionTarget*>(target_.get());
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(2, num_failure_);
   EXPECT_EQ(pointer_touch_target->type(), WebInputEvent::TouchStart);
   EXPECT_EQ(pointer_touch_target->indexes(0), 0);
-  EXPECT_EQ(index_map_[0], 0);
+  EXPECT_EQ(action_param_list_->at(0).index(), 0);
   EXPECT_EQ(pointer_touch_target->positions(0), gfx::PointF(54, 89));
   EXPECT_EQ(pointer_touch_target->states(0), WebTouchPoint::StatePressed);
   ASSERT_EQ(pointer_touch_target->touch_length(), 1U);
 
   // Cannot send a touch press again without releasing the finger.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params0.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params0.set_index(0);
-  params0.set_pointer_action_type(
+  action_param_list_->at(0).gesture_source_type =
+      SyntheticGestureParams::TOUCH_INPUT;
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::PRESS);
-  action_param_list_->push_back(params0);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(3, num_failure_);
 }
 
 TEST_F(SyntheticPointerActionTest, PointerMouseAction) {
   CreateSyntheticPointerActionTarget<MockSyntheticPointerMouseActionTarget>();
 
   // Send a mouse move.
   SyntheticPointerActionParams params = SyntheticPointerActionParams(
-      SyntheticPointerActionParams::PointerActionType::MOVE);
-  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
-  params.set_index(0);
+      SyntheticPointerActionParams::PointerActionType::MOVE,
+      SyntheticGestureParams::MOUSE_INPUT);
   params.set_position(gfx::PointF(189, 62));
   action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   MockSyntheticPointerMouseActionTarget* pointer_mouse_target =
       static_cast<MockSyntheticPointerMouseActionTarget*>(target_.get());
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseMove);
   EXPECT_EQ(pointer_mouse_target->position(), params.position());
   EXPECT_EQ(pointer_mouse_target->clickCount(), 0);
   EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::NoButton);
 
   // Send a mouse down.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params.set_position(gfx::PointF(189, 62));
-  params.set_pointer_action_type(
+  action_param_list_->at(0).set_position(gfx::PointF(189, 62));
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::PRESS);
-  action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(2, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseDown);
   EXPECT_EQ(pointer_mouse_target->position(), params.position());
   EXPECT_EQ(pointer_mouse_target->clickCount(), 1);
   EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::Left);
 
   // Send a mouse drag.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params.set_position(gfx::PointF(326, 298));
-  params.set_pointer_action_type(
+  action_param_list_->at(0).set_position(gfx::PointF(326, 298));
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::MOVE);
-  action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(3, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseMove);
-  EXPECT_EQ(pointer_mouse_target->position(), params.position());
+  EXPECT_EQ(pointer_mouse_target->position(),
+            action_param_list_->at(0).position());
   EXPECT_EQ(pointer_mouse_target->clickCount(), 1);
   EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::Left);
 
   // Send a mouse up.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params.set_pointer_action_type(
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::RELEASE);
-  action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(4, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseUp);
   EXPECT_EQ(pointer_mouse_target->clickCount(), 1);
   EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::Left);
 }
 
 TEST_F(SyntheticPointerActionTest, PointerMouseActionSourceTypeInvalid) {
   CreateSyntheticPointerActionTarget<MockSyntheticPointerMouseActionTarget>();
 
   // Users' gesture source type does not match with the mouse action.
   SyntheticPointerActionParams params = SyntheticPointerActionParams(
-      SyntheticPointerActionParams::PointerActionType::PRESS);
-  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
-  params.set_index(0);
+      SyntheticPointerActionParams::PointerActionType::PRESS,
+      SyntheticGestureParams::TOUCH_INPUT);
   params.set_position(gfx::PointF(54, 89));
   action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(0, num_success_);
   EXPECT_EQ(1, num_failure_);
 
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
-  action_param_list_->push_back(params);
+  params = SyntheticPointerActionParams(
+      SyntheticPointerActionParams::PointerActionType::PRESS,
+      SyntheticGestureParams::MOUSE_INPUT);
+  params.set_position(gfx::PointF(54, 89));
+  action_param_list_->at(0) = params;
   ForwardSyntheticPointerAction();
 
   MockSyntheticPointerMouseActionTarget* pointer_mouse_target =
       static_cast<MockSyntheticPointerMouseActionTarget*>(target_.get());
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(1, num_failure_);
   EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseDown);
   EXPECT_EQ(pointer_mouse_target->position(), params.position());
   EXPECT_EQ(pointer_mouse_target->clickCount(), 1);
   EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::Left);
 }
 
 TEST_F(SyntheticPointerActionTest, PointerMouseActionTypeInvalid) {
   CreateSyntheticPointerActionTarget<MockSyntheticPointerMouseActionTarget>();
 
   // Send a mouse move.
   SyntheticPointerActionParams params = SyntheticPointerActionParams(
-      SyntheticPointerActionParams::PointerActionType::MOVE);
-  params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
-  params.set_index(0);
+      SyntheticPointerActionParams::PointerActionType::MOVE,
+      SyntheticGestureParams::MOUSE_INPUT);
   params.set_position(gfx::PointF(189, 62));
   action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   MockSyntheticPointerMouseActionTarget* pointer_mouse_target =
       static_cast<MockSyntheticPointerMouseActionTarget*>(target_.get());
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseMove);
   EXPECT_EQ(pointer_mouse_target->position(), params.position());
   EXPECT_EQ(pointer_mouse_target->clickCount(), 0);
   EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::NoButton);
 
   // Cannot send a mouse up without sending a mouse down first.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params.set_pointer_action_type(
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::RELEASE);
-  action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(1, num_success_);
   EXPECT_EQ(1, num_failure_);
 
   // Send a mouse down for one finger.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params.set_pointer_action_type(
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::PRESS);
-  action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(2, num_success_);
   EXPECT_EQ(1, num_failure_);
   EXPECT_EQ(pointer_mouse_target->type(), WebInputEvent::MouseDown);
   EXPECT_EQ(pointer_mouse_target->position(), params.position());
   EXPECT_EQ(pointer_mouse_target->clickCount(), 1);
   EXPECT_EQ(pointer_mouse_target->button(), WebMouseEvent::Button::Left);
 
   // Cannot send a mouse down again without releasing the mouse button.
-  action_param_list_.reset(new std::vector<SyntheticPointerActionParams>());
-  params.set_pointer_action_type(
+  action_param_list_->at(0).set_pointer_action_type(
       SyntheticPointerActionParams::PointerActionType::PRESS);
-  action_param_list_->push_back(params);
   ForwardSyntheticPointerAction();
 
   EXPECT_EQ(2, num_success_);
   EXPECT_EQ(2, num_failure_);
 }
 
 }  // namespace
 
-}  // namespace content
+}  // namespace content