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 160 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(0, current_move_segment_start_position_.x(),
+                                   current_move_segment_start_position_.y(),
+                                   target, timestamp);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticSmoothMoveGesture::MovePoint(SyntheticGestureTarget* target,
                                            const gfx::Vector2dF& delta,
                                            const base::TimeTicks& timestamp) {
   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(0, new_position.x(), new_position.y(), target,
+                                  timestamp);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticSmoothMoveGesture::ReleasePoint(
     SyntheticGestureTarget* target,
     const base::TimeTicks& timestamp) {
   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(0, target, timestamp);
+  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