Replace scoped_ptr with std::unique_ptr in //ui

ui/ozone/platform/drm/gpu/hardware_display_plane_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/hardware_display_plane_manager.h"
 
 #include <drm_fourcc.h>
 
 #include <set>
 #include <utility>
@@ skipping 82 matching lines @@
   for (uint32_t i = 0; i < num_planes; ++i) {
     ScopedDrmPlanePtr drm_plane(
         drmModeGetPlane(drm->get_fd(), plane_resources->planes[i]));
     if (!drm_plane) {
       PLOG(ERROR) << "Failed to get plane " << i;
       return false;
     }
 
     uint32_t formats_size = drm_plane->count_formats;
     plane_ids.insert(drm_plane->plane_id);
-    scoped_ptr<HardwareDisplayPlane> plane(
+    std::unique_ptr<HardwareDisplayPlane> plane(
         CreatePlane(drm_plane->plane_id, drm_plane->possible_crtcs));
 
     std::vector<uint32_t> supported_formats(formats_size);
     for (uint32_t j = 0; j < formats_size; j++)
       supported_formats[j] = drm_plane->formats[j];
 
     if (plane->Initialize(drm, supported_formats, false, false)) {
       // CRTC controllers always assume they have a cursor plane and the cursor
       // plane is updated via cursor specific DRM API. Hence, we dont keep
       // track of Cursor plane here to avoid re-using it for any other purpose.
       if (plane->type() != HardwareDisplayPlane::kCursor)
         planes_.push_back(std::move(plane));
     }
   }
 
   // crbug.com/464085: if driver reports no primary planes for a crtc, create a
   // dummy plane for which we can assign exactly one overlay.
   // TODO(dnicoara): refactor this to simplify AssignOverlayPlanes and move
   // this workaround into HardwareDisplayPlaneLegacy.
   if (!has_universal_planes) {
     for (int i = 0; i < resources->count_crtcs; ++i) {
       if (plane_ids.find(resources->crtcs[i] - 1) == plane_ids.end()) {
-        scoped_ptr<HardwareDisplayPlane> dummy_plane(
+        std::unique_ptr<HardwareDisplayPlane> dummy_plane(
             CreatePlane(resources->crtcs[i] - 1, (1 << i)));
         if (dummy_plane->Initialize(drm, std::vector<uint32_t>(), true,
                                     false)) {
           planes_.push_back(std::move(dummy_plane));
         }
       }
     }
   }
 
   std::sort(planes_.begin(), planes_.end(),
-            [](const scoped_ptr<HardwareDisplayPlane>& l,
-               const scoped_ptr<HardwareDisplayPlane>& r) {
+            [](const std::unique_ptr<HardwareDisplayPlane>& l,
+               const std::unique_ptr<HardwareDisplayPlane>& r) {
               return l->plane_id() < r->plane_id();
             });
 
   PopulateSupportedFormats();
   return true;
 }
 
-scoped_ptr<HardwareDisplayPlane> HardwareDisplayPlaneManager::CreatePlane(
+std::unique_ptr<HardwareDisplayPlane> HardwareDisplayPlaneManager::CreatePlane(
     uint32_t plane_id,
     uint32_t possible_crtcs) {
-  return scoped_ptr<HardwareDisplayPlane>(
+  return std::unique_ptr<HardwareDisplayPlane>(
       new HardwareDisplayPlane(plane_id, possible_crtcs));
 }
 
 HardwareDisplayPlane* HardwareDisplayPlaneManager::FindNextUnusedPlane(
     size_t* index,
     uint32_t crtc_index,
     const OverlayPlane& overlay) const {
   for (size_t i = *index; i < planes_.size(); ++i) {
     auto plane = planes_[i].get();
     if (!plane->in_use() && IsCompatible(plane, overlay, crtc_index)) {
@@ skipping 166 matching lines @@
       break;
     } else {
       plane_z_order++;
     }
   }
 
   return format_supported;
 }
 
 }  // namespace ui