chromeos: Remove implicit Point to PointF conversions.

ui/chromeos/touch_exploration_controller.cc

 // Copyright 2014 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 "ui/chromeos/touch_exploration_controller.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/default_tick_clock.h"
 #include "ui/aura/client/cursor_client.h"
@@ skipping 347 matching lines @@
     if (delta > gesture_detector_config_.touch_slop) {
       tap_timer_.Stop();
       OnTapTimerFired();
     }
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (current_touch_ids_.size() != 0)
       return EVENT_REWRITE_DISCARD;
 
     scoped_ptr<ui::TouchEvent> touch_press;
-    touch_press.reset(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
-                                         last_touch_exploration_->location(),
-                                         initial_press_->touch_id(),
-                                         event.time_stamp()));
+    touch_press.reset(new ui::TouchEvent(
+        ui::ET_TOUCH_PRESSED, last_touch_exploration_->location_f(),
+        initial_press_->touch_id(), event.time_stamp()));
     DispatchEvent(touch_press.get());
 
-    rewritten_event->reset(
-        new ui::TouchEvent(ui::ET_TOUCH_RELEASED,
-                           last_touch_exploration_->location(),
-                           initial_press_->touch_id(),
-                           event.time_stamp()));
+    rewritten_event->reset(new ui::TouchEvent(
+        ui::ET_TOUCH_RELEASED, last_touch_exploration_->location_f(),
+        initial_press_->touch_id(), event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     SET_STATE(NO_FINGERS_DOWN);
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InTouchReleasePending(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED || type == ui::ET_TOUCH_MOVED) {
     return ui::EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (current_touch_ids_.size() != 0)
       return EVENT_REWRITE_DISCARD;
 
-    rewritten_event->reset(
-        new ui::TouchEvent(ui::ET_TOUCH_RELEASED,
-                           last_touch_exploration_->location(),
-                           initial_press_->touch_id(),
-                           event.time_stamp()));
+    rewritten_event->reset(new ui::TouchEvent(
+        ui::ET_TOUCH_RELEASED, last_touch_exploration_->location_f(),
+        initial_press_->touch_id(), event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     SET_STATE(NO_FINGERS_DOWN);
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InTouchExploration(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     // Handle split-tap.
     initial_press_.reset(new TouchEvent(event));
     tap_timer_.Stop();
-    rewritten_event->reset(
-        new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
-                           last_touch_exploration_->location(),
-                           event.touch_id(),
-                           event.time_stamp()));
+    rewritten_event->reset(new ui::TouchEvent(
+        ui::ET_TOUCH_PRESSED, last_touch_exploration_->location_f(),
+        event.touch_id(), event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     SET_STATE(TOUCH_EXPLORE_SECOND_PRESS);
     return ui::EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     initial_press_.reset(new TouchEvent(event));
     StartTapTimer();
     SET_STATE(TOUCH_EXPLORE_RELEASED);
   } else if (type != ui::ET_TOUCH_MOVED) {
     NOTREACHED();
     return ui::EVENT_REWRITE_CONTINUE;
   }
 
   // Rewrite as a mouse-move event.
-  *rewritten_event = CreateMouseMoveEvent(event.location(), event.flags());
+  *rewritten_event = CreateMouseMoveEvent(event.location_f(), event.flags());
   last_touch_exploration_.reset(new TouchEvent(event));
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InGestureInProgress(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   // The events were sent to the gesture provider in RewriteEvent already.
   // If no gesture is registered before the tap timer times out, the state
   // will change to "wait for no fingers down" or "touch exploration" depending
@@ skipping 19 matching lines @@
 
     if (current_touch_ids_.size() == 0) {
       SET_STATE(NO_FINGERS_DOWN);
       return ui::EVENT_REWRITE_DISCARD;
     }
     SET_STATE(WAIT_FOR_NO_FINGERS);
     return ui::EVENT_REWRITE_DISCARD;
   }
 
   rewritten_event->reset(new ui::TouchEvent(
-      type, event.location(), event.touch_id(), event.time_stamp()));
+      type, event.location_f(), event.touch_id(), event.time_stamp()));
   (*rewritten_event)->set_flags(event.flags());
 
   if (current_touch_ids_.size() == 0)
     SET_STATE(NO_FINGERS_DOWN);
 
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InOneFingerPassthrough(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   if (event.touch_id() != initial_press_->touch_id()) {
     if (current_touch_ids_.size() == 0) {
       SET_STATE(NO_FINGERS_DOWN);
     }
     return ui::EVENT_REWRITE_DISCARD;
   }
   rewritten_event->reset(
-      new ui::TouchEvent(event.type(),
-                         event.location() - passthrough_offset_,
-                         event.touch_id(),
-                         event.time_stamp()));
+      new ui::TouchEvent(event.type(), event.location_f() - passthrough_offset_,
+                         event.touch_id(), event.time_stamp()));
 
   (*rewritten_event)->set_flags(event.flags());
   if (current_touch_ids_.size() == 0) {
     SET_STATE(NO_FINGERS_DOWN);
   }
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InTouchExploreSecondPress(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
   gfx::PointF location = event.location_f();
   if (type == ui::ET_TOUCH_PRESSED) {
     // A third finger being pressed means that a split tap can no longer go
     // through. The user enters the wait state, Since there has already been
     // a press dispatched when split tap began, the touch needs to be
     // cancelled.
-    rewritten_event->reset(
-        new ui::TouchEvent(ui::ET_TOUCH_CANCELLED,
-                           last_touch_exploration_->location(),
-                           initial_press_->touch_id(),
-                           event.time_stamp()));
+    rewritten_event->reset(new ui::TouchEvent(
+        ui::ET_TOUCH_CANCELLED, last_touch_exploration_->location_f(),
+        initial_press_->touch_id(), event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     SET_STATE(WAIT_FOR_NO_FINGERS);
     return ui::EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_MOVED) {
     // If the fingers have moved too far from their original locations,
     // the user can no longer split tap.
     ui::TouchEvent* original_touch;
     if (event.touch_id() == last_touch_exploration_->touch_id()) {
       original_touch = last_touch_exploration_.get();
     } else if (event.touch_id() == initial_press_->touch_id()) {
       original_touch = initial_press_.get();
     } else {
       NOTREACHED();
       SET_STATE(WAIT_FOR_NO_FINGERS);
       return ui::EVENT_REWRITE_DISCARD;
     }
     // Check the distance between the current finger location and the original
     // location. The slop for this is a bit more generous since keeping two
     // fingers in place is a bit harder. If the user has left the slop, the
     // split tap press (which was previous dispatched) is lifted with a touch
     // cancelled, and the user enters the wait state.
-    if ((event.location() - original_touch->location()).Length() >
+    if ((event.location_f() - original_touch->location_f()).Length() >
         GetSplitTapTouchSlop()) {
-      rewritten_event->reset(
-          new ui::TouchEvent(ui::ET_TOUCH_CANCELLED,
-                             last_touch_exploration_->location(),
-                             initial_press_->touch_id(),
-                             event.time_stamp()));
+      rewritten_event->reset(new ui::TouchEvent(
+          ui::ET_TOUCH_CANCELLED, last_touch_exploration_->location_f(),
+          initial_press_->touch_id(), event.time_stamp()));
       (*rewritten_event)->set_flags(event.flags());
       SET_STATE(WAIT_FOR_NO_FINGERS);
       return ui::EVENT_REWRITE_REWRITTEN;
     }
     return ui::EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     // If the touch exploration finger is lifted, there is no option to return
     // to touch explore anymore. The remaining finger acts as a pending
     // tap or long tap for the last touch explore location.
     if (event.touch_id() == last_touch_exploration_->touch_id()) {
       SET_STATE(TOUCH_RELEASE_PENDING);
       return EVENT_REWRITE_DISCARD;
     }
 
     // Continue to release the touch only if the touch explore finger is the
     // only finger remaining.
     if (current_touch_ids_.size() != 1)
       return EVENT_REWRITE_DISCARD;
 
     // Rewrite at location of last touch exploration.
-    rewritten_event->reset(
-        new ui::TouchEvent(ui::ET_TOUCH_RELEASED,
-                           last_touch_exploration_->location(),
-                           initial_press_->touch_id(),
-                           event.time_stamp()));
+    rewritten_event->reset(new ui::TouchEvent(
+        ui::ET_TOUCH_RELEASED, last_touch_exploration_->location_f(),
+        initial_press_->touch_id(), event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     SET_STATE(TOUCH_EXPLORATION);
     EnterTouchToMouseMode();
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InWaitForNoFingers(
@@ skipping 113 matching lines @@
   switch (state_) {
     case SINGLE_TAP_RELEASED:
       SET_STATE(NO_FINGERS_DOWN);
       break;
     case TOUCH_EXPLORE_RELEASED:
       SET_STATE(NO_FINGERS_DOWN);
       last_touch_exploration_.reset(new TouchEvent(*initial_press_));
       return;
     case DOUBLE_TAP_PENDING: {
       SET_STATE(ONE_FINGER_PASSTHROUGH);
-      passthrough_offset_ = last_unused_finger_event_->location() -
-                            last_touch_exploration_->location();
-      scoped_ptr<ui::TouchEvent> passthrough_press(
-          new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
-                             last_touch_exploration_->location(),
-                             last_unused_finger_event_->touch_id(),
-                             Now()));
+      passthrough_offset_ = last_unused_finger_event_->location_f() -
+                            last_touch_exploration_->location_f();
+      scoped_ptr<ui::TouchEvent> passthrough_press(new ui::TouchEvent(
+          ui::ET_TOUCH_PRESSED, last_touch_exploration_->location_f(),
+          last_unused_finger_event_->touch_id(), Now()));
       DispatchEvent(passthrough_press.get());
       return;
     }
     case SINGLE_TAP_PRESSED:
       if (passthrough_timer_.IsRunning())
         return;
     case GESTURE_IN_PROGRESS:
       // If only one finger is down, go into touch exploration.
       if (current_touch_ids_.size() == 1) {
         EnterTouchToMouseMode();
         SET_STATE(TOUCH_EXPLORATION);
         break;
       }
       // Otherwise wait for all fingers to be lifted.
       SET_STATE(WAIT_FOR_NO_FINGERS);
       return;
     case TWO_FINGER_TAP:
       SET_STATE(WAIT_FOR_NO_FINGERS);
       break;
     default:
       return;
   }
   EnterTouchToMouseMode();
-  scoped_ptr<ui::Event> mouse_move =
-      CreateMouseMoveEvent(initial_press_->location(), initial_press_->flags());
+  scoped_ptr<ui::Event> mouse_move = CreateMouseMoveEvent(
+      initial_press_->location_f(), initial_press_->flags());
   DispatchEvent(mouse_move.get());
   last_touch_exploration_.reset(new TouchEvent(*initial_press_));
 }
 
 void TouchExplorationController::OnPassthroughTimerFired() {
   // The passthrough timer will only fire if if the user has held a finger in
   // one of the passthrough corners for the duration of the passthrough timeout.
 
   // Check that initial press isn't null. Also a check that if the initial
   // corner press was released, then it should not be in corner passthrough.
@@ skipping 394 matching lines @@
   up_swipe_gestures_[4] = BindKeyEventWithFlags(VKEY_BROWSER_HOME, ui::EF_NONE);
   down_swipe_gestures_[4] =
       BindKeyEventWithFlags(VKEY_BROWSER_REFRESH, ui::EF_NONE);
 }
 
 float TouchExplorationController::GetSplitTapTouchSlop() {
   return gesture_detector_config_.touch_slop * 3;
 }
 
 }  // namespace ui