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/web/WebInputEvent.h"
 #include "ui/events/latency_info.h"
 
 namespace content {
 
 SyntheticPointerAction::SyntheticPointerAction(
-    const SyntheticPointerActionParams& params)
+    const SyntheticPointerActionListParams& params)
     : params_(params) {}
 
 SyntheticPointerAction::SyntheticPointerAction(
-    std::unique_ptr<std::vector<SyntheticPointerActionParams>> param_list,
+    const SyntheticPointerActionListParams& params,
     SyntheticPointer* synthetic_pointer,
     IndexMap* index_map)
-    : param_list_(std::move(param_list)),
+    : params_(params),
       synthetic_pointer_(synthetic_pointer),
       index_map_(index_map) {}
 
 SyntheticPointerAction::~SyntheticPointerAction() {}
 
 SyntheticGesture::Result SyntheticPointerAction::ForwardInputEvents(
     const base::TimeTicks& timestamp,
     SyntheticGestureTarget* target) {
   DCHECK(synthetic_pointer_);
+  DCHECK_NE(synthetic_pointer_->SourceType(),
+            SyntheticGestureParams::DEFAULT_INPUT);
   return ForwardTouchOrMouseInputEvents(timestamp, target);
 }
 
 SyntheticGesture::Result SyntheticPointerAction::ForwardTouchOrMouseInputEvents(
     const base::TimeTicks& timestamp,
     SyntheticGestureTarget* target) {
   int point_index;
-  for (const SyntheticPointerActionParams& params : *param_list_) {
+  for (SyntheticPointerActionParams& params : params_.param_list) {
+    if (params.gesture_source_type == SyntheticGestureParams::DEFAULT_INPUT)
+      params.gesture_source_type = synthetic_pointer_->SourceType();
+
     if (!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);
         break;
       case SyntheticPointerActionParams::PointerActionType::MOVE:
         point_index = GetPointIndex(params.index());
         synthetic_pointer_->Move(point_index, params.position().x(),
                                  params.position().y(), target, timestamp);
         break;
       case SyntheticPointerActionParams::PointerActionType::RELEASE:
         point_index = GetPointIndex(params.index());
         synthetic_pointer_->Release(point_index, target, timestamp);
         SetPointIndex(params.index(), -1);
         break;
+      case SyntheticPointerActionParams::PointerActionType::FINISH:
+        return GESTURE_FINISHED;
       default:
         return POINTER_ACTION_INPUT_INVALID;
     }
   }
   synthetic_pointer_->DispatchEvent(target, timestamp);
-  return GESTURE_FINISHED;
+  return GESTURE_RUNNING;
 }
 
 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;
 
@@ skipping 12 matching lines @@
 
   if (params.pointer_action_type() ==
           SyntheticPointerActionParams::PointerActionType::RELEASE &&
       GetPointIndex(params.index()) < 0) {
     return false;
   }
   return true;
 }
 
 }  // namespace content