Replace scoped_ptr with std::unique_ptr in //ui

ui/ozone/platform/egltest/ozone_platform_egltest.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/egltest/ozone_platform_egltest.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/threading/thread_checker.h"
 #include "library_loaders/libeglplatform_shim.h"
 #include "third_party/khronos/EGL/egl.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/event.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/event_factory_evdev.h"
 #include "ui/events/ozone/events_ozone.h"
 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
@@ skipping 19 matching lines @@
 namespace {
 
 const char kEglplatformShim[] = "EGLPLATFORM_SHIM";
 const char kEglplatformShimDefault[] = "libeglplatform_shim.so.1";
 const char kDefaultEglSoname[] = "libEGL.so.1";
 const char kDefaultGlesSoname[] = "libGLESv2.so.2";
 
 // Get the library soname to load.
 std::string GetShimLibraryName() {
   std::string library;
-  scoped_ptr<base::Environment> env(base::Environment::Create());
+  std::unique_ptr<base::Environment> env(base::Environment::Create());
   if (env->GetVar(kEglplatformShim, &library))
     return library;
   return kEglplatformShimDefault;
 }
 
 // Touch events are reported in device coordinates. This scales the event to the
 // window's coordinate space.
 void ScaleTouchEvent(TouchEvent* event, const gfx::SizeF& size) {
   for (const auto& device :
        DeviceDataManager::GetInstance()->touchscreen_devices()) {
@@ skipping 161 matching lines @@
   bool OnSwapBuffers() override { return true; }
 
   void OnSwapBuffersAsync(const SwapCompletionCallback& callback) override {
     callback.Run(gfx::SwapResult::SWAP_ACK);
   }
 
   bool ResizeNativeWindow(const gfx::Size& viewport_size) override {
     return true;
   }
 
-  scoped_ptr<gfx::VSyncProvider> CreateVSyncProvider() override {
+  std::unique_ptr<gfx::VSyncProvider> CreateVSyncProvider() override {
     return nullptr;
   }
 
   void* /* EGLConfig */ GetEGLSurfaceConfig(
       const EglConfigCallbacks& egl) override {
     EGLint broken_props[] = {
         EGL_RENDERABLE_TYPE,
         EGL_OPENGL_ES2_BIT,
         EGL_SURFACE_TYPE,
         EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
@@ skipping 15 matching lines @@
 class SurfaceFactoryEgltest : public ui::SurfaceFactoryOzone {
  public:
   SurfaceFactoryEgltest(LibeglplatformShimLoader* eglplatform_shim)
       : eglplatform_shim_(eglplatform_shim) {}
   ~SurfaceFactoryEgltest() override {
     DCHECK(thread_checker_.CalledOnValidThread());
   }
 
   // SurfaceFactoryOzone:
   intptr_t GetNativeDisplay() override;
-  scoped_ptr<SurfaceOzoneEGL> CreateEGLSurfaceForWidget(
+  std::unique_ptr<SurfaceOzoneEGL> CreateEGLSurfaceForWidget(
       gfx::AcceleratedWidget widget) override;
   bool LoadEGLGLES2Bindings(
       AddGLLibraryCallback add_gl_library,
       SetGLGetProcAddressProcCallback set_gl_get_proc_address) override;
 
  private:
   LibeglplatformShimLoader* eglplatform_shim_;
   base::ThreadChecker thread_checker_;
 };
 
 intptr_t SurfaceFactoryEgltest::GetNativeDisplay() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return eglplatform_shim_->ShimGetNativeDisplay();
 }
 
-scoped_ptr<SurfaceOzoneEGL> SurfaceFactoryEgltest::CreateEGLSurfaceForWidget(
+std::unique_ptr<SurfaceOzoneEGL>
+SurfaceFactoryEgltest::CreateEGLSurfaceForWidget(
     gfx::AcceleratedWidget widget) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return make_scoped_ptr<SurfaceOzoneEGL>(
+  return base::WrapUnique<SurfaceOzoneEGL>(
       new SurfaceOzoneEgltest(widget, eglplatform_shim_));
 }
 
 bool SurfaceFactoryEgltest::LoadEGLGLES2Bindings(
     AddGLLibraryCallback add_gl_library,
     SetGLGetProcAddressProcCallback set_gl_get_proc_address) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const char* egl_soname = eglplatform_shim_->ShimQueryString(SHIM_EGL_LIBRARY);
   const char* gles_soname =
       eglplatform_shim_->ShimQueryString(SHIM_GLES_LIBRARY);
@@ skipping 54 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 nullptr;  // no input injection support.
   }
-  scoped_ptr<PlatformWindow> CreatePlatformWindow(
+  std::unique_ptr<PlatformWindow> CreatePlatformWindow(
       PlatformWindowDelegate* delegate,
       const gfx::Rect& bounds) override {
-    return make_scoped_ptr<PlatformWindow>(new EgltestWindow(
+    return base::WrapUnique<PlatformWindow>(new EgltestWindow(
         delegate, &eglplatform_shim_, event_factory_ozone_.get(), bounds));
   }
-  scoped_ptr<NativeDisplayDelegate> CreateNativeDisplayDelegate() override {
-    return make_scoped_ptr(new NativeDisplayDelegateOzone());
+  std::unique_ptr<NativeDisplayDelegate> CreateNativeDisplayDelegate()
+      override {
+    return base::WrapUnique(new NativeDisplayDelegateOzone());
   }
 
   void InitializeUI() override {
     device_manager_ = CreateDeviceManager();
     overlay_manager_.reset(new StubOverlayManager());
     KeyboardLayoutEngineManager::SetKeyboardLayoutEngine(
-        make_scoped_ptr(new StubKeyboardLayoutEngine()));
+        base::WrapUnique(new StubKeyboardLayoutEngine()));
     event_factory_ozone_.reset(new EventFactoryEvdev(
         NULL, device_manager_.get(),
         KeyboardLayoutEngineManager::GetKeyboardLayoutEngine()));
     cursor_factory_ozone_.reset(new CursorFactoryOzone());
     gpu_platform_support_host_.reset(CreateStubGpuPlatformSupportHost());
   }
 
   void InitializeGPU() override {
     surface_factory_ozone_.reset(new SurfaceFactoryEgltest(&eglplatform_shim_));
     gpu_platform_support_.reset(CreateStubGpuPlatformSupport());
   }
 
  private:
   LibeglplatformShimLoader eglplatform_shim_;
-  scoped_ptr<DeviceManager> device_manager_;
-  scoped_ptr<SurfaceFactoryEgltest> surface_factory_ozone_;
-  scoped_ptr<EventFactoryEvdev> event_factory_ozone_;
-  scoped_ptr<CursorFactoryOzone> cursor_factory_ozone_;
-  scoped_ptr<GpuPlatformSupport> gpu_platform_support_;
-  scoped_ptr<GpuPlatformSupportHost> gpu_platform_support_host_;
-  scoped_ptr<OverlayManagerOzone> overlay_manager_;
+  std::unique_ptr<DeviceManager> device_manager_;
+  std::unique_ptr<SurfaceFactoryEgltest> surface_factory_ozone_;
+  std::unique_ptr<EventFactoryEvdev> event_factory_ozone_;
+  std::unique_ptr<CursorFactoryOzone> cursor_factory_ozone_;
+  std::unique_ptr<GpuPlatformSupport> gpu_platform_support_;
+  std::unique_ptr<GpuPlatformSupportHost> gpu_platform_support_host_;
+  std::unique_ptr<OverlayManagerOzone> overlay_manager_;
 
   bool shim_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(OzonePlatformEgltest);
 };
 
 }  // namespace
 
 OzonePlatform* CreateOzonePlatformEgltest() {
   OzonePlatformEgltest* platform = new OzonePlatformEgltest;
   platform->Initialize();
   return platform;
 }
 
 }  // namespace ui