Make SyntheticPointerAction to flush the pointer action sequence

content/browser/renderer_host/input/synthetic_pointer_action.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_pointer_action.h"
 
 #include "base/logging.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/events/latency_info.h"
 
 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;
+  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_);
 
-    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);
+    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