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) {
+    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_);

[tdresser, 2016/12/13 14:37:43]

Should this happen only when the state is SETUP?

[lanwei, 2016/12/18 17:35:55]

Done.

+  }
+
+  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;

[tdresser, 2016/12/13 14:37:43]

Could we move this return up by the DCHECK that we aren't DEFAULT_INPUT?
Then we don't need to check the gesture_source_type here.

[lanwei, 2016/12/18 17:35:55]

Done.

+  }
+
+  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_);

[tdresser, 2016/12/13 14:37:43]

I know we've talked about this before, but I can't remember. Why do we need the
gesture_source_type in each param as well as in the SyntheticPointerAction?
Can't we only put it in one or the other, ideally in the SyntheticPointerAction?

Do we allow mixing input types?

[lanwei, 2016/12/18 17:35:55]

Yes, the reason we have it in both SyntheticPointerActionParams and
SyntheticPointerAction, is we want to support mixing input types later, so each
SyntheticPointerActionParams should specify its own source type. But now we only
support one type, so I make the SyntheticPointerAction has one source type.
Should I remove the type from SyntheticPointerActionParams, and add it later,
when we   start to support multi-type.

[tdresser, 2016/12/19 15:11:53]

Yeah, let's remove it for now.

 
-    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