Rename SyntheticPointer to SyntheticPointerDriver

content/browser/renderer_host/input/synthetic_smooth_move_gesture.cc

 // Copyright 2013 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_smooth_move_gesture.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "ui/gfx/geometry/point_f.h"
@@ skipping 49 matching lines @@
     const base::TimeTicks& timestamp,
     SyntheticGestureTarget* target) {
   if (state_ == SETUP) {
     state_ = STARTED;
     current_move_segment_ = -1;
     current_move_segment_stop_time_ = timestamp;
   }
 
   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:
       ForwardMouseWheelInputEvents(timestamp, target);
       break;
     default:
       return SyntheticGesture::GESTURE_SOURCE_TYPE_NOT_IMPLEMENTED;
   }
   return (state_ == DONE) ? SyntheticGesture::GESTURE_FINISHED
                           : SyntheticGesture::GESTURE_RUNNING;
@@ skipping 116 matching lines @@
         state_ = DONE;
         break;
       }
       ComputeNextMoveSegment();
       PressPoint(target, event_timestamp);
       state_ = MOVING;
       break;
     case MOVING: {
       base::TimeTicks event_timestamp = ClampTimestamp(timestamp);
       gfx::Vector2dF delta = GetPositionDeltaAtTime(event_timestamp);
-      MovePoint(target, delta, event_timestamp);
+      MovePoint(target, delta, event_timestamp, -1);

[tdresser, 2016/11/12 19:50:55]

I don't think we should explicitly pass -1 here, we should probably just change
the default instead.

[lanwei, 2016/11/14 04:20:54]

Done.

 
       if (FinishedCurrentMoveSegment(event_timestamp)) {
         if (!IsLastMoveSegment()) {
           current_move_segment_start_position_ +=
               params_.distances[current_move_segment_];
           ComputeNextMoveSegment();
         } else {
-          ReleasePoint(target, event_timestamp);
+          ReleasePoint(target, event_timestamp, -1);
           state_ = DONE;
         }
       }
     } break;
     case STOPPING:
       NOTREACHED()
           << "State STOPPING invalid for synthetic drag using mouse input.";
     case SETUP:
       NOTREACHED()
           << "State SETUP invalid for synthetic drag using mouse input.";
@@ skipping 15 matching lines @@
   mouse_wheel_event.y = current_move_segment_start_position_.y();
 
   mouse_wheel_event.timeStampSeconds = ConvertTimestampToSeconds(timestamp);
 
   target->DispatchInputEventToPlatform(mouse_wheel_event);
 }
 
 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,
                                            const gfx::Vector2dF& delta,
-                                           const base::TimeTicks& timestamp) {
+                                           const base::TimeTicks& timestamp,
+                                           int index) {
   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(), index);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
-void SyntheticSmoothMoveGesture::ReleasePoint(
-    SyntheticGestureTarget* target,
-    const base::TimeTicks& timestamp) {
+void SyntheticSmoothMoveGesture::ReleasePoint(SyntheticGestureTarget* target,
+                                              const base::TimeTicks& timestamp,
+                                              int index) {
   DCHECK_EQ(current_move_segment_,
             static_cast<int>(params_.distances.size()) - 1);
   gfx::PointF position;
   if (params_.input_type ==
       SyntheticSmoothMoveGestureParams::MOUSE_DRAG_INPUT) {
     position = current_move_segment_start_position_ +
                GetPositionDeltaAtTime(timestamp);
   }
-  synthetic_pointer_->Release(0, target, timestamp);
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->Release(index);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticSmoothMoveGesture::AddTouchSlopToFirstDistance(
     SyntheticGestureTarget* target) {
   DCHECK_GE(params_.distances.size(), 1ul);
   gfx::Vector2dF& first_move_distance = params_.distances[0];
   DCHECK_GT(first_move_distance.Length(), 0);
   first_move_distance += CeilFromZero(ProjectScalarOntoVector(
       target->GetTouchSlopInDips(), first_move_distance));
 }
@@ skipping 39 matching lines @@
   DCHECK_LT(current_move_segment_, static_cast<int>(params_.distances.size()));
   return current_move_segment_ ==
          static_cast<int>(params_.distances.size()) - 1;
 }
 
 bool SyntheticSmoothMoveGesture::MoveIsNoOp() const {
   return params_.distances.size() == 0 || params_.distances[0].IsZero();
 }
 
 }  // namespace content