Rename SyntheticPointer to SyntheticPointerDriver

content/browser/renderer_host/input/synthetic_touchscreen_pinch_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_touchscreen_pinch_gesture.h"
 
 #include <stdint.h>
 
 #include <cmath>
 
@@ skipping 22 matching lines @@
     gesture_source_type_ = params_.gesture_source_type;
     if (gesture_source_type_ == SyntheticGestureParams::DEFAULT_INPUT)
       gesture_source_type_ = target->GetDefaultSyntheticGestureSourceType();
 
     state_ = STARTED;
     start_time_ = timestamp;
   }
 
   DCHECK_NE(gesture_source_type_, SyntheticGestureParams::DEFAULT_INPUT);
 
-  if (!synthetic_pointer_)
-    synthetic_pointer_ = SyntheticPointer::Create(gesture_source_type_);
+  if (!synthetic_pointer_driver_)
+    synthetic_pointer_driver_ =
+        SyntheticPointerDriver::Create(gesture_source_type_);
 
   if (gesture_source_type_ == SyntheticGestureParams::TOUCH_INPUT) {
     ForwardTouchInputEvents(timestamp, target);
   } else {
     return SyntheticGesture::GESTURE_SOURCE_TYPE_NOT_IMPLEMENTED;
   }
 
   return (state_ == DONE) ? SyntheticGesture::GESTURE_FINISHED
                           : SyntheticGesture::GESTURE_RUNNING;
 }
@@ skipping 24 matching lines @@
     case SETUP:
       NOTREACHED() << "State SETUP invalid for synthetic pinch.";
     case DONE:
       NOTREACHED() << "State DONE invalid for synthetic pinch.";
   }
 }
 
 void SyntheticTouchscreenPinchGesture::PressTouchPoints(
     SyntheticGestureTarget* target,
     const base::TimeTicks& timestamp) {
-  synthetic_pointer_->Press(params_.anchor.x(), start_y_0_, target, timestamp);
-  synthetic_pointer_->Press(params_.anchor.x(), start_y_1_, target, timestamp);
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->Press(params_.anchor.x(), start_y_0_);
+  synthetic_pointer_driver_->Press(params_.anchor.x(), start_y_1_);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticTouchscreenPinchGesture::MoveTouchPoints(
     SyntheticGestureTarget* target,
     float delta,
     const base::TimeTicks& timestamp) {
   // The two pointers move in opposite directions.
   float current_y_0 = start_y_0_ + delta;
   float current_y_1 = start_y_1_ - delta;
 
-  synthetic_pointer_->Move(0, params_.anchor.x(), current_y_0, target,
-                           timestamp);
-  synthetic_pointer_->Move(1, params_.anchor.x(), current_y_1, target,
-                           timestamp);
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->Move(params_.anchor.x(), current_y_0, 0);
+  synthetic_pointer_driver_->Move(params_.anchor.x(), current_y_1, 1);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticTouchscreenPinchGesture::ReleaseTouchPoints(
     SyntheticGestureTarget* target,
     const base::TimeTicks& timestamp) {
-  synthetic_pointer_->Release(0, target, timestamp);
-  synthetic_pointer_->Release(1, target, timestamp);
-  synthetic_pointer_->DispatchEvent(target, timestamp);
+  synthetic_pointer_driver_->Release(0);
+  synthetic_pointer_driver_->Release(1);
+  synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticTouchscreenPinchGesture::SetupCoordinatesAndStopTime(
     SyntheticGestureTarget* target) {
   // To achieve the specified scaling factor, the ratio of the final to the
   // initial span (distance between the pointers) has to be equal to the scaling
   // factor. Since we're moving both pointers at the same speed, each pointer's
   // distance to the anchor is half the span.
   float initial_distance_to_anchor, final_distance_to_anchor;
   if (params_.scale_factor > 1.0f) {  // zooming in
@@ skipping 39 matching lines @@
     const base::TimeTicks& timestamp) const {
   return std::min(timestamp, stop_time_);
 }
 
 bool SyntheticTouchscreenPinchGesture::HasReachedTarget(
     const base::TimeTicks& timestamp) const {
   return timestamp >= stop_time_;
 }
 
 }  // namespace content