Replace scoped_ptr with std::unique_ptr in //ui

ui/ozone/platform/drm/gpu/screen_manager.cc

 // Copyright 2014 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 "ui/ozone/platform/drm/gpu/screen_manager.h"
 
 #include <xf86drmMode.h>
+
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/crtc_controller.h"
 #include "ui/ozone/platform/drm/gpu/drm_console_buffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_window.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
@@ skipping 73 matching lines @@
   HardwareDisplayControllers::iterator it = FindDisplayController(drm, crtc);
   // TODO(dnicoara): Turn this into a DCHECK when async display configuration is
   // properly supported. (When there can't be a race between forcing initial
   // display configuration in ScreenManager and NativeDisplayDelegate creating
   // the display controllers.)
   if (it != controllers_.end()) {
     LOG(WARNING) << "Display controller (crtc=" << crtc << ") already present.";
     return;
   }
 
-  controllers_.push_back(make_scoped_ptr(new HardwareDisplayController(
-      scoped_ptr<CrtcController>(new CrtcController(drm, crtc, connector)),
+  controllers_.push_back(base::WrapUnique(new HardwareDisplayController(
+      std::unique_ptr<CrtcController>(new CrtcController(drm, crtc, connector)),
       gfx::Point())));
 }
 
 void ScreenManager::RemoveDisplayController(const scoped_refptr<DrmDevice>& drm,
                                             uint32_t crtc) {
   HardwareDisplayControllers::iterator it = FindDisplayController(drm, crtc);
   if (it != controllers_.end()) {
     bool is_mirrored = (*it)->IsMirrored();
     (*it)->RemoveCrtc(drm, crtc);
     if (!is_mirrored) {
@@ skipping 46 matching lines @@
 
     // Just re-enable the controller to re-use the current state.
     return EnableController(controller);
   }
 
   // Either the mode or the location of the display changed, so exit mirror
   // mode and configure the display independently. If the caller still wants
   // mirror mode, subsequent calls configuring the other controllers will
   // restore mirror mode.
   if (controller->IsMirrored()) {
-    controllers_.push_back(make_scoped_ptr(new HardwareDisplayController(
+    controllers_.push_back(base::WrapUnique(new HardwareDisplayController(
         controller->RemoveCrtc(drm, crtc), controller->origin())));
     it = controllers_.end() - 1;
     controller = it->get();
   }
 
   HardwareDisplayControllers::iterator mirror =
       FindActiveDisplayControllerByLocation(modeset_bounds);
   // Handle mirror mode.
   if (mirror != controllers_.end() && it != mirror)
     return HandleMirrorMode(it, mirror, drm, crtc, connector, mode);
 
   return ModesetController(controller, origin, mode);
 }
 
 bool ScreenManager::DisableDisplayController(
     const scoped_refptr<DrmDevice>& drm,
     uint32_t crtc) {
   HardwareDisplayControllers::iterator it = FindDisplayController(drm, crtc);
   if (it != controllers_.end()) {
     HardwareDisplayController* controller = it->get();
     if (controller->IsMirrored()) {
-      controllers_.push_back(make_scoped_ptr(new HardwareDisplayController(
+      controllers_.push_back(base::WrapUnique(new HardwareDisplayController(
           controller->RemoveCrtc(drm, crtc), controller->origin())));
       controller = controllers_.back().get();
     }
 
     controller->Disable();
     UpdateControllerToWindowMapping();
     return true;
   }
 
   LOG(ERROR) << "Failed to find display controller crtc=" << crtc;
   return false;
 }
 
 HardwareDisplayController* ScreenManager::GetDisplayController(
     const gfx::Rect& bounds) {
   HardwareDisplayControllers::iterator it =
       FindActiveDisplayControllerByLocation(bounds);
   if (it != controllers_.end())
     return it->get();
 
   return nullptr;
 }
 
 void ScreenManager::AddWindow(gfx::AcceleratedWidget widget,
-                              scoped_ptr<DrmWindow> window) {
+                              std::unique_ptr<DrmWindow> window) {
   std::pair<WidgetToWindowMap::iterator, bool> result =
       window_map_.add(widget, std::move(window));
   DCHECK(result.second) << "Window already added.";
   UpdateControllerToWindowMapping();
 }
 
-scoped_ptr<DrmWindow> ScreenManager::RemoveWindow(
+std::unique_ptr<DrmWindow> ScreenManager::RemoveWindow(
     gfx::AcceleratedWidget widget) {
-  scoped_ptr<DrmWindow> window = window_map_.take_and_erase(widget);
+  std::unique_ptr<DrmWindow> window = window_map_.take_and_erase(widget);
   DCHECK(window) << "Attempting to remove non-existing window for " << widget;
   UpdateControllerToWindowMapping();
   return window;
 }
 
 DrmWindow* ScreenManager::GetWindow(gfx::AcceleratedWidget widget) {
   WidgetToWindowMap::iterator it = window_map_.find(widget);
   if (it != window_map_.end())
     return it->second;
 
@@ skipping 144 matching lines @@
 DrmWindow* ScreenManager::FindWindowAt(const gfx::Rect& bounds) const {
   for (auto pair : window_map_) {
     if (pair.second->bounds() == bounds)
       return pair.second;
   }
 
   return nullptr;
 }
 
 }  // namespace ui