Convert //ash from scoped_ptr to std::unique_ptr

ash/sticky_keys/sticky_keys_controller.h

 // 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.
 
 #ifndef ASH_STICKY_KEYS_STICKY_KEYS_CONTROLLER_H_
 #define ASH_STICKY_KEYS_STICKY_KEYS_CONTROLLER_H_
 
+#include <memory>
+
 #include "ash/ash_export.h"
 #include "ash/sticky_keys/sticky_keys_state.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/event_rewriter.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 namespace ui {
 class Event;
 class KeyEvent;
 class MouseEvent;
 }  // namespace ui
@@ skipping 79 matching lines @@
                                             int* flags);
 
   // Obtains a pending modifier-up event. If the immediately previous
   // call to |Rewrite...Event()| or |NextDispatchEvent()| returned
   // ui::EVENT_REWRITE_DISPATCH_ANOTHER, this sets |new_event| and returns:
   // - ui::EVENT_REWRITE_DISPATCH_ANOTHER if there is at least one more
   //   pending modifier-up event;
   // - ui::EVENT_REWRITE_REWRITE if this is the last or only modifier-up event;
   // Otherwise, there is no pending modifier-up event, and this function
   // returns ui::EVENT_REWRITE_CONTINUE and sets |new_event| to NULL.
-  ui::EventRewriteStatus NextDispatchEvent(scoped_ptr<ui::Event>* new_event);
+  ui::EventRewriteStatus NextDispatchEvent(
+      std::unique_ptr<ui::Event>* new_event);
 
  private:
   // Handles keyboard event. Returns true if Sticky key consumes keyboard event.
   // Adds to |mod_down_flags| any flag to be added to the key event.
   // Sets |released| if any modifier is to be released after the key event.
   bool HandleKeyEvent(const ui::KeyEvent& event,
                       ui::KeyboardCode key_code,
                       int* mod_down_flags,
                       bool* released);
 
@@ skipping 15 matching lines @@
   // Whether sticky keys is activated and modifying events.
   bool enabled_;
 
   // Whether the current layout has a mod3 key.
   bool mod3_enabled_;
 
   // Whether the current layout has an altgr key.
   bool altgr_enabled_;
 
   // Sticky key handlers.
-  scoped_ptr<StickyKeysHandler> shift_sticky_key_;
-  scoped_ptr<StickyKeysHandler> alt_sticky_key_;
-  scoped_ptr<StickyKeysHandler> altgr_sticky_key_;
-  scoped_ptr<StickyKeysHandler> ctrl_sticky_key_;
-  scoped_ptr<StickyKeysHandler> mod3_sticky_key_;
-  scoped_ptr<StickyKeysHandler> search_sticky_key_;
+  std::unique_ptr<StickyKeysHandler> shift_sticky_key_;
+  std::unique_ptr<StickyKeysHandler> alt_sticky_key_;
+  std::unique_ptr<StickyKeysHandler> altgr_sticky_key_;
+  std::unique_ptr<StickyKeysHandler> ctrl_sticky_key_;
+  std::unique_ptr<StickyKeysHandler> mod3_sticky_key_;
+  std::unique_ptr<StickyKeysHandler> search_sticky_key_;
 
-  scoped_ptr<StickyKeysOverlay> overlay_;
+  std::unique_ptr<StickyKeysOverlay> overlay_;
 
   DISALLOW_COPY_AND_ASSIGN(StickyKeysController);
 };
 
 // StickyKeysHandler handles key event and controls sticky keysfor specific
 // modifier keys. If monitored keyboard events are recieved, StickyKeysHandler
 // changes internal state. If non modifier keyboard events or mouse events are
 // received, StickyKeysHandler will append modifier based on internal state.
 // For other events, StickyKeysHandler does nothing.
 //
@@ skipping 43 matching lines @@
   // Handles scroll event. Returns true if sticky key consumes scroll event.
   // Sets its own modifier flag in |mod_down_flags| if it is active and needs
   // to be added to the event, and sets |released| if releasing it.
   bool HandleScrollEvent(const ui::ScrollEvent& event,
                          int* mod_down_flags,
                          bool* released);
 
   // Fetches a pending modifier-up event if one exists and the return
   // parameter |new_event| is available (i.e. not set). Returns the number
   // of pending events still remaining to be returned.
-  int GetModifierUpEvent(scoped_ptr<ui::Event>* new_event);
+  int GetModifierUpEvent(std::unique_ptr<ui::Event>* new_event);
 
   // Returns current internal state.
   StickyKeyState current_state() const { return current_state_; }
 
  private:
   // Represents event type in Sticky Key context.
   enum KeyEventType {
     TARGET_MODIFIER_DOWN,  // The monitoring modifier key is down.
     TARGET_MODIFIER_UP,  // The monitoring modifier key is up.
     NORMAL_KEY_DOWN,  // The non modifier key is down.
@@ skipping 35 matching lines @@
   // shortcuts (eg. ctrl + t) during this time will prevent a transition to
   // the ENABLED state.
   bool preparing_to_enable_;
 
   // Tracks the scroll direction of the current scroll sequence. Sticky keys
   // stops modifying the scroll events of the sequence when the direction
   // changes. If no sequence is tracked, the value is 0.
   int scroll_delta_;
 
   // The modifier up key event to be sent on non modifier key on ENABLED state.
-  scoped_ptr<ui::KeyEvent> modifier_up_event_;
+  std::unique_ptr<ui::KeyEvent> modifier_up_event_;
 
   DISALLOW_COPY_AND_ASSIGN(StickyKeysHandler);
 };
 
 }  // namespace ash
 
 #endif  // ASH_STICKY_KEYS_STICKY_KEYS_CONTROLLER_H_