Replace scoped_ptr with std::unique_ptr in //ui

ui/ozone/platform/drm/host/drm_display_host_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/host/drm_display_host_manager.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <xf86drm.h>
+
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/events/ozone/device/device_event.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/ozone/common/display_util.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/host/drm_device_handle.h"
 #include "ui/ozone/platform/drm/host/drm_display_host.h"
 #include "ui/ozone/platform/drm/host/drm_native_display_delegate.h"
 #include "ui/ozone/platform/drm/host/gpu_thread_adapter.h"
 
 namespace ui {
 
 namespace {
 
 typedef base::Callback<void(const base::FilePath&,
                             const base::FilePath&,
-                            scoped_ptr<DrmDeviceHandle>)>
+                            std::unique_ptr<DrmDeviceHandle>)>
     OnOpenDeviceReplyCallback;
 
 const char kDefaultGraphicsCardPattern[] = "/dev/dri/card%d";
 
 const char* kDisplayActionString[] = {
     "ADD", "REMOVE", "CHANGE",
 };
 
 // Find sysfs device path for the given device path.
 base::FilePath MapDevPathToSysPath(const base::FilePath& device_path) {
   // |device_path| looks something like /dev/dri/card0. We take the basename of
   // that (card0) and append it to /sys/class/drm. /sys/class/drm/card0 is a
   // symlink that points to something like
   // /sys/devices/pci0000:00/0000:00:02.0/0000:05:00.0/drm/card0, which exposes
   // some metadata about the attached device.
   return base::MakeAbsoluteFilePath(
       base::FilePath("/sys/class/drm").Append(device_path.BaseName()));
 }
 
 void OpenDeviceOnWorkerThread(
     const base::FilePath& device_path,
     const scoped_refptr<base::TaskRunner>& reply_runner,
     const OnOpenDeviceReplyCallback& callback) {
   base::FilePath sys_path = MapDevPathToSysPath(device_path);
 
-  scoped_ptr<DrmDeviceHandle> handle(new DrmDeviceHandle());
+  std::unique_ptr<DrmDeviceHandle> handle(new DrmDeviceHandle());
   handle->Initialize(device_path, sys_path);
   reply_runner->PostTask(FROM_HERE,
                          base::Bind(callback, device_path, sys_path,
                                     base::Passed(std::move(handle))));
 }
 
 base::FilePath GetPrimaryDisplayCardPath() {
   struct drm_mode_card_res res;
   for (int i = 0; /* end on first card# that does not exist */; i++) {
     std::string card_path = base::StringPrintf(kDefaultGraphicsCardPattern, i);
@@ skipping 19 matching lines @@
 
   LOG(FATAL) << "Failed to open primary graphics device.";
   return base::FilePath();  // Not reached.
 }
 
 class FindDrmDisplayHostById {
  public:
   explicit FindDrmDisplayHostById(int64_t display_id)
       : display_id_(display_id) {}
 
-  bool operator()(const scoped_ptr<DrmDisplayHost>& display) const {
+  bool operator()(const std::unique_ptr<DrmDisplayHost>& display) const {
     return display->snapshot()->display_id() == display_id_;
   }
 
  private:
   int64_t display_id_;
 };
 
 }  // namespace
 
 DrmDisplayHostManager::DrmDisplayHostManager(
@@ skipping 25 matching lines @@
   }
 
   device_manager_->AddObserver(this);
   proxy_->RegisterHandlerForDrmDisplayHostManager(this);
   proxy_->AddGpuThreadObserver(this);
 
   ScopedVector<HardwareDisplayControllerInfo> display_infos =
       GetAvailableDisplayControllerInfos(primary_drm_device_handle_->fd());
   has_dummy_display_ = !display_infos.empty();
   for (size_t i = 0; i < display_infos.size(); ++i) {
-    displays_.push_back(make_scoped_ptr(new DrmDisplayHost(
+    displays_.push_back(base::WrapUnique(new DrmDisplayHost(
         proxy_, CreateDisplaySnapshotParams(
                     display_infos[i], primary_drm_device_handle_->fd(),
                     primary_drm_device_handle_->sys_path(), 0, gfx::Point()),
         true /* is_dummy */)));
   }
 }
 
 DrmDisplayHostManager::~DrmDisplayHostManager() {
   device_manager_->RemoveObserver(this);
   proxy_->UnRegisterHandlerForDrmDisplayHostManager();
@@ skipping 114 matching lines @@
           drm_devices_.erase(it);
         }
         break;
     }
   }
 }
 
 void DrmDisplayHostManager::OnAddGraphicsDevice(
     const base::FilePath& dev_path,
     const base::FilePath& sys_path,
-    scoped_ptr<DrmDeviceHandle> handle) {
+    std::unique_ptr<DrmDeviceHandle> handle) {
   if (handle->IsValid()) {
     drm_devices_[dev_path] = sys_path;
     proxy_->GpuAddGraphicsDevice(sys_path,
                                  base::FileDescriptor(handle->PassFD()));
     NotifyDisplayDelegate();
   }
 
   task_pending_ = false;
   ProcessEvent();
 }
@@ skipping 27 matching lines @@
   }
 
   // Signal that we're taking DRM master since we're going through the
   // initialization process again and we'll take all the available resources.
   if (!take_display_control_callback_.is_null())
     GpuTookDisplayControl(true);
 
   if (!relinquish_display_control_callback_.is_null())
     GpuRelinquishedDisplayControl(false);
 
