Replace scoped_ptr with std::unique_ptr in //ui

ui/ozone/platform/drm/gpu/drm_gpu_display_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/drm_gpu_display_manager.h"
 
 #include <stddef.h>
 
+#include "base/memory/ptr_util.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
 #include "ui/ozone/common/display_util.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_display.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 
 namespace ui {
 
 namespace {
 
 class DisplayComparator {
  public:
   explicit DisplayComparator(const DrmDisplay* display)
       : drm_(display->drm()),
         crtc_(display->crtc()),
         connector_(display->connector()) {}
 
   DisplayComparator(const scoped_refptr<DrmDevice>& drm,
                     uint32_t crtc,
                     uint32_t connector)
       : drm_(drm), crtc_(crtc), connector_(connector) {}
 
-  bool operator()(const scoped_ptr<DrmDisplay>& other) const {
+  bool operator()(const std::unique_ptr<DrmDisplay>& other) const {
     return drm_ == other->drm() && connector_ == other->connector() &&
            crtc_ == other->crtc();
   }
 
  private:
   scoped_refptr<DrmDevice> drm_;
   uint32_t crtc_;
   uint32_t connector_;
 };
 
@@ skipping 17 matching lines @@
 
 DrmGpuDisplayManager::DrmGpuDisplayManager(ScreenManager* screen_manager,
                                            DrmDeviceManager* drm_device_manager)
     : screen_manager_(screen_manager), drm_device_manager_(drm_device_manager) {
 }
 
 DrmGpuDisplayManager::~DrmGpuDisplayManager() {
 }
 
 std::vector<DisplaySnapshot_Params> DrmGpuDisplayManager::GetDisplays() {
-  std::vector<scoped_ptr<DrmDisplay>> old_displays;
+  std::vector<std::unique_ptr<DrmDisplay>> old_displays;
   old_displays.swap(displays_);
   std::vector<DisplaySnapshot_Params> params_list;
 
   const DrmDeviceVector& devices = drm_device_manager_->GetDrmDevices();
   size_t device_index = 0;
   for (const auto& drm : devices) {
     ScopedVector<HardwareDisplayControllerInfo> display_infos =
         GetAvailableDisplayControllerInfos(drm->get_fd());
     for (auto* display_info : display_infos) {
       auto it = std::find_if(
           old_displays.begin(), old_displays.end(),
           DisplayComparator(drm, display_info->crtc()->crtc_id,
                             display_info->connector()->connector_id));
       if (it != old_displays.end()) {
         displays_.push_back(std::move(*it));
         old_displays.erase(it);
       } else {
         displays_.push_back(
-            make_scoped_ptr(new DrmDisplay(screen_manager_, drm)));
+            base::WrapUnique(new DrmDisplay(screen_manager_, drm)));
       }
       params_list.push_back(
           displays_.back()->Update(display_info, device_index));
     }
     device_index++;
   }
 
   NotifyScreenManager(displays_, old_displays);
   return params_list;
 }
@@ skipping 111 matching lines @@
 DrmDisplay* DrmGpuDisplayManager::FindDisplay(int64_t display_id) {
   for (const auto& display : displays_) {
     if (display->display_id() == display_id)
       return display.get();
   }
 
   return nullptr;
 }
 
 void DrmGpuDisplayManager::NotifyScreenManager(
-    const std::vector<scoped_ptr<DrmDisplay>>& new_displays,
-    const std::vector<scoped_ptr<DrmDisplay>>& old_displays) const {
+    const std::vector<std::unique_ptr<DrmDisplay>>& new_displays,
+    const std::vector<std::unique_ptr<DrmDisplay>>& old_displays) const {
   for (const auto& old_display : old_displays) {
     auto it = std::find_if(new_displays.begin(), new_displays.end(),
                            DisplayComparator(old_display.get()));
 
     if (it == new_displays.end()) {
       screen_manager_->RemoveDisplayController(old_display->drm(),
                                                old_display->crtc());
     }
   }
 
   for (const auto& new_display : new_displays) {
     auto it = std::find_if(old_displays.begin(), old_displays.end(),
                            DisplayComparator(new_display.get()));
 
     if (it == old_displays.end()) {
       screen_manager_->AddDisplayController(
           new_display->drm(), new_display->crtc(), new_display->connector());
     }
   }
 }
 
 }  // namespace ui