Replace scoped_ptr with std::unique_ptr in //ui

ui/views/view.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_VIEWS_VIEW_H_
 #define UI_VIEWS_VIEW_H_
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drop_target_event.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer_delegate.h"
 #include "ui/compositor/layer_owner.h"
 #include "ui/compositor/paint_cache.h"
@@ skipping 276 matching lines @@
 
   // Sets whether this view paints to a layer. A view paints to a layer if
   // either of the following are true:
   // . the view has a non-identity transform.
   // . SetPaintToLayer(true) has been invoked.
   // View creates the Layer only when it exists in a Widget with a non-NULL
   // Compositor.
   void SetPaintToLayer(bool paint_to_layer);
 
   // Overridden from ui::LayerOwner:
-  scoped_ptr<ui::Layer> RecreateLayer() override;
+  std::unique_ptr<ui::Layer> RecreateLayer() override;
 
   // RTL positioning -----------------------------------------------------------
 
   // Methods for accessing the bounds and position of the view, relative to its
   // parent. The position returned is mirrored if the parent view is using a RTL
   // layout.
   //
   // NOTE: in the vast majority of the cases, the mirroring implementation is
   //       transparent to the View subclasses and therefore you should use the
   //       bounds() accessor instead.
@@ skipping 169 matching lines @@
   // to paint itself via the various OnPaint*() event handlers and then paints
   // the hierarchy beneath it.
   void Paint(const ui::PaintContext& parent_context);
 
   // The background object is owned by this object and may be NULL.
   void set_background(Background* b);
   const Background* background() const { return background_.get(); }
   Background* background() { return background_.get(); }
 
   // The border object is owned by this object and may be NULL.
-  virtual void SetBorder(scoped_ptr<Border> b);
+  virtual void SetBorder(std::unique_ptr<Border> b);
   const Border* border() const { return border_.get(); }
   Border* border() { return border_.get(); }
 
   // Get the theme provider from the parent widget.
   const ui::ThemeProvider* GetThemeProvider() const;
 
   // Returns the NativeTheme to use for this View. This calls through to
   // GetNativeTheme() on the Widget this View is in, or provides a default
   // theme if there's no widget. Warning: the default theme might not be
   // correct; you should probably override OnNativeThemeChanged().
@@ skipping 175 matching lines @@
   // Convenience method to retrieve the InputMethod associated with the
   // Widget that contains this view.
   ui::InputMethod* GetInputMethod() {
     return const_cast<ui::InputMethod*>(
         const_cast<const View*>(this)->GetInputMethod());
   }
   const ui::InputMethod* GetInputMethod() const;
 
   // Sets a new ViewTargeter for the view, and returns the previous
   // ViewTargeter.
-  scoped_ptr<ViewTargeter> SetEventTargeter(scoped_ptr<ViewTargeter> targeter);
+  std::unique_ptr<ViewTargeter> SetEventTargeter(
+      std::unique_ptr<ViewTargeter> targeter);
 
   // Returns the ViewTargeter installed on |this| if one exists,
   // otherwise returns the ViewTargeter installed on our root view.
   // The return value is guaranteed to be non-null.
   ViewTargeter* GetEffectiveViewTargeter() const;
 
   ViewTargeter* targeter() const { return targeter_.get(); }
 
   // Overridden from ui::EventTarget:
   bool CanAcceptEvent(const ui::Event& event) override;
   ui::EventTarget* GetParentTarget() override;
-  scoped_ptr<ui::EventTargetIterator> GetChildIterator() const override;
+  std::unique_ptr<ui::EventTargetIterator> GetChildIterator() const override;
   ui::EventTargeter* GetEventTargeter() override;
   void ConvertEventToTarget(ui::EventTarget* target,
                             ui::LocatedEvent* event) override;
 
   // Overridden from ui::EventHandler:
   void OnKeyEvent(ui::KeyEvent* event) override;
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnScrollEvent(ui::ScrollEvent* event) override;
   void OnTouchEvent(ui::TouchEvent* event) final;
   void OnGestureEvent(ui::GestureEvent* event) override;
@@ skipping 749 matching lines @@
   // still into this view, this view receives a mouse-enter event if this flag
   // is turned off, but doesn't if this flag is turned on.
   // This flag is initialized to false.
   bool notify_enter_exit_on_child_;
 
   // Whether or not RegisterViewForVisibleBoundsNotification on the RootView
   // has been invoked.
   bool registered_for_visible_bounds_notification_;
 
   // List of descendants wanting notification when their visible bounds change.
-  scoped_ptr<Views> descendants_to_notify_;
+  std::unique_ptr<Views> descendants_to_notify_;
 
   // Transformations -----------------------------------------------------------
 
   // Painting will be clipped to this path. TODO(estade): this doesn't work for
   // layers.
   gfx::Path clip_path_;
 
   // Layout --------------------------------------------------------------------
 
   // Whether the view needs to be laid out.
   bool needs_layout_;
 
   // The View's LayoutManager defines the sizing heuristics applied to child
   // Views. The default is absolute positioning according to bounds_.
-  scoped_ptr<LayoutManager> layout_manager_;
+  std::unique_ptr<LayoutManager> layout_manager_;
 
   // Whether this View's layer should be snapped to the pixel boundary.
   bool snap_layer_to_pixel_boundary_;
 
   // Painting ------------------------------------------------------------------
 
   // Background
-  scoped_ptr<Background> background_;
+  std::unique_ptr<Background> background_;
 
   // Border.
-  scoped_ptr<Border> border_;
+  std::unique_ptr<Border> border_;
 
   // Cached output of painting to be reused in future frames until invalidated.
   ui::PaintCache paint_cache_;
 
   // RTL painting --------------------------------------------------------------
 
   // Indicates whether or not the gfx::Canvas object passed to View::Paint()
   // is going to be flipped horizontally (using the appropriate transform) on
   // right-to-left locales for this View.
   bool flip_canvas_on_paint_for_rtl_ui_;
 
   // Accelerated painting ------------------------------------------------------
 
   bool paint_to_layer_;
 
   // Accelerators --------------------------------------------------------------
 
   // Focus manager accelerators registered on.
   FocusManager* accelerator_focus_manager_;
 
   // The list of accelerators. List elements in the range
   // [0, registered_accelerator_count_) are already registered to FocusManager,
   // and the rest are not yet.
-  scoped_ptr<std::vector<ui::Accelerator> > accelerators_;
+  std::unique_ptr<std::vector<ui::Accelerator>> accelerators_;
   size_t registered_accelerator_count_;
 
   // Focus ---------------------------------------------------------------------
 
   // Next view to be focused when the Tab key is pressed.
   View* next_focusable_view_;
 
   // Next view to be focused when the Shift-Tab key combination is pressed.
   View* previous_focusable_view_;
 
   // Whether this view can be focused.
   bool focusable_;
 
   // Whether this view is focusable if the user requires full keyboard access,
   // even though it may not be normally focusable.
   bool accessibility_focusable_;
 
   // Context menus -------------------------------------------------------------
 
   // The menu controller.
   ContextMenuController* context_menu_controller_;
 
   // Drag and drop -------------------------------------------------------------
 
   DragController* drag_controller_;
 
   // Input  --------------------------------------------------------------------
 
-  scoped_ptr<ViewTargeter> targeter_;
+  std::unique_ptr<ViewTargeter> targeter_;
 
   // Accessibility -------------------------------------------------------------
 
   // Belongs to this view, but it's reference-counted on some platforms
   // so we can't use a scoped_ptr. It's dereferenced in the destructor.
   NativeViewAccessibility* native_view_accessibility_;
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_VIEW_H_