-  scoped_ptr<DrmDeviceHandle> handle = std::move(primary_drm_device_handle_);
+  std::unique_ptr<DrmDeviceHandle> handle =
+      std::move(primary_drm_device_handle_);
   {
     base::ThreadRestrictions::ScopedAllowIO allow_io;
 
     drm_devices_.clear();
     drm_devices_[primary_graphics_card_path_] =
         MapDevPathToSysPath(primary_graphics_card_path_);
 
     if (!handle) {
       handle.reset(new DrmDeviceHandle());
       if (!handle->Initialize(primary_graphics_card_path_,
                               drm_devices_[primary_graphics_card_path_]))
         LOG(FATAL) << "Failed to open primary graphics card";
     }
   }
 
   // Send the primary device first since this is used to initialize graphics
   // state.
   proxy_->GpuAddGraphicsDevice(drm_devices_[primary_graphics_card_path_],
                                base::FileDescriptor(handle->PassFD()));
 
   device_manager_->ScanDevices(this);
   NotifyDisplayDelegate();
 }
 
 void DrmDisplayHostManager::OnGpuThreadRetired() {}
 
 void DrmDisplayHostManager::GpuHasUpdatedNativeDisplays(
     const std::vector<DisplaySnapshot_Params>& params) {
-  std::vector<scoped_ptr<DrmDisplayHost>> old_displays;
+  std::vector<std::unique_ptr<DrmDisplayHost>> old_displays;
   displays_.swap(old_displays);
   for (size_t i = 0; i < params.size(); ++i) {
     auto it = std::find_if(old_displays.begin(), old_displays.end(),
                            FindDrmDisplayHostById(params[i].display_id));
     if (it == old_displays.end()) {
-      displays_.push_back(make_scoped_ptr(
+      displays_.push_back(base::WrapUnique(
           new DrmDisplayHost(proxy_, params[i], false /* is_dummy */)));
     } else {
       (*it)->UpdateDisplaySnapshot(params[i]);
       displays_.push_back(std::move(*it));
       old_displays.erase(it);
     }
   }
 
   if (!get_displays_callback_.is_null()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 80 matching lines @@
 
   callback.Run(snapshots);
 }
 
 void DrmDisplayHostManager::NotifyDisplayDelegate() const {
   if (delegate_)
     delegate_->OnConfigurationChanged();
 }
 
 }  // namespace ui