Replace scoped_ptr with std::unique_ptr in //ui

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 <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 36 matching lines @@
   root_window->GetHost()->GetEventSource()->AddEventRewriter(this);
   InitializeSwipeGestureMaps();
 }
 
 TouchExplorationController::~TouchExplorationController() {
   root_window_->GetHost()->GetEventSource()->RemoveEventRewriter(this);
 }
 
 ui::EventRewriteStatus TouchExplorationController::RewriteEvent(
     const ui::Event& event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   if (!event.IsTouchEvent()) {
     if (event.IsKeyEvent()) {
       const ui::KeyEvent& key_event = static_cast<const ui::KeyEvent&>(event);
       VLOG(0) << "\nKeyboard event: " << key_event.name()
               << "\n Key code: " << key_event.key_code()
               << ", Flags: " << key_event.flags()
               << ", Is char: " << key_event.is_char();
     }
     return ui::EVENT_REWRITE_CONTINUE;
   }
@@ skipping 116 matching lines @@
     case WAIT_FOR_NO_FINGERS:
       return InWaitForNoFingers(touch_event, rewritten_event);
     case TWO_FINGER_TAP:
       return InTwoFingerTap(touch_event, rewritten_event);
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::NextDispatchEvent(
-    const ui::Event& last_event, scoped_ptr<ui::Event>* new_event) {
+    const ui::Event& last_event,
+    std::unique_ptr<ui::Event>* new_event) {
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InNoFingersDown(
-    const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
+    const ui::TouchEvent& event,
+    std::unique_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type != ui::ET_TOUCH_PRESSED) {
     NOTREACHED() << "Unexpected event type received: " << event.name();
     return ui::EVENT_REWRITE_CONTINUE;
   }
 
   // If the user enters the screen from the edge then send an earcon.
   int edge = FindEdgesWithinBounds(event.location(), kLeavingScreenEdge);
   if (edge != NO_EDGE)
     delegate_->PlayEnterScreenEarcon();
@@ skipping 12 matching lines @@
   }
   initial_press_.reset(new TouchEvent(event));
   initial_presses_[event.touch_id()] = event.location();
   last_unused_finger_event_.reset(new TouchEvent(event));
   StartTapTimer();
   SET_STATE(SINGLE_TAP_PRESSED);
   return ui::EVENT_REWRITE_DISCARD;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapPressed(
-    const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
+    const ui::TouchEvent& event,
+    std::unique_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
 
   int location = FindEdgesWithinBounds(event.location(), kMaxDistanceFromEdge);
   bool in_a_bottom_corner =
       (location == BOTTOM_LEFT_CORNER) || (location == BOTTOM_RIGHT_CORNER);
   // If the event is from the initial press and the location is no longer in the
   // corner, then we are not waiting for a corner passthrough anymore.
   if (event.touch_id() == initial_press_->touch_id() && !in_a_bottom_corner) {
     if (passthrough_timer_.IsRunning()) {
       passthrough_timer_.Stop();
@@ skipping 55 matching lines @@
     SET_STATE(TOUCH_EXPLORATION);
     return InTouchExploration(event, rewritten_event);
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus
 TouchExplorationController::InSingleTapOrTouchExploreReleased(
     const ui::TouchEvent& event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   // If there is more than one finger down, then discard to wait until no
   // fingers are down.
   if (current_touch_ids_.size() > 1) {
     SET_STATE(WAIT_FOR_NO_FINGERS);
     return ui::EVENT_REWRITE_DISCARD;
   }
   if (type == ui::ET_TOUCH_PRESSED) {
     // If there is no touch exploration yet, we can't send a click, so discard.
     if (!last_touch_exploration_) {
@@ skipping 22 matching lines @@
     return ui::EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_MOVED) {
     return ui::EVENT_REWRITE_DISCARD;
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InDoubleTapPending(
     const ui::TouchEvent& event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     return ui::EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_MOVED) {
     // If the user moves far enough from the initial touch location (outside
     // the "slop" region, jump to passthrough mode early.
     float delta = (event.location() - initial_press_->location()).Length();
     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;
+    std::unique_ptr<ui::TouchEvent> touch_press;
     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());
 
-    scoped_ptr<ui::TouchEvent> new_event(
+    std::unique_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 = std::move(new_event);
     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) {
+    std::unique_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;
 
-    scoped_ptr<ui::TouchEvent> new_event(
+    std::unique_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 = std::move(new_event);
     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) {
+    std::unique_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();
-    scoped_ptr<ui::TouchEvent> new_event(
+    std::unique_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 = std::move(new_event);
     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_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) {
+    std::unique_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
   // on the number of fingers down, and this function will stop being called.
   if (current_touch_ids_.size() == 0) {
     SET_STATE(NO_FINGERS_DOWN);
   }
   return ui::EVENT_REWRITE_DISCARD;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InCornerPassthrough(
     const ui::TouchEvent& event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
 
   // If the first finger has left the corner, then exit passthrough.
   if (event.touch_id() == initial_press_->touch_id()) {
     int edges = FindEdgesWithinBounds(event.location(), kSlopDistanceFromEdge);
     bool in_a_bottom_corner = (edges == BOTTOM_LEFT_CORNER) ||
                               (edges == BOTTOM_RIGHT_CORNER);
     if (type == ui::ET_TOUCH_MOVED && in_a_bottom_corner)
       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;
   }
 
-  scoped_ptr<ui::TouchEvent> new_event(new ui::TouchEvent(
+  std::unique_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 = std::move(new_event);
 
   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) {
+    std::unique_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;
   }
-  scoped_ptr<ui::TouchEvent> new_event(new ui::TouchEvent(
+  std::unique_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 = std::move(new_event);
   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) {
+    std::unique_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.
-    scoped_ptr<ui::TouchEvent> new_event(
+    std::unique_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 = std::move(new_event);
     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()) {
-      scoped_ptr<ui::TouchEvent> new_event(
+      std::unique_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 = std::move(new_event);
       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.
-    scoped_ptr<ui::TouchEvent> new_event(
+    std::unique_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 = std::move(new_event);
     SET_STATE(TOUCH_EXPLORATION);
     EnterTouchToMouseMode();
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InWaitForNoFingers(
     const ui::TouchEvent& event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   if (current_touch_ids_.size() == 0)
     SET_STATE(NO_FINGERS_DOWN);
   return EVENT_REWRITE_DISCARD;
 }
 
 void TouchExplorationController::PlaySoundForTimer() {
   delegate_->PlayVolumeAdjustEarcon();
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSlideGesture(
     const ui::TouchEvent& event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   // The timer should not fire when sliding.
   tap_timer_.Stop();
 
   ui::EventType type = event.type();
   // If additional fingers are added before a swipe gesture has been registered,
   // then wait until all fingers have been lifted.
   if (type == ui::ET_TOUCH_PRESSED ||
       event.touch_id() != initial_press_->touch_id()) {
     if (sound_timer_.IsRunning())
       sound_timer_.Stop();
@@ skipping 24 matching lines @@
   }
 
   if (current_touch_ids_.size() == 0) {
     SET_STATE(NO_FINGERS_DOWN);
   }
   return ui::EVENT_REWRITE_DISCARD;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InTwoFingerTap(
     const ui::TouchEvent& event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     // This is now a three finger gesture.
     SET_STATE(GESTURE_IN_PROGRESS);
     return ui::EVENT_REWRITE_DISCARD;
   }
 
   if (type == ui::ET_TOUCH_MOVED) {
     // Determine if it was a swipe.
     gfx::Point original_location = initial_presses_[event.touch_id()];
@@ skipping 46 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(
+      std::unique_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();
         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(
+  std::unique_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
@@ skipping 24 matching lines @@
 
 // This is an override for a function that is only called for timer-based events
 // like long press. Events that are created synchronously as a result of
 // certain touch events are added to the vector accessible via
 // GetAndResetPendingGestures(). We only care about swipes (which are created
 // synchronously), so we ignore this callback.
 void TouchExplorationController::OnGestureEvent(ui::GestureConsumer* consumer,
                                                 ui::GestureEvent* gesture) {}
 
 void TouchExplorationController::ProcessGestureEvents() {
-  scoped_ptr<ScopedVector<ui::GestureEvent> > gestures(
+  std::unique_ptr<ScopedVector<ui::GestureEvent>> gestures(
       gesture_provider_->GetAndResetPendingGestures());
   if (gestures) {
     for (ScopedVector<GestureEvent>::iterator i = gestures->begin();
          i != gestures->end();
          ++i) {
       if ((*i)->type() == ui::ET_GESTURE_SWIPE &&
           state_ == GESTURE_IN_PROGRESS) {
         OnSwipeEvent(*i);
         // The tap timer to leave gesture state is ended, and we now wait for
         // all fingers to be released.
@@ skipping 159 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::MouseEvent> TouchExplorationController::CreateMouseMoveEvent(
-    const gfx::PointF& location,
-    int flags) {
+std::unique_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;
 
-  scoped_ptr<ui::MouseEvent> event(
+  std::unique_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_);
@@ skipping 152 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