Replace scoped_ptr with std::unique_ptr in //ui

ui/events/event.h

 // Copyright (c) 2012 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_EVENTS_EVENT_H_
 #define UI_EVENTS_EVENT_H_
 
 #include <stdint.h>
+
+#include <memory>
+
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/gesture_event_details.h"
 #include "ui/events/gestures/gesture_types.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_conversions.h"
 
@@ skipping 10 matching lines @@
 class KeyEvent;
 class MouseEvent;
 class MouseWheelEvent;
 class PointerEvent;
 class ScrollEvent;
 class TouchEvent;
 enum class DomCode;
 class Event;
 class MouseWheelEvent;
 
-using ScopedEvent = scoped_ptr<Event>;
+using ScopedEvent = std::unique_ptr<Event>;
 
 class EVENTS_EXPORT Event {
  public:
-  static scoped_ptr<Event> Clone(const Event& event);
+  static std::unique_ptr<Event> Clone(const Event& event);
 
   virtual ~Event();
 
   class DispatcherApi {
    public:
     explicit DispatcherApi(Event* event) : event_(event) {}
 
     void set_target(EventTarget* target) {
       event_->target_ = target;
     }
@@ skipping 792 matching lines @@
   KeyEvent& operator=(const KeyEvent& rhs);
 
   ~KeyEvent() override;
 
   // TODO(erg): While we transition to mojo, we have to hack around a mismatch
   // in our event types. Our ui::Events don't really have all the data we need
   // to process key events, and we instead do per-platform conversions with
   // native HWNDs or XEvents. And we can't reliably send those native data
   // types across mojo types in a cross-platform way. So instead, we set the
   // resulting data when read across IPC boundaries.
-  void SetExtendedKeyEventData(scoped_ptr<ExtendedKeyEventData> data);
+  void SetExtendedKeyEventData(std::unique_ptr<ExtendedKeyEventData> data);
   const ExtendedKeyEventData* extended_key_event_data() const {
     return extended_key_event_data_.get();
   }
 
   // This bypasses the normal mapping from keystroke events to characters,
   // which allows an I18N virtual keyboard to fabricate a keyboard event that
   // does not have a corresponding KeyboardCode (example: U+00E1 Latin small
   // letter A with acute, U+0410 Cyrillic capital letter A).
   void set_character(base::char16 character) {
     key_ = DomKey::FromCharacter(character);
@@ skipping 92 matching lines @@
   // This value represents the meaning of a key, which is either a Unicode
   // character, or a named DomKey:: value.
   // This is not necessarily initialized when the event is constructed;
   // it may be set only if and when GetCharacter() or GetDomKey() is called.
   mutable DomKey key_ = DomKey::NONE;
 
   // Parts of our event handling require raw native events (see both the
   // windows and linux implementations of web_input_event in content/). Because
   // mojo instead serializes and deserializes events in potentially different
   // processes, we need to have a mechanism to keep track of this data.
-  scoped_ptr<ExtendedKeyEventData> extended_key_event_data_;
+  std::unique_ptr<ExtendedKeyEventData> extended_key_event_data_;
 
   static bool IsRepeated(const KeyEvent& event);
 
   static KeyEvent* last_key_event_;
 };
 
 class EVENTS_EXPORT ScrollEvent : public MouseEvent {
  public:
   explicit ScrollEvent(const base::NativeEvent& native_event);
   template <class T>
@@ skipping 74 matching lines @@
       : LocatedEvent(type, time_stamp, flags) {}
   friend struct IPC::ParamTraits<ui::ScopedEvent>;
   friend struct IPC::ParamTraits<ui::GestureEvent>;
 
   GestureEventDetails details_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_