Convert //ash from scoped_ptr to std::unique_ptr

ash/wm/drag_window_controller.cc

 // 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.
 
 #include "ash/wm/drag_window_controller.h"
 
 #include <algorithm>
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_util.h"
+#include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_tree_owner.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/views/view.h"
@@ skipping 131 matching lines @@
   void OnWindowDestroying(aura::Window* window) override {
     DCHECK_EQ(drag_window_, window);
     drag_window_ = nullptr;
   }
 
   aura::Window* root_window_;
 
   aura::Window* drag_window_ = nullptr;  // Owned by the container.
 
   // The copy of window_->layer() and its descendants.
-  scoped_ptr<ui::LayerTreeOwner> layer_owner_;
+  std::unique_ptr<ui::LayerTreeOwner> layer_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(DragWindowDetails);
 };
 
 // static
 float DragWindowController::GetDragWindowOpacity(
     const gfx::Rect& window_bounds,
     const gfx::Rect& visible_bounds) {
   // The maximum opacity of the drag phantom window.
   static const float kMaxOpacity = 0.8f;
 
   return kMaxOpacity * visible_bounds.size().GetArea() /
          window_bounds.size().GetArea();
 }
 
 DragWindowController::DragWindowController(aura::Window* window)
     : window_(window) {
   DCHECK(drag_windows_.empty());
   gfx::Screen* screen = gfx::Screen::GetScreen();
   gfx::Display current = screen->GetDisplayNearestWindow(window_);
 
   for (const gfx::Display& display : screen->GetAllDisplays()) {
     if (current.id() == display.id())
       continue;
     drag_windows_.push_back(
-        make_scoped_ptr(new DragWindowDetails(display, window_)));
+        base::WrapUnique(new DragWindowDetails(display, window_)));
   }
 }
 
 DragWindowController::~DragWindowController() {}
 
 void DragWindowController::Update(const gfx::Rect& bounds_in_screen,
                                   const gfx::Point& drag_location_in_screen) {
-  for (scoped_ptr<DragWindowDetails>& details : drag_windows_)
+  for (std::unique_ptr<DragWindowDetails>& details : drag_windows_)
     details->Update(window_, bounds_in_screen, drag_location_in_screen);
 }
 
 int DragWindowController::GetDragWindowsCountForTest() const {
   int count = 0;
-  for (const scoped_ptr<DragWindowDetails>& details : drag_windows_) {
+  for (const std::unique_ptr<DragWindowDetails>& details : drag_windows_) {
     if (details->drag_window_)
       count++;
   }
   return count;
 }
 
 const aura::Window* DragWindowController::GetDragWindowForTest(
     size_t index) const {
-  for (const scoped_ptr<DragWindowDetails>& details : drag_windows_) {
+  for (const std::unique_ptr<DragWindowDetails>& details : drag_windows_) {
     if (details->drag_window_) {
       if (index == 0)
         return details->drag_window_;
       index--;
     }
   }
   return nullptr;
 }
 
 const ui::LayerTreeOwner* DragWindowController::GetDragLayerOwnerForTest(
     size_t index) const {
-  for (const scoped_ptr<DragWindowDetails>& details : drag_windows_) {
+  for (const std::unique_ptr<DragWindowDetails>& details : drag_windows_) {
     if (details->layer_owner_) {
       if (index == 0)
         return details->layer_owner_.get();
       index--;
     }
   }
   return nullptr;
 }
 
 }  // namespace ash