Rename SyntheticPointer to SyntheticPointerDriver

Rename SyntheticPointer to SyntheticPointerDriver, SyntheticTouchPointer to
SyntheticTouchDriver, and SyntheticMousePointer to SyntheticMouseDriver,
because these classes do not represent the synthetic pointers. They actually create
synthetic pointers for each pointer types and their actions.

BUG=525187

Review-Url: https://codereview.chromium.org/2478423002
Cr-Commit-Position: refs/heads/master@{#434763}

content/browser/BUILD.gn

@@ -1031,14 +1031,14 @@ source_set("browser") {
     "renderer_host/input/synthetic_gesture_target_base.h",
     "renderer_host/input/synthetic_gesture_target_mac.h",
     "renderer_host/input/synthetic_gesture_target_mac.mm",
-    "renderer_host/input/synthetic_mouse_pointer.cc",
-    "renderer_host/input/synthetic_mouse_pointer.h",
+    "renderer_host/input/synthetic_mouse_driver.cc",
+    "renderer_host/input/synthetic_mouse_driver.h",
     "renderer_host/input/synthetic_pinch_gesture.cc",
     "renderer_host/input/synthetic_pinch_gesture.h",
-    "renderer_host/input/synthetic_pointer.cc",
-    "renderer_host/input/synthetic_pointer.h",
     "renderer_host/input/synthetic_pointer_action.cc",
     "renderer_host/input/synthetic_pointer_action.h",
+    "renderer_host/input/synthetic_pointer_driver.cc",
+    "renderer_host/input/synthetic_pointer_driver.h",
     "renderer_host/input/synthetic_smooth_drag_gesture.cc",
     "renderer_host/input/synthetic_smooth_drag_gesture.h",
     "renderer_host/input/synthetic_smooth_move_gesture.cc",
@@ -1047,8 +1047,8 @@ source_set("browser") {
     "renderer_host/input/synthetic_smooth_scroll_gesture.h",
     "renderer_host/input/synthetic_tap_gesture.cc",
     "renderer_host/input/synthetic_tap_gesture.h",
-    "renderer_host/input/synthetic_touch_pointer.cc",
-    "renderer_host/input/synthetic_touch_pointer.h",
+    "renderer_host/input/synthetic_touch_driver.cc",
+    "renderer_host/input/synthetic_touch_driver.h",
     "renderer_host/input/synthetic_touchpad_pinch_gesture.cc",
     "renderer_host/input/synthetic_touchpad_pinch_gesture.h",
     "renderer_host/input/synthetic_touchscreen_pinch_gesture.cc",

content/browser/renderer_host/input/synthetic_gesture_controller_unittest.cc

@@ -20,7 +20,6 @@
 #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_touch_pointer.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"

content/browser/renderer_host/input/synthetic_mouse_pointer.cc → content/browser/renderer_host/input/synthetic_mouse_driver.cc

@@ -2,37 +2,31 @@
 // 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_mouse_pointer.h"
+#include "content/browser/renderer_host/input/synthetic_mouse_driver.h"
 
 #include "content/browser/renderer_host/input/synthetic_gesture_target.h"
 
 namespace content {
 
-SyntheticMousePointer::SyntheticMousePointer() {}
+SyntheticMouseDriver::SyntheticMouseDriver() {}
 
-SyntheticMousePointer::~SyntheticMousePointer() {}
+SyntheticMouseDriver::~SyntheticMouseDriver() {}
 
-void SyntheticMousePointer::DispatchEvent(SyntheticGestureTarget* target,
-                                          const base::TimeTicks& timestamp) {
+void SyntheticMouseDriver::DispatchEvent(SyntheticGestureTarget* target,
+                                         const base::TimeTicks& timestamp) {
   mouse_event_.timeStampSeconds = ConvertTimestampToSeconds(timestamp);
   target->DispatchInputEventToPlatform(mouse_event_);
 }
 
-int SyntheticMousePointer::Press(float x,
-                                 float y,
-                                 SyntheticGestureTarget* target,
-                                 const base::TimeTicks& timestamp) {
+int SyntheticMouseDriver::Press(float x, float y) {
   mouse_event_ = SyntheticWebMouseEventBuilder::Build(
       blink::WebInputEvent::MouseDown, x, y, 0);
   mouse_event_.clickCount = 1;
   return 0;
 }
 
-void SyntheticMousePointer::Move(int index,
-                                 float x,
-                                 float y,
-                                 SyntheticGestureTarget* target,
-                                 const base::TimeTicks& timestamp) {
+void SyntheticMouseDriver::Move(float x, float y, int index) {
+  DCHECK_EQ(index, 0);
   blink::WebMouseEvent::Button button = mouse_event_.button;
   int click_count = mouse_event_.clickCount;
   mouse_event_ = SyntheticWebMouseEventBuilder::Build(
@@ -41,17 +35,36 @@ void SyntheticMousePointer::Move(int index,
   mouse_event_.clickCount = click_count;
 }
 
-void SyntheticMousePointer::Release(int index,
-                                    SyntheticGestureTarget* target,
-                                    const base::TimeTicks& timestamp) {
+void SyntheticMouseDriver::Release(int index) {
+  DCHECK_EQ(index, 0);
   mouse_event_ = SyntheticWebMouseEventBuilder::Build(
       blink::WebInputEvent::MouseUp, mouse_event_.x, mouse_event_.y, 0);
   mouse_event_.clickCount = 1;
 }
 
-SyntheticGestureParams::GestureSourceType SyntheticMousePointer::SourceType()
-    const {
-  return SyntheticGestureParams::MOUSE_INPUT;
+bool SyntheticMouseDriver::UserInputCheck(
+    const SyntheticPointerActionParams& params) const {
+  if (params.gesture_source_type != SyntheticGestureParams::MOUSE_INPUT)
+    return false;
+
+  if (params.pointer_action_type() ==
+      SyntheticPointerActionParams::PointerActionType::NOT_INITIALIZED) {
+    return false;
+  }
+
+  if (params.pointer_action_type() ==
+          SyntheticPointerActionParams::PointerActionType::PRESS &&
+      mouse_event_.clickCount > 0) {
+    return false;
+  }
+
+  if (params.pointer_action_type() ==
+          SyntheticPointerActionParams::PointerActionType::RELEASE &&
+      mouse_event_.clickCount <= 0) {
+    return false;
+  }
+
+  return true;
 }
 
 }  // namespace content

content/browser/renderer_host/input/synthetic_mouse_pointer.h → content/browser/renderer_host/input/synthetic_mouse_driver.h

@@ -2,44 +2,36 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_MOUSE_POINTER_H_
-#define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_MOUSE_POINTER_H_
+#ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_MOUSE_DRIVER_H_
+#define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_MOUSE_DRIVER_H_
 
 #include "base/macros.h"
-#include "content/browser/renderer_host/input/synthetic_pointer.h"
+#include "content/browser/renderer_host/input/synthetic_pointer_driver.h"
 #include "content/common/content_export.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 
 namespace content {
 
-class CONTENT_EXPORT SyntheticMousePointer : public SyntheticPointer {
+class CONTENT_EXPORT SyntheticMouseDriver : public SyntheticPointerDriver {
  public:
-  SyntheticMousePointer();
-  ~SyntheticMousePointer() override;
+  SyntheticMouseDriver();
+  ~SyntheticMouseDriver() override;
 
   void DispatchEvent(SyntheticGestureTarget* target,
                      const base::TimeTicks& timestamp) override;
 
-  int Press(float x,
-            float y,
-            SyntheticGestureTarget* target,
-            const base::TimeTicks& timestamp) override;
-  void Move(int index,
-            float x,
-            float y,
-            SyntheticGestureTarget* target,
-            const base::TimeTicks& timestamp) override;
-  void Release(int index,
-               SyntheticGestureTarget* target,
-               const base::TimeTicks& timestamp) override;
-
-  SyntheticGestureParams::GestureSourceType SourceType() const override;
+  int Press(float x, float y) override;
+  void Move(float x, float y, int index = 0) override;
+  void Release(int index = 0) override;
+
+  bool UserInputCheck(
+      const SyntheticPointerActionParams& params) const override;
 
  private:
   blink::WebMouseEvent mouse_event_;
-  DISALLOW_COPY_AND_ASSIGN(SyntheticMousePointer);
+  DISALLOW_COPY_AND_ASSIGN(SyntheticMouseDriver);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_MOUSE_POINTER_H_
+#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_MOUSE_DRIVER_H_

content/browser/renderer_host/input/synthetic_pointer_action.cc

@@ -15,81 +15,54 @@ SyntheticPointerAction::SyntheticPointerAction(
     : params_(params) {}
 
 SyntheticPointerAction::SyntheticPointerAction(
-    std::unique_ptr<std::vector<SyntheticPointerActionParams>> param_list,
-    SyntheticPointer* synthetic_pointer,
-    IndexMap* index_map)
-    : param_list_(std::move(param_list)),
-      synthetic_pointer_(synthetic_pointer),
-      index_map_(index_map) {}
+    std::vector<SyntheticPointerActionParams>* param_list,
+    SyntheticPointerDriver* synthetic_pointer_driver)
+    : param_list_(param_list),
+      synthetic_pointer_driver_(synthetic_pointer_driver) {}
 
 SyntheticPointerAction::~SyntheticPointerAction() {}
 
 SyntheticGesture::Result SyntheticPointerAction::ForwardInputEvents(
     const base::TimeTicks& timestamp,
     SyntheticGestureTarget* target) {
-  DCHECK(synthetic_pointer_);
+  DCHECK(synthetic_pointer_driver_);
   return ForwardTouchOrMouseInputEvents(timestamp, target);
 }
 
 SyntheticGesture::Result SyntheticPointerAction::ForwardTouchOrMouseInputEvents(
     const base::TimeTicks& timestamp,
     SyntheticGestureTarget* target) {
-  int point_index;
-  for (const SyntheticPointerActionParams& params : *param_list_) {
-    if (!UserInputCheck(params))
+  for (SyntheticPointerActionParams& params : *param_list_) {
+    if (!synthetic_pointer_driver_->UserInputCheck(params))
       return POINTER_ACTION_INPUT_INVALID;
 
     switch (params.pointer_action_type()) {
-      case SyntheticPointerActionParams::PointerActionType::PRESS:
-        point_index = synthetic_pointer_->Press(
-            params.position().x(), params.position().y(), target, timestamp);
-        SetPointIndex(params.index(), point_index);
+      case SyntheticPointerActionParams::PointerActionType::PRESS: {
+        int index = synthetic_pointer_driver_->Press(params.position().x(),
+                                                     params.position().y());
+        params.set_index(index);
         break;
+      }
       case SyntheticPointerActionParams::PointerActionType::MOVE:
-        point_index = GetPointIndex(params.index());
-        synthetic_pointer_->Move(point_index, params.position().x(),
-                                 params.position().y(), target, timestamp);
+        synthetic_pointer_driver_->Move(params.position().x(),
+                                        params.position().y(), params.index());
         break;
       case SyntheticPointerActionParams::PointerActionType::RELEASE:
-        point_index = GetPointIndex(params.index());
-        synthetic_pointer_->Release(point_index, target, timestamp);
-        SetPointIndex(params.index(), -1);
+        synthetic_pointer_driver_->Release(params.index());
+        // Only reset the index for touch pointers.
+        if (params.gesture_source_type != SyntheticGestureParams::MOUSE_INPUT)
+          params.set_index(-1);
         break;
-      default:
+      case SyntheticPointerActionParams::PointerActionType::IDLE:
+        break;
+      case SyntheticPointerActionParams::PointerActionType::NOT_INITIALIZED:
         return POINTER_ACTION_INPUT_INVALID;
+      case SyntheticPointerActionParams::PointerActionType::FINISH:
+        return GESTURE_FINISHED;
     }
   }
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
   return GESTURE_FINISHED;
 }
 
-bool SyntheticPointerAction::UserInputCheck(
-    const SyntheticPointerActionParams& params) {
-  if (params.index() < 0 || params.index() >= WebTouchEvent::kTouchesLengthCap)
-    return false;
-
-  if (synthetic_pointer_->SourceType() != params.gesture_source_type)
-    return false;
-
-  if (params.pointer_action_type() ==
-          SyntheticPointerActionParams::PointerActionType::PRESS &&
-      GetPointIndex(params.index()) >= 0) {
-    return false;
-  }
-
-  if (synthetic_pointer_->SourceType() == SyntheticGestureParams::TOUCH_INPUT &&
-      params.pointer_action_type() ==
-          SyntheticPointerActionParams::PointerActionType::MOVE &&
-      GetPointIndex(params.index()) < 0) {
-    return false;
-  }
-
-  if (params.pointer_action_type() ==
-          SyntheticPointerActionParams::PointerActionType::RELEASE &&
-      GetPointIndex(params.index()) < 0) {
-    return false;
-  }
-  return true;
-}
-
 }  // namespace content

content/browser/renderer_host/input/synthetic_pointer_action.h

@@ -5,11 +5,10 @@
 #ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_POINTER_ACTION_H_
 #define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_POINTER_ACTION_H_
 
-#include <array>
 #include "base/macros.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.h"
+#include "content/browser/renderer_host/input/synthetic_pointer_driver.h"
 #include "content/common/content_export.h"
 #include "content/common/input/synthetic_pointer_action_params.h"
 
@@ -19,12 +18,8 @@ namespace content {
 
 class CONTENT_EXPORT SyntheticPointerAction : public SyntheticGesture {
  public:
-  using IndexMap = std::array<int, WebTouchEvent::kTouchesLengthCap>;
-
-  SyntheticPointerAction(
-      std::unique_ptr<std::vector<SyntheticPointerActionParams>> param_list,
-      SyntheticPointer* synthetic_pointer,
-      IndexMap* index_map);
+  SyntheticPointerAction(std::vector<SyntheticPointerActionParams>* param_list,
+                         SyntheticPointerDriver* synthetic_pointer_driver);
   ~SyntheticPointerAction() override;
 
   SyntheticGesture::Result ForwardInputEvents(
@@ -36,26 +31,17 @@ class CONTENT_EXPORT SyntheticPointerAction : public SyntheticGesture {
   SyntheticGesture::Result ForwardTouchOrMouseInputEvents(
       const base::TimeTicks& timestamp,
       SyntheticGestureTarget* target);
-  int GetPointIndex(int index) const { return (*index_map_)[index]; }
-  void SetPointIndex(int index, int point_index) {
-    (*index_map_)[index] = point_index;
-  }
-
-  // Check if the user inputs in the SyntheticPointerActionParams can generate
-  // a valid sequence of pointer actions.
-  bool UserInputCheck(const SyntheticPointerActionParams& params);
 
   // SyntheticGestureController is responsible to create the
   // SyntheticPointerActions and control when to forward them.
-  // This will be passed from SyntheticGestureController, which will reset its
-  // value to push a new batch of action parameters.
-  // This contains a list of pointer actions which will be dispatched together.
-  const std::unique_ptr<std::vector<SyntheticPointerActionParams>> param_list_;
+
   // These two objects will be owned by SyntheticGestureController, which
   // will manage their lifetime by initiating them when it starts processing a
   // pointer action sequence and resetting them when it finishes.
-  SyntheticPointer* synthetic_pointer_;
-  IndexMap* index_map_;
+  // param_list_ contains a list of pointer actions which will be dispatched
+  // together.
+  std::vector<SyntheticPointerActionParams>* param_list_;
+  SyntheticPointerDriver* synthetic_pointer_driver_;
 
   SyntheticPointerActionParams params_;
 

content/browser/renderer_host/input/synthetic_pointer.cc → content/browser/renderer_host/input/synthetic_pointer_driver.cc

@@ -2,33 +2,32 @@
 // 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_pointer.h"
+#include "content/browser/renderer_host/input/synthetic_pointer_driver.h"
 
 #include "base/memory/ptr_util.h"
-#include "content/browser/renderer_host/input/synthetic_mouse_pointer.h"
-#include "content/browser/renderer_host/input/synthetic_touch_pointer.h"
-#include "third_party/WebKit/public/platform/WebInputEvent.h"
+#include "content/browser/renderer_host/input/synthetic_mouse_driver.h"
+#include "content/browser/renderer_host/input/synthetic_touch_driver.h"
 
 namespace content {
 
-SyntheticPointer::SyntheticPointer() {}
-SyntheticPointer::~SyntheticPointer() {}
+SyntheticPointerDriver::SyntheticPointerDriver() {}
+SyntheticPointerDriver::~SyntheticPointerDriver() {}
 
 // static
-std::unique_ptr<SyntheticPointer> SyntheticPointer::Create(
+std::unique_ptr<SyntheticPointerDriver> SyntheticPointerDriver::Create(
     SyntheticGestureParams::GestureSourceType gesture_source_type) {
   if (gesture_source_type == SyntheticGestureParams::TOUCH_INPUT) {
-    return base::MakeUnique<SyntheticTouchPointer>();
+    return base::MakeUnique<SyntheticTouchDriver>();
   } else if (gesture_source_type == SyntheticGestureParams::MOUSE_INPUT) {
-    return base::MakeUnique<SyntheticMousePointer>();
+    return base::MakeUnique<SyntheticMouseDriver>();
   } else {
     NOTREACHED() << "Invalid gesture source type";
-    return std::unique_ptr<SyntheticPointer>();
+    return std::unique_ptr<SyntheticPointerDriver>();
   }
 }
 
 // static
-double SyntheticPointer::ConvertTimestampToSeconds(
+double SyntheticPointerDriver::ConvertTimestampToSeconds(
     const base::TimeTicks& timestamp) {
   return (timestamp - base::TimeTicks()).InSecondsF();
 }

content/browser/renderer_host/input/synthetic_pointer.h → content/browser/renderer_host/input/synthetic_pointer_driver.h

@@ -2,53 +2,48 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_POINTER_H_
-#define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_POINTER_H_
+#ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_POINTER_DRIVER_H_
+#define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_POINTER_DRIVER_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #include "content/common/content_export.h"
 #include "content/common/input/synthetic_gesture_params.h"
+#include "content/common/input/synthetic_pointer_action_params.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 
 namespace content {
 
 class SyntheticGestureTarget;
 
-class CONTENT_EXPORT SyntheticPointer {
+class CONTENT_EXPORT SyntheticPointerDriver {
  public:
-  SyntheticPointer();
-  virtual ~SyntheticPointer();
+  SyntheticPointerDriver();
+  virtual ~SyntheticPointerDriver();
 
-  static std::unique_ptr<SyntheticPointer> Create(
+  static std::unique_ptr<SyntheticPointerDriver> Create(
       SyntheticGestureParams::GestureSourceType gesture_source_type);
 
   virtual void DispatchEvent(SyntheticGestureTarget* target,
                              const base::TimeTicks& timestamp) = 0;
 
-  virtual int Press(float x,
-                    float y,
-                    SyntheticGestureTarget* target,
-                    const base::TimeTicks& timestamp) = 0;
-  virtual void Move(int index,
-                    float x,
-                    float y,
-                    SyntheticGestureTarget* target,
-                    const base::TimeTicks& timestamp) = 0;
-  virtual void Release(int index,
-                       SyntheticGestureTarget* target,
-                       const base::TimeTicks& timestamp) = 0;
-
-  virtual SyntheticGestureParams::GestureSourceType SourceType() const = 0;
+  virtual int Press(float x, float y) = 0;
+  virtual void Move(float x, float y, int index = 0) = 0;
+  virtual void Release(int index = 0) = 0;
+
+  // Check if the user inputs in the SyntheticPointerActionParams can generate
+  // a valid sequence of pointer actions.
+  virtual bool UserInputCheck(
+      const SyntheticPointerActionParams& params) const = 0;
 
  protected:
   static double ConvertTimestampToSeconds(const base::TimeTicks& timestamp);
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(SyntheticPointer);
+  DISALLOW_COPY_AND_ASSIGN(SyntheticPointerDriver);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_POINTER_H_
+#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_POINTER_DRIVER_H_

content/browser/renderer_host/input/synthetic_smooth_move_gesture.cc

@@ -67,15 +67,15 @@ SyntheticGesture::Result SyntheticSmoothMoveGesture::ForwardInputEvents(
 
   switch (params_.input_type) {
     case SyntheticSmoothMoveGestureParams::TOUCH_INPUT:
-      if (!synthetic_pointer_)
-        synthetic_pointer_ =
-            SyntheticPointer::Create(SyntheticGestureParams::TOUCH_INPUT);
+      if (!synthetic_pointer_driver_)
+        synthetic_pointer_driver_ =
+            SyntheticPointerDriver::Create(SyntheticGestureParams::TOUCH_INPUT);
       ForwardTouchInputEvents(timestamp, target);
       break;
     case SyntheticSmoothMoveGestureParams::MOUSE_DRAG_INPUT:
-      if (!synthetic_pointer_)
-        synthetic_pointer_ =
-            SyntheticPointer::Create(SyntheticGestureParams::MOUSE_INPUT);
+      if (!synthetic_pointer_driver_)
+        synthetic_pointer_driver_ =
+            SyntheticPointerDriver::Create(SyntheticGestureParams::MOUSE_INPUT);
       ForwardMouseClickInputEvents(timestamp, target);
       break;
     case SyntheticSmoothMoveGestureParams::MOUSE_WHEEL_INPUT:
@@ -256,10 +256,9 @@ void SyntheticSmoothMoveGesture::ForwardMouseWheelEvent(
 void SyntheticSmoothMoveGesture::PressPoint(SyntheticGestureTarget* target,
                                             const base::TimeTicks& timestamp) {
   DCHECK_EQ(current_move_segment_, 0);
-  synthetic_pointer_->Press(current_move_segment_start_position_.x(),
-                            current_move_segment_start_position_.y(), target,
-                            timestamp);
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->Press(current_move_segment_start_position_.x(),
+                                   current_move_segment_start_position_.y());
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticSmoothMoveGesture::MovePoint(SyntheticGestureTarget* target,
@@ -268,9 +267,8 @@ void SyntheticSmoothMoveGesture::MovePoint(SyntheticGestureTarget* target,
   DCHECK_GE(current_move_segment_, 0);
   DCHECK_LT(current_move_segment_, static_cast<int>(params_.distances.size()));
   gfx::PointF new_position = current_move_segment_start_position_ + delta;
-  synthetic_pointer_->Move(0, new_position.x(), new_position.y(), target,
-                           timestamp);
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->Move(new_position.x(), new_position.y());
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticSmoothMoveGesture::ReleasePoint(
@@ -284,8 +282,8 @@ void SyntheticSmoothMoveGesture::ReleasePoint(
     position = current_move_segment_start_position_ +
                GetPositionDeltaAtTime(timestamp);
   }
-  synthetic_pointer_->Release(0, target, timestamp);
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->Release();
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticSmoothMoveGesture::AddTouchSlopToFirstDistance(

content/browser/renderer_host/input/synthetic_smooth_move_gesture.h

@@ -11,7 +11,7 @@
 #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.h"
+#include "content/browser/renderer_host/input/synthetic_pointer_driver.h"
 #include "content/common/content_export.h"
 #include "content/common/input/synthetic_smooth_drag_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
@@ -93,7 +93,7 @@ class CONTENT_EXPORT SyntheticSmoothMoveGesture : public SyntheticGesture {
   bool MoveIsNoOp() const;
 
   SyntheticSmoothMoveGestureParams params_;
-  std::unique_ptr<SyntheticPointer> synthetic_pointer_;
+  std::unique_ptr<SyntheticPointerDriver> synthetic_pointer_driver_;
   // Used for mouse input.
   gfx::Vector2d current_move_segment_total_delta_discrete_;
   // Used for touch input.

content/browser/renderer_host/input/synthetic_tap_gesture.cc

@@ -32,8 +32,9 @@ SyntheticGesture::Result SyntheticTapGesture::ForwardInputEvents(
 
   DCHECK_NE(gesture_source_type_, SyntheticGestureParams::DEFAULT_INPUT);
 
-  if (!synthetic_pointer_)
-    synthetic_pointer_ = SyntheticPointer::Create(gesture_source_type_);
+  if (!synthetic_pointer_driver_)
+    synthetic_pointer_driver_ =
+        SyntheticPointerDriver::Create(gesture_source_type_);
 
   if (gesture_source_type_ == SyntheticGestureParams::TOUCH_INPUT ||
       gesture_source_type_ == SyntheticGestureParams::MOUSE_INPUT)
@@ -49,13 +50,13 @@ void SyntheticTapGesture::ForwardTouchOrMouseInputEvents(
     const base::TimeTicks& timestamp, SyntheticGestureTarget* target) {
   switch (state_) {
     case PRESS:
-      synthetic_pointer_->Press(params_.position.x(), params_.position.y(),
-                                target, timestamp);
-      synthetic_pointer_->DispatchEvent(target, timestamp);
+      synthetic_pointer_driver_->Press(params_.position.x(),
+                                       params_.position.y());
+      synthetic_pointer_driver_->DispatchEvent(target, timestamp);
       // Release immediately if duration is 0.
       if (params_.duration_ms == 0) {
-        synthetic_pointer_->Release(0, target, timestamp);
-        synthetic_pointer_->DispatchEvent(target, timestamp);
+        synthetic_pointer_driver_->Release();
+        synthetic_pointer_driver_->DispatchEvent(target, timestamp);
         state_ = DONE;
       } else {
         start_time_ = timestamp;
@@ -64,8 +65,9 @@ void SyntheticTapGesture::ForwardTouchOrMouseInputEvents(
       break;
     case WAITING_TO_RELEASE:
       if (timestamp - start_time_ >= GetDuration()) {
-        synthetic_pointer_->Release(0, target, start_time_ + GetDuration());
-        synthetic_pointer_->DispatchEvent(target, start_time_ + GetDuration());
+        synthetic_pointer_driver_->Release();
+        synthetic_pointer_driver_->DispatchEvent(target,
+                                                 start_time_ + GetDuration());
         state_ = DONE;
       }
       break;

content/browser/renderer_host/input/synthetic_tap_gesture.h

@@ -8,7 +8,7 @@
 #include "base/macros.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.h"
+#include "content/browser/renderer_host/input/synthetic_pointer_driver.h"
 #include "content/common/content_export.h"
 #include "content/common/input/synthetic_tap_gesture_params.h"
 
@@ -37,7 +37,7 @@ class CONTENT_EXPORT SyntheticTapGesture : public SyntheticGesture {
   base::TimeDelta GetDuration() const;
 
   SyntheticTapGestureParams params_;
-  std::unique_ptr<SyntheticPointer> synthetic_pointer_;
+  std::unique_ptr<SyntheticPointerDriver> synthetic_pointer_driver_;
   base::TimeTicks start_time_;
   SyntheticGestureParams::GestureSourceType gesture_source_type_;
   GestureState state_;

content/browser/renderer_host/input/synthetic_touch_driver.cc

+// Copyright 2015 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_touch_driver.h"
+
+#include "content/browser/renderer_host/input/synthetic_gesture_target.h"
+
+using blink::WebTouchEvent;
+
+namespace content {
+
+SyntheticTouchDriver::SyntheticTouchDriver() {}
+
+SyntheticTouchDriver::SyntheticTouchDriver(SyntheticWebTouchEvent touch_event)
+    : touch_event_(touch_event) {}
+
+SyntheticTouchDriver::~SyntheticTouchDriver() {}
+
+void SyntheticTouchDriver::DispatchEvent(SyntheticGestureTarget* target,
+                                         const base::TimeTicks& timestamp) {
+  touch_event_.timeStampSeconds = ConvertTimestampToSeconds(timestamp);
+  target->DispatchInputEventToPlatform(touch_event_);
+}
+
+int SyntheticTouchDriver::Press(float x, float y) {
+  int index = touch_event_.PressPoint(x, y);
+  return index;
+}
+
+void SyntheticTouchDriver::Move(float x, float y, int index) {
+  touch_event_.MovePoint(index, x, y);
+}
+
+void SyntheticTouchDriver::Release(int index) {
+  touch_event_.ReleasePoint(index);
+}
+
+bool SyntheticTouchDriver::UserInputCheck(
+    const SyntheticPointerActionParams& params) const {
+  DCHECK_GE(params.index(), -1);
+  DCHECK_LT(params.index(), WebTouchEvent::kTouchesLengthCap);
+  if (params.gesture_source_type != SyntheticGestureParams::TOUCH_INPUT)
+    return false;
+
+  if (params.pointer_action_type() ==
+      SyntheticPointerActionParams::PointerActionType::NOT_INITIALIZED) {
+    return false;
+  }
+
+  if (params.pointer_action_type() ==
+          SyntheticPointerActionParams::PointerActionType::PRESS &&
+      params.index() >= 0) {
+    return false;
+  }
+
+  if (params.pointer_action_type() ==
+          SyntheticPointerActionParams::PointerActionType::MOVE &&
+      params.index() == -1) {
+    return false;
+  }
+
+  if (params.pointer_action_type() ==
+          SyntheticPointerActionParams::PointerActionType::RELEASE &&
+      params.index() == -1) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace content

content/browser/renderer_host/input/synthetic_touch_pointer.h → content/browser/renderer_host/input/synthetic_touch_driver.h

@@ -2,46 +2,38 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_TOUCH_POINTER_H_
-#define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_TOUCH_POINTER_H_
+#ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_TOUCH_DRIVER_H_
+#define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_TOUCH_DRIVER_H_
 
+#include <array>
 #include "base/macros.h"
-#include "content/browser/renderer_host/input/synthetic_pointer.h"
+#include "content/browser/renderer_host/input/synthetic_pointer_driver.h"
 #include "content/common/content_export.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 
 namespace content {
 
-class CONTENT_EXPORT SyntheticTouchPointer : public SyntheticPointer {
+class CONTENT_EXPORT SyntheticTouchDriver : public SyntheticPointerDriver {
  public:
-  SyntheticTouchPointer();
-  explicit SyntheticTouchPointer(SyntheticWebTouchEvent touch_event);
-  ~SyntheticTouchPointer() override;
+  SyntheticTouchDriver();
+  explicit SyntheticTouchDriver(SyntheticWebTouchEvent touch_event);
+  ~SyntheticTouchDriver() override;
 
   void DispatchEvent(SyntheticGestureTarget* target,
                      const base::TimeTicks& timestamp) override;
 
-  int Press(float x,
-            float y,
-            SyntheticGestureTarget* target,
-            const base::TimeTicks& timestamp) override;
-  void Move(int index,
-            float x,
-            float y,
-            SyntheticGestureTarget* target,
-            const base::TimeTicks& timestamp) override;
-  void Release(int index,
-               SyntheticGestureTarget* target,
-               const base::TimeTicks& timestamp) override;
-
-  SyntheticGestureParams::GestureSourceType SourceType() const override;
+  int Press(float x, float y) override;
+  void Move(float x, float y, int index) override;
+  void Release(int index) override;
+
+  bool UserInputCheck(
+      const SyntheticPointerActionParams& params) const override;
 
  private:
   SyntheticWebTouchEvent touch_event_;
-
-  DISALLOW_COPY_AND_ASSIGN(SyntheticTouchPointer);
+  DISALLOW_COPY_AND_ASSIGN(SyntheticTouchDriver);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_COMMON_INPUT_SYNTHETIC_TOUCH_POINTER_H_
+#endif  // CONTENT_COMMON_INPUT_SYNTHETIC_TOUCH_DRIVER_H_

content/browser/renderer_host/input/synthetic_touch_pointer.cc

-// Copyright 2015 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_touch_pointer.h"
-
-#include "content/browser/renderer_host/input/synthetic_gesture_target.h"
-
-namespace content {
-
-SyntheticTouchPointer::SyntheticTouchPointer() {}
-
-SyntheticTouchPointer::SyntheticTouchPointer(SyntheticWebTouchEvent touch_event)
-    : touch_event_(touch_event) {}
-
-SyntheticTouchPointer::~SyntheticTouchPointer() {}
-
-void SyntheticTouchPointer::DispatchEvent(SyntheticGestureTarget* target,
-                                          const base::TimeTicks& timestamp) {
-  touch_event_.timeStampSeconds = ConvertTimestampToSeconds(timestamp);
-  target->DispatchInputEventToPlatform(touch_event_);
-}
-
-int SyntheticTouchPointer::Press(float x,
-                                 float y,
-                                 SyntheticGestureTarget* target,
-                                 const base::TimeTicks& timestamp) {
-  int index = touch_event_.PressPoint(x, y);
-  return index;
-}
-
-void SyntheticTouchPointer::Move(int index,
-                                 float x,
-                                 float y,
-                                 SyntheticGestureTarget* target,
-                                 const base::TimeTicks& timestamp) {
-  touch_event_.MovePoint(index, x, y);
-}
-
-void SyntheticTouchPointer::Release(int index,
-                                    SyntheticGestureTarget* target,
-                                    const base::TimeTicks& timestamp) {
-  touch_event_.ReleasePoint(index);
-}
-
-SyntheticGestureParams::GestureSourceType SyntheticTouchPointer::SourceType()
-    const {
-  return SyntheticGestureParams::TOUCH_INPUT;
-}
-
-}  // namespace content

content/browser/renderer_host/input/synthetic_touchscreen_pinch_gesture.cc

@@ -40,8 +40,9 @@ SyntheticGesture::Result SyntheticTouchscreenPinchGesture::ForwardInputEvents(
 
   DCHECK_NE(gesture_source_type_, SyntheticGestureParams::DEFAULT_INPUT);
 
-  if (!synthetic_pointer_)
-    synthetic_pointer_ = SyntheticPointer::Create(gesture_source_type_);
+  if (!synthetic_pointer_driver_)
+    synthetic_pointer_driver_ =
+        SyntheticPointerDriver::Create(gesture_source_type_);
 
   if (gesture_source_type_ == SyntheticGestureParams::TOUCH_INPUT) {
     ForwardTouchInputEvents(timestamp, target);
@@ -86,9 +87,9 @@ void SyntheticTouchscreenPinchGesture::ForwardTouchInputEvents(
 void SyntheticTouchscreenPinchGesture::PressTouchPoints(
     SyntheticGestureTarget* target,
     const base::TimeTicks& timestamp) {
-  synthetic_pointer_->Press(params_.anchor.x(), start_y_0_, target, timestamp);
-  synthetic_pointer_->Press(params_.anchor.x(), start_y_1_, target, timestamp);
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->Press(params_.anchor.x(), start_y_0_);
+  synthetic_pointer_driver_->Press(params_.anchor.x(), start_y_1_);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticTouchscreenPinchGesture::MoveTouchPoints(
@@ -99,19 +100,17 @@ void SyntheticTouchscreenPinchGesture::MoveTouchPoints(
   float current_y_0 = start_y_0_ + delta;
   float current_y_1 = start_y_1_ - delta;
 
-  synthetic_pointer_->Move(0, params_.anchor.x(), current_y_0, target,
-                           timestamp);
-  synthetic_pointer_->Move(1, params_.anchor.x(), current_y_1, target,
-                           timestamp);
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->Move(params_.anchor.x(), current_y_0, 0);
+  synthetic_pointer_driver_->Move(params_.anchor.x(), current_y_1, 1);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticTouchscreenPinchGesture::ReleaseTouchPoints(
     SyntheticGestureTarget* target,
     const base::TimeTicks& timestamp) {
-  synthetic_pointer_->Release(0, target, timestamp);
-  synthetic_pointer_->Release(1, target, timestamp);
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->Release(0);
+  synthetic_pointer_driver_->Release(1);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticTouchscreenPinchGesture::SetupCoordinatesAndStopTime(

content/browser/renderer_host/input/synthetic_touchscreen_pinch_gesture.h

@@ -9,7 +9,7 @@
 #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.h"
+#include "content/browser/renderer_host/input/synthetic_pointer_driver.h"
 #include "content/common/content_export.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
@@ -48,7 +48,7 @@ class CONTENT_EXPORT SyntheticTouchscreenPinchGesture
   bool HasReachedTarget(const base::TimeTicks& timestamp) const;
 
   SyntheticPinchGestureParams params_;
-  std::unique_ptr<SyntheticPointer> synthetic_pointer_;
+  std::unique_ptr<SyntheticPointerDriver> synthetic_pointer_driver_;
   float start_y_0_;
   float start_y_1_;
   float max_pointer_delta_0_;

content/common/input/input_param_traits_unittest.cc

@@ -91,8 +91,6 @@ class InputParamTraitsTest : public testing::Test {
       EXPECT_EQ(a->position(), b->position());
     }
     if (a->pointer_action_type() !=
-            SyntheticPointerActionParams::PointerActionType::PROCESS &&
-        a->pointer_action_type() !=
             SyntheticPointerActionParams::PointerActionType::FINISH) {
       EXPECT_EQ(a->index(), b->index());
     }
@@ -278,8 +276,8 @@ TEST_F(InputParamTraitsTest, SyntheticTapGestureParams) {
 TEST_F(InputParamTraitsTest, SyntheticPointerActionParamsMove) {
   std::unique_ptr<SyntheticPointerActionParams> gesture_params =
       base::MakeUnique<SyntheticPointerActionParams>(
-          SyntheticPointerActionParams::PointerActionType::MOVE);
-  gesture_params->gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+          SyntheticPointerActionParams::PointerActionType::MOVE,
+          SyntheticGestureParams::TOUCH_INPUT);
   gesture_params->set_position(gfx::PointF(356, 287));
   gesture_params->set_index(0);
   ASSERT_EQ(SyntheticGestureParams::POINTER_ACTION,
@@ -292,8 +290,8 @@ TEST_F(InputParamTraitsTest, SyntheticPointerActionParamsMove) {
 TEST_F(InputParamTraitsTest, SyntheticPointerActionParamsRelease) {
   std::unique_ptr<SyntheticPointerActionParams> gesture_params =
       base::MakeUnique<SyntheticPointerActionParams>(
-          SyntheticPointerActionParams::PointerActionType::RELEASE);
-  gesture_params->gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+          SyntheticPointerActionParams::PointerActionType::RELEASE,
+          SyntheticGestureParams::TOUCH_INPUT);
   gesture_params->set_index(0);
   ASSERT_EQ(SyntheticGestureParams::POINTER_ACTION,
             gesture_params->GetGestureType());
@@ -305,8 +303,9 @@ TEST_F(InputParamTraitsTest, SyntheticPointerActionParamsRelease) {
 TEST_F(InputParamTraitsTest, SyntheticPointerActionParamsProcess) {
   std::unique_ptr<SyntheticPointerActionParams> gesture_params =
       base::MakeUnique<SyntheticPointerActionParams>(
-          SyntheticPointerActionParams::PointerActionType::PROCESS);
-  gesture_params->gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+          SyntheticPointerActionParams::PointerActionType::IDLE,
+          SyntheticGestureParams::TOUCH_INPUT);
+  gesture_params->set_index(0);
   ASSERT_EQ(SyntheticGestureParams::POINTER_ACTION,
             gesture_params->GetGestureType());
   SyntheticGesturePacket packet_in;
@@ -317,8 +316,8 @@ TEST_F(InputParamTraitsTest, SyntheticPointerActionParamsProcess) {
 TEST_F(InputParamTraitsTest, SyntheticPointerActionParamsFinish) {
   std::unique_ptr<SyntheticPointerActionParams> gesture_params =
       base::MakeUnique<SyntheticPointerActionParams>(
-          SyntheticPointerActionParams::PointerActionType::FINISH);
-  gesture_params->gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+          SyntheticPointerActionParams::PointerActionType::FINISH,
+          SyntheticGestureParams::TOUCH_INPUT);
   ASSERT_EQ(SyntheticGestureParams::POINTER_ACTION,
             gesture_params->GetGestureType());
   SyntheticGesturePacket packet_in;

content/common/input/synthetic_pointer_action_params.cc

@@ -7,11 +7,17 @@
 namespace content {
 
 SyntheticPointerActionParams::SyntheticPointerActionParams()
-    : pointer_action_type_(PointerActionType::NOT_INITIALIZED), index_(-1) {}
+    : pointer_action_type_(PointerActionType::NOT_INITIALIZED) {
+  index_ = gesture_source_type != MOUSE_INPUT ? -1 : 0;
+}
 
 SyntheticPointerActionParams::SyntheticPointerActionParams(
-    PointerActionType type)
-    : pointer_action_type_(type), index_(-1) {}
+    PointerActionType action_type,
+    GestureSourceType source_type)
+    : pointer_action_type_(action_type) {
+  gesture_source_type = source_type;
+  index_ = gesture_source_type != MOUSE_INPUT ? -1 : 0;
+}
 
 SyntheticPointerActionParams::SyntheticPointerActionParams(
     const SyntheticPointerActionParams& other)
@@ -24,9 +30,11 @@ SyntheticPointerActionParams::SyntheticPointerActionParams(
       position_ = other.position();
       break;
     case PointerActionType::RELEASE:
+    case PointerActionType::IDLE:
+    case PointerActionType::NOT_INITIALIZED:
       index_ = other.index();
       break;
-    default:
+    case PointerActionType::FINISH:
       break;
   }
 }

content/common/input/synthetic_pointer_action_params.h

@@ -21,21 +21,22 @@ namespace content {
 struct CONTENT_EXPORT SyntheticPointerActionParams
     : public SyntheticGestureParams {
  public:
-  // Actions are queued up until we receive a PROCESS action, at which point
-  // we'll dispatch all queued events. A FINISH action will be received when
-  // we reach the end of the action sequence.
+  // All the pointer actions that will be dispatched together will be grouped
+  // in an array. A FINISH action will be received when we reach the end of the
+  // action sequence.
   enum class PointerActionType {
     NOT_INITIALIZED,
     PRESS,
     MOVE,
     RELEASE,
-    PROCESS,
+    IDLE,
     FINISH,
     POINTER_ACTION_TYPE_MAX = FINISH
   };
 
   SyntheticPointerActionParams();
-  explicit SyntheticPointerActionParams(PointerActionType type);
+  SyntheticPointerActionParams(PointerActionType action_type,
+                               GestureSourceType source_type);
   SyntheticPointerActionParams(const SyntheticPointerActionParams& other);
   ~SyntheticPointerActionParams() override;
 
@@ -49,9 +50,8 @@ struct CONTENT_EXPORT SyntheticPointerActionParams
   }
 
   void set_index(int index) {
-    DCHECK(pointer_action_type_ != PointerActionType::PROCESS &&
-           pointer_action_type_ != PointerActionType::FINISH);
-    // For all mouse pointer actions, the index should always be 0.
+    DCHECK(pointer_action_type_ != PointerActionType::FINISH);
+    // For mouse pointers, the index should always be 0.
     DCHECK(gesture_source_type != MOUSE_INPUT || index == 0);
     index_ = index;
   }
@@ -65,8 +65,8 @@ struct CONTENT_EXPORT SyntheticPointerActionParams
   PointerActionType pointer_action_type() const { return pointer_action_type_; }
 
   int index() const {
-    DCHECK(pointer_action_type_ != PointerActionType::PROCESS &&
-           pointer_action_type_ != PointerActionType::FINISH);
+    DCHECK(pointer_action_type_ != PointerActionType::FINISH);
+    // For mouse pointers, the index should always be 0.
     DCHECK(gesture_source_type != MOUSE_INPUT || index_ == 0);
     return index_;
   }

tools/ipc_fuzzer/fuzzer/fuzzer.cc

@@ -954,7 +954,8 @@ struct FuzzTraits<content::SyntheticGesturePacket> {
         if (!FuzzParam(&index, fuzzer))
           return false;
         content::SyntheticPointerActionParams* params =
-            new content::SyntheticPointerActionParams(action_type);
+            new content::SyntheticPointerActionParams();
+        params->set_pointer_action_type(action_type);
         params->set_position(position);
         params->set_index(index);
         gesture_params.reset(params);