Convert //ash from scoped_ptr to std::unique_ptr

ash/wm/window_state.cc

 // 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.
 
 #include "ash/wm/window_state.h"
 
 #include <utility>
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
@@ skipping 77 matching lines @@
   // WindowState is registered as an owned property of |window_|, and window
   // unregisters all of its observers in its d'tor before destroying its
   // properties. As a result, window_->RemoveObserver() doesn't need to (and
   // shouldn't) be called here.
 }
 
 bool WindowState::HasDelegate() const {
   return !!delegate_;
 }
 
-void WindowState::SetDelegate(scoped_ptr<WindowStateDelegate> delegate) {
+void WindowState::SetDelegate(std::unique_ptr<WindowStateDelegate> delegate) {
   DCHECK(!delegate_.get());
   delegate_ = std::move(delegate);
 }
 
 WindowStateType WindowState::GetStateType() const {
   return current_state_->GetType();
 }
 
 bool WindowState::IsMinimized() const {
   return GetStateType() == WINDOW_STATE_TYPE_MINIMIZED ||
@@ skipping 167 matching lines @@
 
 void WindowState::SetRestoreBoundsInParent(const gfx::Rect& bounds) {
   SetRestoreBoundsInScreen(
       ScreenUtil::ConvertRectToScreen(window_->parent(), bounds));
 }
 
 void WindowState::ClearRestoreBounds() {
   window_->ClearProperty(aura::client::kRestoreBoundsKey);
 }
 
-scoped_ptr<WindowState::State> WindowState::SetStateObject(
-    scoped_ptr<WindowState::State> new_state) {
+std::unique_ptr<WindowState::State> WindowState::SetStateObject(
+    std::unique_ptr<WindowState::State> new_state) {
   current_state_->DetachState(this);
-  scoped_ptr<WindowState::State> old_object = std::move(current_state_);
+  std::unique_ptr<WindowState::State> old_object = std::move(current_state_);
   current_state_ = std::move(new_state);
   current_state_->AttachState(this, old_object.get());
   return old_object;
 }
 
 void WindowState::SetPreAutoManageWindowBounds(
     const gfx::Rect& bounds) {
   pre_auto_manage_window_bounds_.reset(new gfx::Rect(bounds));
 }
 
@@ skipping 158 matching lines @@
     return;
   }
 
   const gfx::Rect old_bounds = window_->bounds();
 
   // Create fresh layers for the window and all its children to paint into.
   // Takes ownership of the old layer and all its children, which will be
   // cleaned up after the animation completes.
   // Specify |set_bounds| to true here to keep the old bounds in the child
   // windows of |window|.
-  scoped_ptr<ui::LayerTreeOwner> old_layer_owner =
+  std::unique_ptr<ui::LayerTreeOwner> old_layer_owner =
       ::wm::RecreateLayers(window_);
   ui::Layer* old_layer = old_layer_owner->root();
   DCHECK(old_layer);
   ui::Layer* new_layer = window_->layer();
 
   // Resize the window to the new size, which will force a layout and paint.
   SetBoundsDirect(new_bounds);
 
   // Ensure the higher-resolution layer is on top.
   bool old_on_top = (old_bounds.width() > new_bounds.width());
@@ skipping 20 matching lines @@
   }
   return settings;
 }
 
 const WindowState* GetWindowState(const aura::Window* window) {
   return GetWindowState(const_cast<aura::Window*>(window));
 }
 
 }  // namespace wm
 }  // namespace ash