Replace scoped_ptr with std::unique_ptr in //ui

ui/chromeos/touch_exploration_controller.h

 // 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.
 
 #ifndef UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_
 #define UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_
 
 #include "base/macros.h"
 #include "base/time/tick_clock.h"
 #include "base/timer/timer.h"
@@ skipping 161 matching lines @@
       aura::Window* root_window,
       ui::TouchExplorationControllerDelegate* delegate);
   ~TouchExplorationController() override;
 
  private:
   friend class TouchExplorationControllerTestApi;
 
   // Overridden from ui::EventRewriter
   ui::EventRewriteStatus RewriteEvent(
       const ui::Event& event,
-      scoped_ptr<ui::Event>* rewritten_event) override;
+      std::unique_ptr<ui::Event>* rewritten_event) override;
   ui::EventRewriteStatus NextDispatchEvent(
       const ui::Event& last_event,
-      scoped_ptr<ui::Event>* new_event) override;
+      std::unique_ptr<ui::Event>* new_event) override;
 
   // Event handlers based on the current state - see State, below.
   ui::EventRewriteStatus InNoFingersDown(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSingleTapPressed(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSingleTapOrTouchExploreReleased(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InDoubleTapPending(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTouchReleasePending(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTouchExploration(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InCornerPassthrough(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InOneFingerPassthrough(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InGestureInProgress(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTouchExploreSecondPress(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InWaitForNoFingers(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSlideGesture(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTwoFingerTap(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+      const ui::TouchEvent& event,
+      std::unique_ptr<ui::Event>* rewritten_event);
 
   // Returns the current time of the tick clock.
   base::TimeDelta Now();
 
   // This timer is started every time we get the first press event, and
   // it fires after the double-click timeout elapses (300 ms by default).
   // If the user taps and releases within 300 ms and doesn't press again,
   // we treat that as a single mouse move (touch exploration) event.
   void StartTapTimer();
   void OnTapTimerFired();
@@ skipping 30 matching lines @@
 
   // Binds DispatchShiftSearchKeyEvent to a specific third key.
   base::Closure BindShiftSearchKeyEvent(const ui::KeyboardCode third_key);
 
   // Dispatches a single key with the given flags.
   void DispatchKeyWithFlags(const ui::KeyboardCode key, int flags);
 
   // Binds DispatchKeyWithFlags to a specific key and flags.
   base::Closure BindKeyEventWithFlags(const ui::KeyboardCode key, int flags);
 
-  scoped_ptr<ui::MouseEvent> CreateMouseMoveEvent(const gfx::PointF& location,
-                                                  int flags);
+  std::unique_ptr<ui::MouseEvent> CreateMouseMoveEvent(
+      const gfx::PointF& location,
+      int flags);
 
   void EnterTouchToMouseMode();
 
   void PlaySoundForTimer();
 
   // Some constants used in touch_exploration_controller:
 
   // Within this many dips of the screen edge, the release event generated will
   // reset the state to NoFingersDown.
   const float kLeavingScreenEdge = 6;
@@ skipping 136 matching lines @@
   // A set of touch ids for fingers currently touching the screen.
   std::vector<int> current_touch_ids_;
 
   // Map of touch ids to their last known location.
   std::map<int, gfx::PointF> touch_locations_;
 
   // The current state.
   State state_;
 
   // A copy of the event from the initial touch press.
-  scoped_ptr<ui::TouchEvent> initial_press_;
+  std::unique_ptr<ui::TouchEvent> initial_press_;
 
   // Map of touch ids to where its initial press occurred relative to the
   // screen.
   std::map<int, gfx::Point> initial_presses_;
 
   // In one finger passthrough, the touch is displaced relative to the
   // last touch exploration location.
   gfx::Vector2dF passthrough_offset_;
 
   // Stores the most recent event from a finger that is currently not
   // sending events through, but might in the future (e.g. before a finger
   // enters double-tap-hold passthrough, we need to update its location.)
-  scoped_ptr<ui::TouchEvent> last_unused_finger_event_;
+  std::unique_ptr<ui::TouchEvent> last_unused_finger_event_;
 
   // The last synthesized mouse move event. When the user double-taps,
   // we send the passed-through tap to the location of this event.
-  scoped_ptr<ui::TouchEvent> last_touch_exploration_;
+  std::unique_ptr<ui::TouchEvent> last_touch_exploration_;
 
   // A timer that fires after the double-tap delay.
   base::OneShotTimer tap_timer_;
 
   // A timer that fires to enter passthrough.
   base::OneShotTimer passthrough_timer_;
 
   // A timer to fire an indicating sound when sliding to change volume.
   base::RepeatingTimer sound_timer_;
 
   // A default gesture detector config, so we can share the same
   // timeout and pixel slop constants.
   ui::GestureDetector::Config gesture_detector_config_;
 
   // Gesture Handler to interpret the touch events.
-  scoped_ptr<ui::GestureProviderAura> gesture_provider_;
+  std::unique_ptr<ui::GestureProviderAura> gesture_provider_;
 
   // The previous state entered.
   State prev_state_;
 
   // A copy of the previous event passed.
-  scoped_ptr<ui::TouchEvent> prev_event_;
+  std::unique_ptr<ui::TouchEvent> prev_event_;
 
   // This toggles whether VLOGS are turned on or not.
   bool VLOG_on_;
 
   // When touch_exploration_controller gets time relative to real time during
   // testing, this clock is set to the simulated clock and used.
   base::TickClock* tick_clock_;
 
   // Maps the number of fingers in a swipe to the resulting functions that
   // dispatch key events.
   std::map<int, base::Closure> left_swipe_gestures_;
   std::map<int, base::Closure> right_swipe_gestures_;
   std::map<int, base::Closure> up_swipe_gestures_;
   std::map<int, base::Closure> down_swipe_gestures_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationController);
 };
 
 }  // namespace ui
 
 #endif  // UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_