Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/events/event_rewriter.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 CHROME_BROWSER_CHROMEOS_EVENTS_EVENT_REWRITER_H_
 #define CHROME_BROWSER_CHROMEOS_EVENTS_EVENT_REWRITER_H_
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "ui/events/event.h"
 #include "ui/events/event_rewriter.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 
 class PrefService;
 
 namespace ash {
 class StickyKeysController;
 }
 
@@ skipping 39 matching lines @@
   explicit EventRewriter(ash::StickyKeysController* sticky_keys_controller);
   ~EventRewriter() override;
 
   // Calls KeyboardDeviceAddedInternal.
   DeviceType KeyboardDeviceAddedForTesting(int device_id,
                                            const std::string& device_name);
 
   // Calls RewriteMouseEvent().
   void RewriteMouseButtonEventForTesting(
       const ui::MouseEvent& event,
-      scoped_ptr<ui::Event>* rewritten_event);
+      std::unique_ptr<ui::Event>* rewritten_event);
 
   const std::map<int, DeviceType>& device_id_to_type_for_testing() const {
     return device_id_to_type_;
   }
   void set_last_keyboard_device_id_for_testing(int device_id) {
     last_keyboard_device_id_ = device_id;
   }
   void set_pref_service_for_testing(const PrefService* pref_service) {
     pref_service_for_testing_ = pref_service;
   }
   void set_ime_keyboard_for_testing(
       chromeos::input_method::ImeKeyboard* ime_keyboard) {
     ime_keyboard_for_testing_ = ime_keyboard;
   }
 
   // EventRewriter overrides:
   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;
 
   // Generate a new key event from an original key event and the replacement
   // state determined by a key rewriter.
-  static void BuildRewrittenKeyEvent(const ui::KeyEvent& key_event,
-                                     const MutableKeyState& state,
-                                     scoped_ptr<ui::Event>* rewritten_event);
+  static void BuildRewrittenKeyEvent(
+      const ui::KeyEvent& key_event,
+      const MutableKeyState& state,
+      std::unique_ptr<ui::Event>* rewritten_event);
 
  private:
   void DeviceKeyPressedOrReleased(int device_id);
 
   // Returns the PrefService that should be used.
   const PrefService* GetPrefService() const;
 
   // Adds a device to |device_id_to_type_|.
   DeviceType KeyboardDeviceAdded(int device_id);
 
@@ skipping 19 matching lines @@
 
   // Given modifier flags |original_flags|, returns the remapped modifiers
   // according to user preferences and/or event properties.
   int GetRemappedModifierMasks(const PrefService& pref_service,
                                const ui::Event& event,
                                int original_flags) const;
 
   // Rewrite a particular kind of event.
   ui::EventRewriteStatus RewriteKeyEvent(
       const ui::KeyEvent& key_event,
-      scoped_ptr<ui::Event>* rewritten_event);
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus RewriteMouseButtonEvent(
       const ui::MouseEvent& mouse_event,
-      scoped_ptr<ui::Event>* rewritten_event);
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus RewriteMouseWheelEvent(
       const ui::MouseWheelEvent& mouse_event,
-      scoped_ptr<ui::Event>* rewritten_event);
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus RewriteTouchEvent(
       const ui::TouchEvent& touch_event,
-      scoped_ptr<ui::Event>* rewritten_event);
+      std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus RewriteScrollEvent(
       const ui::ScrollEvent& scroll_event,
-      scoped_ptr<ui::Event>* rewritten_event);
+      std::unique_ptr<ui::Event>* rewritten_event);
 
   // Rewriter phases. These can inspect the original |event|, but operate using
   // the current |state|, which may have been modified by previous phases.
   bool RewriteModifierKeys(const ui::KeyEvent& event, MutableKeyState* state);
   void RewriteNumPadKeys(const ui::KeyEvent& event, MutableKeyState* state);
   void RewriteExtendedKeys(const ui::KeyEvent& event, MutableKeyState* state);
   void RewriteFunctionKeys(const ui::KeyEvent& event, MutableKeyState* state);
   void RewriteLocatedEvent(const ui::Event& event, int* flags);
   int RewriteModifierClick(const ui::MouseEvent& event, int* flags);
 
@@ skipping 33 matching lines @@
   int pressed_modifier_latches_;
   int latched_modifier_latches_;
   int used_modifier_latches_;
 
   DISALLOW_COPY_AND_ASSIGN(EventRewriter);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_EVENTS_EVENT_REWRITER_H_