Convert //ash from scoped_ptr to std::unique_ptr

ash/wm/window_state.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_WM_WINDOW_STATE_H_
 #define ASH_WM_WINDOW_STATE_H_
 
+#include <memory>
+
 #include "ash/ash_export.h"
 #include "ash/wm/drag_details.h"
 #include "ash/wm/wm_types.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/ui_base_types.h"
 
 namespace aura {
 class Window;
 }
 
 namespace gfx {
 class Rect;
@@ skipping 54 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(State);
   };
 
   // Call GetWindowState() to instantiate this class.
   ~WindowState() override;
 
   aura::Window* window() { return window_; }
   const aura::Window* window() const { return window_; }
 
   bool HasDelegate() const;
-  void SetDelegate(scoped_ptr<WindowStateDelegate> delegate);
+  void SetDelegate(std::unique_ptr<WindowStateDelegate> delegate);
 
   // Returns the window's current ash state type.
   // Refer to WindowStateType definition in wm_types.h as for why Ash
   // has its own state type.
   WindowStateType GetStateType() const;
 
   // Predicates to check window state.
   bool IsMinimized() const;
   bool IsMaximized() const;
   bool IsFullscreen() const;
@@ skipping 70 matching lines @@
   // Sets the restore bounds property on the window in the virtual screen
   // coordinates.  Deletes existing bounds value if exists.
   void SetRestoreBoundsInScreen(const gfx::Rect& bounds_in_screen);
 
   // Deletes and clears the restore bounds property on the window.
   void ClearRestoreBounds();
 
   // Replace the State object of a window with a state handler which can
   // implement a new window manager type. The passed object will be owned
   // by this object and the returned object will be owned by the caller.
-  scoped_ptr<State> SetStateObject(scoped_ptr<State> new_state);
+  std::unique_ptr<State> SetStateObject(std::unique_ptr<State> new_state);
 
   // True if the window should be unminimized to the restore bounds, as
   // opposed to the window's current bounds. |unminimized_to_restore_bounds_| is
   // reset to the default value after the window is unminimized.
   bool unminimize_to_restore_bounds() const {
     return unminimize_to_restore_bounds_;
   }
   void set_unminimize_to_restore_bounds(bool value) {
     unminimize_to_restore_bounds_ = value;
   }
@@ skipping 163 matching lines @@
   // Sets the wndow's |bounds| and transitions to the new bounds with
   // a scale animation.
   void SetBoundsDirectAnimated(const gfx::Rect& bounds);
 
   // Sets the window's |bounds| and transition to the new bounds with
   // a cross fade animation.
   void SetBoundsDirectCrossFade(const gfx::Rect& bounds);
 
   // The owner of this window settings.
   aura::Window* window_;
-  scoped_ptr<WindowStateDelegate> delegate_;
+  std::unique_ptr<WindowStateDelegate> delegate_;
 
   bool window_position_managed_;
   bool bounds_changed_by_user_;
   bool panel_attached_;
   bool ignored_by_shelf_;
   bool can_consume_system_keys_;
   bool top_row_keys_are_function_keys_;
-  scoped_ptr<DragDetails> drag_details_;
+  std::unique_ptr<DragDetails> drag_details_;
 
   bool unminimize_to_restore_bounds_;
   bool in_immersive_fullscreen_;
   bool hide_shelf_when_fullscreen_;
   bool minimum_visibility_;
   bool can_be_dragged_;
   bool cached_always_on_top_;
 
   // A property to remember the window position which was set before the
   // auto window position manager changed the window bounds, so that it can get
   // restored when only this one window gets shown.
-  scoped_ptr<gfx::Rect> pre_auto_manage_window_bounds_;
+  std::unique_ptr<gfx::Rect> pre_auto_manage_window_bounds_;
 
   base::ObserverList<WindowStateObserver> observer_list_;
 
   // True to ignore a property change event to avoid reentrance in
   // UpdateWindowStateType()
   bool ignore_property_change_;
 
-  scoped_ptr<State> current_state_;
+  std::unique_ptr<State> current_state_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowState);
 };
 
 // Returns the WindowState for active window. Returns |NULL|
 // if there is no active window.
 ASH_EXPORT WindowState* GetActiveWindowState();
 
 // Returns the WindowState for |window|. Creates WindowState
 // if it didn't exist. The settings object is owned by |window|.
 ASH_EXPORT WindowState* GetWindowState(aura::Window* window);
 
 // const version of GetWindowState.
 ASH_EXPORT const WindowState*
 GetWindowState(const aura::Window* window);
 
 }  // namespace wm
 }  // namespace ash
 
 #endif  // ASH_WM_WINDOW_STATE_H_