Make SyntheticPointerAction to flush the pointer action sequence

content/browser/renderer_host/input/synthetic_pointer_action.cc

Index: content/browser/renderer_host/input/synthetic_pointer_action.cc
diff --git a/content/browser/renderer_host/input/synthetic_pointer_action.cc b/content/browser/renderer_host/input/synthetic_pointer_action.cc
index 59981ceeacdc90d3321f16c58e7ec91ae2b2faa7..bedd2f13ee7b2c8920e2972d11a697f5e7d1dbb2 100644
--- a/content/browser/renderer_host/input/synthetic_pointer_action.cc
+++ b/content/browser/renderer_host/input/synthetic_pointer_action.cc
@@ -11,58 +11,83 @@
 namespace content {
 
 SyntheticPointerAction::SyntheticPointerAction(
-    const SyntheticPointerActionParams& params)
-    : params_(params) {}
-
-SyntheticPointerAction::SyntheticPointerAction(
-    std::vector<SyntheticPointerActionParams>* param_list,
-    SyntheticPointerDriver* synthetic_pointer_driver)
-    : param_list_(param_list),
-      synthetic_pointer_driver_(synthetic_pointer_driver) {}
+    const SyntheticPointerActionListParams& params)
+    : params_(params),
+      gesture_source_type_(SyntheticGestureParams::DEFAULT_INPUT),
+      state_(SETUP),
+      count_(0U) {}
 
 SyntheticPointerAction::~SyntheticPointerAction() {}
 
 SyntheticGesture::Result SyntheticPointerAction::ForwardInputEvents(
     const base::TimeTicks& timestamp,
     SyntheticGestureTarget* target) {
-  DCHECK(synthetic_pointer_driver_);
-  return ForwardTouchOrMouseInputEvents(timestamp, target);
+  if (state_ == SETUP) {

[Navid Zolghadr, 2016/12/06 17:05:38]

I assume this function needs to be called multiple times to flush all the
vectors. Where do we use this function beside the tests? Should there be some
sort of for loop or something?

[lanwei, 2016/12/07 19:04:27]

https://codesearch.chromium.org/chromium/src/content/browser/renderer_host/in...

The flush function in the SyntheticGestureController will check the result of
this function and decide should flush again or call the callback.

[Navid Zolghadr, 2016/12/09 16:04:47]

So should that change be part of this patch or are you planning to update it
later?

+    gesture_source_type_ = params_.gesture_source_type;
+    if (gesture_source_type_ == SyntheticGestureParams::DEFAULT_INPUT)
+      gesture_source_type_ = target->GetDefaultSyntheticGestureSourceType();
+
+    state_ = RUNNING;
+  }
+
+  DCHECK_NE(gesture_source_type_, SyntheticGestureParams::DEFAULT_INPUT);
+
+  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) {
+    state_ = ForwardTouchOrMouseInputEvents(timestamp, target);
+  } else {
+    return SyntheticGesture::GESTURE_SOURCE_TYPE_NOT_IMPLEMENTED;
+  }
+
+  if (state_ == INVALID)
+    return POINTER_ACTION_INPUT_INVALID;
+
+  return (state_ == DONE) ? SyntheticGesture::GESTURE_FINISHED
+                          : SyntheticGesture::GESTURE_RUNNING;
 }
 
-SyntheticGesture::Result SyntheticPointerAction::ForwardTouchOrMouseInputEvents(
+SyntheticPointerAction::GestureState
+SyntheticPointerAction::ForwardTouchOrMouseInputEvents(
     const base::TimeTicks& timestamp,
     SyntheticGestureTarget* target) {
-  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: {
-        int index = synthetic_pointer_driver_->Press(params.position().x(),
-                                                     params.position().y());
-        params.set_index(index);
+  DCHECK_GE(count_, 0U);
+  DCHECK_LT(count_, params_.params.size());
+  SyntheticPointerActionListParams::ParamList& param_list =
+      params_.params[count_];
+  for (SyntheticPointerActionParams& param : param_list) {
+    if (param.gesture_source_type() == SyntheticGestureParams::DEFAULT_INPUT)
+      param.set_gesture_source_type(gesture_source_type_);
+
+    if (!synthetic_pointer_driver_->UserInputCheck(param))
+      return INVALID;
+
+    switch (param.pointer_action_type()) {
+      case SyntheticPointerActionParams::PointerActionType::PRESS:
+        synthetic_pointer_driver_->Press(param.position().x(),
+                                         param.position().y(), param.index());
         break;
-      }
       case SyntheticPointerActionParams::PointerActionType::MOVE:
-        synthetic_pointer_driver_->Move(params.position().x(),
-                                        params.position().y(), params.index());
+        synthetic_pointer_driver_->Move(param.position().x(),
+                                        param.position().y(), param.index());
         break;
       case SyntheticPointerActionParams::PointerActionType::RELEASE:
-        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;
-      case SyntheticPointerActionParams::PointerActionType::IDLE:
+        synthetic_pointer_driver_->Release(param.index());
         break;
       case SyntheticPointerActionParams::PointerActionType::NOT_INITIALIZED:
-        return POINTER_ACTION_INPUT_INVALID;
-      case SyntheticPointerActionParams::PointerActionType::FINISH:
-        return GESTURE_FINISHED;
+        return INVALID;
     }
   }
   synthetic_pointer_driver_->DispatchEvent(target, timestamp);
-  return GESTURE_FINISHED;
+  count_++;
+  if (count_ == params_.params.size())
+    return DONE;
+  else
+    return RUNNING;
 }
 
-}  // namespace content
+}  // namespace content