Replace scoped_ptr with std::unique_ptr in //ui

ui/ozone/platform/drm/ozone_platform_gbm.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/ozone_platform_gbm.h"
 
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <gbm.h>
 #include <stdlib.h>
 #include <xf86drm.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/event_factory_evdev.h"
 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
 #include "ui/ozone/platform/drm/common/drm_util.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_gpu_platform_support.h"
 #include "ui/ozone/platform/drm/gpu/drm_thread_message_proxy.h"
@@ skipping 71 matching lines @@
   }
   InputController* GetInputController() override {
     return event_factory_ozone_->input_controller();
   }
   GpuPlatformSupport* GetGpuPlatformSupport() override {
     return gpu_platform_support_.get();
   }
   GpuPlatformSupportHost* GetGpuPlatformSupportHost() override {
     return gpu_platform_support_host_.get();
   }
-  scoped_ptr<SystemInputInjector> CreateSystemInputInjector() override {
+  std::unique_ptr<SystemInputInjector> CreateSystemInputInjector() override {
     return event_factory_ozone_->CreateSystemInputInjector();
   }
-  scoped_ptr<PlatformWindow> CreatePlatformWindow(
+  std::unique_ptr<PlatformWindow> CreatePlatformWindow(
       PlatformWindowDelegate* delegate,
       const gfx::Rect& bounds) override {
     GpuThreadAdapter* adapter = gpu_platform_support_host_.get();
     if (RunningInsideMus()) {
       DCHECK(drm_thread_) << "drm_thread_ should exist (and be running) here.";
       adapter = mus_thread_proxy_.get();
     }
 
-    scoped_ptr<DrmWindowHost> platform_window(new DrmWindowHost(
+    std::unique_ptr<DrmWindowHost> platform_window(new DrmWindowHost(
         delegate, bounds, adapter, event_factory_ozone_.get(), cursor_.get(),
         window_manager_.get(), display_manager_.get(), overlay_manager_.get()));
     platform_window->Initialize();
     return std::move(platform_window);
   }
-  scoped_ptr<NativeDisplayDelegate> CreateNativeDisplayDelegate() override {
-    return make_scoped_ptr(
+  std::unique_ptr<NativeDisplayDelegate> CreateNativeDisplayDelegate()
+      override {
+    return base::WrapUnique(
         new DrmNativeDisplayDelegate(display_manager_.get()));
   }
   void InitializeUI() override {
     device_manager_ = CreateDeviceManager();
     window_manager_.reset(new DrmWindowHostManager());
     cursor_.reset(new DrmCursor(window_manager_.get()));
 #if defined(USE_XKBCOMMON)
-    KeyboardLayoutEngineManager::SetKeyboardLayoutEngine(make_scoped_ptr(
+    KeyboardLayoutEngineManager::SetKeyboardLayoutEngine(base::WrapUnique(
         new XkbKeyboardLayoutEngine(xkb_evdev_code_converter_)));
 #else
     KeyboardLayoutEngineManager::SetKeyboardLayoutEngine(
-        make_scoped_ptr(new StubKeyboardLayoutEngine()));
+        base::WrapUnique(new StubKeyboardLayoutEngine()));
 #endif
     event_factory_ozone_.reset(new EventFactoryEvdev(
         cursor_.get(), device_manager_.get(),
         KeyboardLayoutEngineManager::GetKeyboardLayoutEngine()));
 
     GpuThreadAdapter* adapter;
     if (RunningInsideMus()) {
       gl_api_loader_.reset(new GlApiLoader());
       mus_thread_proxy_.reset(new MusThreadProxy());
       adapter = mus_thread_proxy_.get();
@@ skipping 36 matching lines @@
     drm_thread_->BindThreadIntoMessagingProxy(itmp);
 
     surface_factory_.reset(new GbmSurfaceFactory(drm_thread_.get()));
     if (RunningInsideMus()) {
       mus_thread_proxy_->StartDrmThread();
     }
   }
 
  private:
   // Objects in the GPU process.
-  scoped_ptr<DrmThreadProxy> drm_thread_;
-  scoped_ptr<GlApiLoader> gl_api_loader_;
-  scoped_ptr<GbmSurfaceFactory> surface_factory_;
-  scoped_ptr<DrmGpuPlatformSupport> gpu_platform_support_;
+  std::unique_ptr<DrmThreadProxy> drm_thread_;
+  std::unique_ptr<GlApiLoader> gl_api_loader_;
+  std::unique_ptr<GbmSurfaceFactory> surface_factory_;
+  std::unique_ptr<DrmGpuPlatformSupport> gpu_platform_support_;
 
   // Objects in the Browser process.
-  scoped_ptr<DeviceManager> device_manager_;
-  scoped_ptr<BitmapCursorFactoryOzone> cursor_factory_ozone_;
-  scoped_ptr<DrmWindowHostManager> window_manager_;
-  scoped_ptr<DrmCursor> cursor_;
-  scoped_ptr<EventFactoryEvdev> event_factory_ozone_;
-  scoped_ptr<DrmGpuPlatformSupportHost> gpu_platform_support_host_;
-  scoped_ptr<DrmDisplayHostManager> display_manager_;
-  scoped_ptr<DrmOverlayManager> overlay_manager_;
+  std::unique_ptr<DeviceManager> device_manager_;
+  std::unique_ptr<BitmapCursorFactoryOzone> cursor_factory_ozone_;
+  std::unique_ptr<DrmWindowHostManager> window_manager_;
+  std::unique_ptr<DrmCursor> cursor_;
+  std::unique_ptr<EventFactoryEvdev> event_factory_ozone_;
+  std::unique_ptr<DrmGpuPlatformSupportHost> gpu_platform_support_host_;
+  std::unique_ptr<DrmDisplayHostManager> display_manager_;
+  std::unique_ptr<DrmOverlayManager> overlay_manager_;
 
   // Bridges the DRM, GPU and main threads in mus.
-  scoped_ptr<MusThreadProxy> mus_thread_proxy_;
+  std::unique_ptr<MusThreadProxy> mus_thread_proxy_;
 
 #if defined(USE_XKBCOMMON)
   XkbEvdevCodes xkb_evdev_code_converter_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(OzonePlatformGbm);
 };
 
 }  // namespace
 
 OzonePlatform* CreateOzonePlatformGbm() {
   return new OzonePlatformGbm;
 }
 
 }  // namespace ui