gfx: Make conversions from gfx::Point to PointF explicit.

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_f(),
-        initial_press_->touch_id(), event.time_stamp()));
+    touch_press.reset(new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(),
+                                         initial_press_->touch_id(),
+                                         event.time_stamp()));
+    touch_press->set_location_f(last_touch_exploration_->location_f());
+    touch_press->set_root_location_f(last_touch_exploration_->location_f());
     DispatchEvent(touch_press.get());
 
-    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());
+    scoped_ptr<ui::TouchEvent> new_event(
+        new ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(),
+                           initial_press_->touch_id(), event.time_stamp()));
+    new_event->set_location_f(last_touch_exploration_->location_f());
+    new_event->set_root_location_f(last_touch_exploration_->location_f());
+    new_event->set_flags(event.flags());
+    *rewritten_event = new_event.Pass();
     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_f(),
-        initial_press_->touch_id(), event.time_stamp()));
-    (*rewritten_event)->set_flags(event.flags());
+    scoped_ptr<ui::TouchEvent> new_event(
+        new ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(),
+                           initial_press_->touch_id(), event.time_stamp()));
+    new_event->set_location_f(last_touch_exploration_->location_f());
+    new_event->set_root_location_f(last_touch_exploration_->location_f());
+    new_event->set_flags(event.flags());
+    *rewritten_event = new_event.Pass();
     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_f(),
-        event.touch_id(), event.time_stamp()));
-    (*rewritten_event)->set_flags(event.flags());
+    scoped_ptr<ui::TouchEvent> new_event(
+        new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(), event.touch_id(),
+                           event.time_stamp()));
+    new_event->set_location_f(last_touch_exploration_->location_f());
+    new_event->set_root_location_f(last_touch_exploration_->location_f());
+    new_event->set_flags(event.flags());
+    *rewritten_event = new_event.Pass();
     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;
   }
@@ skipping 31 matching lines @@
       return ui::EVENT_REWRITE_DISCARD;
 
     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_f(), event.touch_id(), event.time_stamp()));
-  (*rewritten_event)->set_flags(event.flags());
+  scoped_ptr<ui::TouchEvent> new_event(new ui::TouchEvent(
+      type, gfx::Point(), event.touch_id(), event.time_stamp()));
+  new_event->set_location_f(event.location_f());
+  new_event->set_root_location_f(event.location_f());
+  new_event->set_flags(event.flags());
+  *rewritten_event = new_event.Pass();
 
   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_f() - passthrough_offset_,
-                         event.touch_id(), event.time_stamp()));
-
-  (*rewritten_event)->set_flags(event.flags());
+  scoped_ptr<ui::TouchEvent> new_event(new ui::TouchEvent(
+      event.type(), gfx::Point(), event.touch_id(), event.time_stamp()));
+  new_event->set_location_f(event.location_f() - passthrough_offset_);
+  new_event->set_root_location_f(event.location_f() - passthrough_offset_);
+  new_event->set_flags(event.flags());
+  *rewritten_event = new_event.Pass();
   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_f(),
-        initial_press_->touch_id(), event.time_stamp()));
-    (*rewritten_event)->set_flags(event.flags());
+    scoped_ptr<ui::TouchEvent> new_event(
+        new ui::TouchEvent(ui::ET_TOUCH_CANCELLED, gfx::Point(),
+                           initial_press_->touch_id(), event.time_stamp()));
+    new_event->set_location_f(last_touch_exploration_->location_f());
+    new_event->set_root_location_f(last_touch_exploration_->location_f());
+    new_event->set_flags(event.flags());
+    *rewritten_event = new_event.Pass();
     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_f() - original_touch->location_f()).Length() >
         GetSplitTapTouchSlop()) {
-      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());
+      scoped_ptr<ui::TouchEvent> new_event(
+          new ui::TouchEvent(ui::ET_TOUCH_CANCELLED, gfx::Point(),
+                             initial_press_->touch_id(), event.time_stamp()));
+      new_event->set_location_f(last_touch_exploration_->location_f());
+      new_event->set_root_location_f(last_touch_exploration_->location_f());
+      new_event->set_flags(event.flags());
+      *rewritten_event = new_event.Pass();
       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_f(),
-        initial_press_->touch_id(), event.time_stamp()));
-    (*rewritten_event)->set_flags(event.flags());
+    scoped_ptr<ui::TouchEvent> new_event(
+        new ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(),
+                           initial_press_->touch_id(), event.time_stamp()));
+    new_event->set_location_f(last_touch_exploration_->location_f());
+    new_event->set_root_location_f(last_touch_exploration_->location_f());
+    new_event->set_flags(event.flags());
+    *rewritten_event = new_event.Pass();
     SET_STATE(TOUCH_EXPLORATION);
     EnterTouchToMouseMode();
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InWaitForNoFingers(
     const ui::TouchEvent& event,
@@ skipping 114 matching lines @@
       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_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()));
+      scoped_ptr<ui::TouchEvent> passthrough_press(
+          new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(),
+                             last_unused_finger_event_->touch_id(), Now()));
+      passthrough_press->set_location_f(last_touch_exploration_->location_f());
+      passthrough_press->set_root_location_f(
+          last_touch_exploration_->location_f());
       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();
@@ skipping 228 matching lines @@
 
 base::Closure TouchExplorationController::BindKeyEventWithFlags(
     const ui::KeyboardCode key,
     int flags) {
   return base::Bind(&TouchExplorationController::DispatchKeyWithFlags,
                     base::Unretained(this),
                     key,
                     flags);
 }
 
-scoped_ptr<ui::Event> TouchExplorationController::CreateMouseMoveEvent(
+scoped_ptr<ui::MouseEvent> TouchExplorationController::CreateMouseMoveEvent(
     const gfx::PointF& location,
     int flags) {
   // The "synthesized" flag should be set on all events that don't have a
   // backing native event.
   flags |= ui::EF_IS_SYNTHESIZED;
 
   // This flag is used to identify mouse move events that were generated from
   // touch exploration in Chrome code.
   flags |= ui::EF_TOUCH_ACCESSIBILITY;
 
   // TODO(dmazzoni) http://crbug.com/391008 - get rid of this hack.
   // This is a short-term workaround for the limitation that we're using
   // the ChromeVox content script to process touch exploration events, but
   // ChromeVox needs a way to distinguish between a real mouse move and a
   // mouse move generated from touch exploration, so we have touch exploration
   // pretend that the command key was down (which becomes the "meta" key in
   // JavaScript). We can remove this hack when the ChromeVox content script
   // goes away and native accessibility code sends a touch exploration
   // event to the new ChromeVox background page via the automation api.
   flags |= ui::EF_COMMAND_DOWN;
 
-  return make_scoped_ptr(new ui::MouseEvent(
-      ui::ET_MOUSE_MOVED, location, location, ui::EventTimeForNow(), flags, 0));
+  scoped_ptr<ui::MouseEvent> event(
+      new ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(),
+                         ui::EventTimeForNow(), flags, 0));
+  event->set_location_f(location);
+  event->set_root_location_f(location);
+  return event;
 }
 
 void TouchExplorationController::EnterTouchToMouseMode() {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window_);
   if (cursor_client && !cursor_client->IsMouseEventsEnabled())
     cursor_client->EnableMouseEvents();
   if (cursor_client && cursor_client->IsCursorVisible())
     cursor_client->HideCursor();
 }
@@ skipping 147 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