Replace scoped_ptr with std::unique_ptr in //ui

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

 // Copyright 2015 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_thread.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "ui/ozone/platform/drm/gpu/drm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_generator.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_gpu_display_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_window.h"
 #include "ui/ozone/platform/drm/gpu/drm_window_proxy.h"
 #include "ui/ozone/platform/drm/gpu/gbm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/gbm_device.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surface_factory.h"
@@ skipping 62 matching lines @@
     LOG(FATAL) << "Failed to create DRM thread";
 }
 
 void DrmThread::Init() {
   bool use_atomic = false;
 #if defined(USE_DRM_ATOMIC)
   use_atomic = true;
 #endif
 
   device_manager_.reset(new DrmDeviceManager(
-      make_scoped_ptr(new GbmDeviceGenerator(use_atomic))));
+      base::WrapUnique(new GbmDeviceGenerator(use_atomic))));
   buffer_generator_.reset(new GbmBufferGenerator());
   screen_manager_.reset(new ScreenManager(buffer_generator_.get()));
 
   display_manager_.reset(
       new DrmGpuDisplayManager(screen_manager_.get(), device_manager_.get()));
 }
 
 void DrmThread::CreateBuffer(gfx::AcceleratedWidget widget,
                              const gfx::Size& size,
                              gfx::BufferFormat format,
@@ skipping 38 matching lines @@
     const gfx::VSyncProvider::UpdateVSyncCallback& callback) {
   DrmWindow* window = screen_manager_->GetWindow(widget);
   // No need to call the callback if there isn't a window since the vsync
   // provider doesn't require the callback to be called if there isn't a vsync
   // data source.
   if (window)
     window->GetVSyncParameters(callback);
 }
 
 void DrmThread::CreateWindow(gfx::AcceleratedWidget widget) {
-  scoped_ptr<DrmWindow> window(
+  std::unique_ptr<DrmWindow> window(
       new DrmWindow(widget, device_manager_.get(), screen_manager_.get()));
   window->Initialize(buffer_generator_.get());
   screen_manager_->AddWindow(widget, std::move(window));
 }
 
 void DrmThread::DestroyWindow(gfx::AcceleratedWidget widget) {
-  scoped_ptr<DrmWindow> window = screen_manager_->RemoveWindow(widget);
+  std::unique_ptr<DrmWindow> window = screen_manager_->RemoveWindow(widget);
   window->Shutdown();
 }
 
 void DrmThread::SetWindowBounds(gfx::AcceleratedWidget widget,
                                 const gfx::Rect& bounds) {
   screen_manager_->GetWindow(widget)->SetBounds(bounds);
 }
 
 void DrmThread::SetCursor(gfx::AcceleratedWidget widget,
                           const std::vector<SkBitmap>& bitmaps,
@@ skipping 75 matching lines @@
 void DrmThread::SetColorCorrection(
     int64_t display_id,
     const std::vector<GammaRampRGBEntry>& degamma_lut,
     const std::vector<GammaRampRGBEntry>& gamma_lut,
     const std::vector<float>& correction_matrix) {
   display_manager_->SetColorCorrection(display_id, degamma_lut, gamma_lut,
                                        correction_matrix);
 }
 
 }  // namespace ui