Replace scoped_ptr with std::unique_ptr in //ui

ui/gl/gl_surface_ozone.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/gl/gl_surface.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 54 matching lines @@
 }
 
 void WaitForFence(EGLDisplay display, EGLSyncKHR fence) {
   eglClientWaitSyncKHR(display, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
                        EGL_FOREVER_KHR);
 }
 
 // A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow.
 class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL {
  public:
-  GLSurfaceOzoneEGL(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
+  GLSurfaceOzoneEGL(std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                     AcceleratedWidget widget);
 
   // GLSurface:
   bool Initialize(gfx::GLSurface::Format format) override;
   bool Resize(const gfx::Size& size,
               float scale_factor,
               bool has_alpha) override;
   gfx::SwapResult SwapBuffers() override;
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
                             GLImage* image,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override;
   EGLConfig GetConfig() override;
 
  private:
   using NativeViewGLSurfaceEGL::Initialize;
 
   ~GLSurfaceOzoneEGL() override;
 
   bool ReinitializeNativeSurface();
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
-  scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
+  std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
   AcceleratedWidget widget_;
 
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneEGL);
 };
 
 GLSurfaceOzoneEGL::GLSurfaceOzoneEGL(
-    scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
+    std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
     AcceleratedWidget widget)
     : NativeViewGLSurfaceEGL(ozone_surface->GetNativeWindow()),
       ozone_surface_(std::move(ozone_surface)),
       widget_(widget) {}
 
 bool GLSurfaceOzoneEGL::Initialize(gfx::GLSurface::Format format) {
   format_ = format;
   return Initialize(ozone_surface_->CreateVSyncProvider());
 }
 
@@ skipping 35 matching lines @@
   if (config_)
     return config_;
   return NativeViewGLSurfaceEGL::GetConfig();
 }
 
 GLSurfaceOzoneEGL::~GLSurfaceOzoneEGL() {
   Destroy();  // The EGL surface must be destroyed before SurfaceOzone.
 }
 
 bool GLSurfaceOzoneEGL::ReinitializeNativeSurface() {
-  scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current;
+  std::unique_ptr<ui::ScopedMakeCurrent> scoped_make_current;
   GLContext* current_context = GLContext::GetCurrent();
   bool was_current = current_context && current_context->IsCurrent(this);
   if (was_current) {
     scoped_make_current.reset(new ui::ScopedMakeCurrent(current_context, this));
   }
 
   Destroy();
   ozone_surface_ = ui::OzonePlatform::GetInstance()
                        ->GetSurfaceFactoryOzone()
                        ->CreateEGLSurfaceForWidget(widget_);
   if (!ozone_surface_) {
     LOG(ERROR) << "Failed to create native surface.";
     return false;
   }
 
   window_ = ozone_surface_->GetNativeWindow();
   if (!Initialize(format_)) {
     LOG(ERROR) << "Failed to initialize.";
     return false;
   }
 
   return true;
 }
 
 class GL_EXPORT GLSurfaceOzoneSurfaceless : public SurfacelessEGL {
  public:
-  GLSurfaceOzoneSurfaceless(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
+  GLSurfaceOzoneSurfaceless(std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                             AcceleratedWidget widget);
 
   // GLSurface:
   bool Initialize(gfx::GLSurface::Format format) override;
   bool Resize(const gfx::Size& size,
               float scale_factor,
               bool has_alpha) override;
   gfx::SwapResult SwapBuffers() override;
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
@@ skipping 28 matching lines @@
 
   void SubmitFrame();
 
   EGLSyncKHR InsertFence();
   void FenceRetired(EGLSyncKHR fence, PendingFrame* frame);
 
   void SwapCompleted(const SwapCompletionCallback& callback,
                      gfx::SwapResult result);
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
-  scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
+  std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
   AcceleratedWidget widget_;
-  scoped_ptr<VSyncProvider> vsync_provider_;
+  std::unique_ptr<VSyncProvider> vsync_provider_;
   ScopedVector<PendingFrame> unsubmitted_frames_;
   bool has_implicit_external_sync_;
   bool last_swap_buffers_result_;
   bool swap_buffers_pending_;
 
   base::WeakPtrFactory<GLSurfaceOzoneSurfaceless> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless);
 };
 
 GLSurfaceOzoneSurfaceless::PendingFrame::PendingFrame() : ready(false) {}
 
 bool GLSurfaceOzoneSurfaceless::PendingFrame::ScheduleOverlayPlanes(
     gfx::AcceleratedWidget widget) {
   for (const auto& overlay : overlays)
     if (!overlay.ScheduleOverlayPlane(widget))
       return false;
   return true;
 }
 
 GLSurfaceOzoneSurfaceless::GLSurfaceOzoneSurfaceless(
-    scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
+    std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
     AcceleratedWidget widget)
     : SurfacelessEGL(gfx::Size()),
       ozone_surface_(std::move(ozone_surface)),
       widget_(widget),
       has_implicit_external_sync_(
           HasEGLExtension("EGL_ARM_implicit_external_sync")),
       last_swap_buffers_result_(true),
       swap_buffers_pending_(false),
       weak_factory_(this) {
   unsubmitted_frames_.push_back(new PendingFrame());
@@ skipping 140 matching lines @@
 }
 
 GLSurfaceOzoneSurfaceless::~GLSurfaceOzoneSurfaceless() {
   Destroy();  // The EGL surface must be destroyed before SurfaceOzone.
 }
 
 void GLSurfaceOzoneSurfaceless::SubmitFrame() {
   DCHECK(!unsubmitted_frames_.empty());
 
   if (unsubmitted_frames_.front()->ready && !swap_buffers_pending_) {
-    scoped_ptr<PendingFrame> frame(unsubmitted_frames_.front());
+    std::unique_ptr<PendingFrame> frame(unsubmitted_frames_.front());
     unsubmitted_frames_.weak_erase(unsubmitted_frames_.begin());
     swap_buffers_pending_ = true;
 
     if (!frame->ScheduleOverlayPlanes(widget_)) {
       // |callback| is a wrapper for SwapCompleted(). Call it to properly
       // propagate the failed state.
       frame->callback.Run(gfx::SwapResult::SWAP_FAILED);
       return;
     }
 
@@ skipping 30 matching lines @@
 
   SubmitFrame();
 }
 
 // This provides surface-like semantics implemented through surfaceless.
 // A framebuffer is bound automatically.
 class GL_EXPORT GLSurfaceOzoneSurfacelessSurfaceImpl
     : public GLSurfaceOzoneSurfaceless {
  public:
   GLSurfaceOzoneSurfacelessSurfaceImpl(
-      scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
+      std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
       AcceleratedWidget widget);
 
   // GLSurface:
   unsigned int GetBackingFrameBufferObject() override;
   bool OnMakeCurrent(GLContext* context) override;
   bool Resize(const gfx::Size& size,
               float scale_factor,
               bool has_alpha) override;
   bool SupportsPostSubBuffer() override;
   gfx::SwapResult SwapBuffers() override;
   void SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   void Destroy() override;
   bool IsSurfaceless() const override;
 
  private:
   ~GLSurfaceOzoneSurfacelessSurfaceImpl() override;
 
   void BindFramebuffer();
   bool CreatePixmaps();
 
   scoped_refptr<GLContext> context_;
   GLuint fbo_;
   GLuint textures_[2];
   scoped_refptr<GLImage> images_[2];
   int current_surface_;
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfacelessSurfaceImpl);
 };
 
 GLSurfaceOzoneSurfacelessSurfaceImpl::GLSurfaceOzoneSurfacelessSurfaceImpl(
-    scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
+    std::unique_ptr<ui::SurfaceOzoneEGL> ozone_surface,
     AcceleratedWidget widget)
     : GLSurfaceOzoneSurfaceless(std::move(ozone_surface), widget),
       context_(nullptr),
       fbo_(0),
       current_surface_(0) {
   for (auto& texture : textures_)
     texture = 0;
 }
 
 unsigned int
@@ skipping 130 matching lines @@
     // Bind image to texture.
     ScopedTextureBinder binder(GL_TEXTURE_2D, textures_[i]);
     if (!images_[i]->BindTexImage(GL_TEXTURE_2D))
       return false;
   }
   return true;
 }
 
 scoped_refptr<GLSurface> CreateViewGLSurfaceOzone(
     gfx::AcceleratedWidget window) {
-  scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
+  std::unique_ptr<ui::SurfaceOzoneEGL> surface_ozone =
       ui::OzonePlatform::GetInstance()
           ->GetSurfaceFactoryOzone()
           ->CreateEGLSurfaceForWidget(window);
   if (!surface_ozone)
     return nullptr;
   scoped_refptr<GLSurface> surface =
       new GLSurfaceOzoneEGL(std::move(surface_ozone), window);
   if (!surface->Initialize())
     return nullptr;
   return surface;
 }
 
 scoped_refptr<GLSurface> CreateViewGLSurfaceOzoneSurfacelessSurfaceImpl(
     gfx::AcceleratedWidget window) {
-  scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
+  std::unique_ptr<ui::SurfaceOzoneEGL> surface_ozone =
       ui::OzonePlatform::GetInstance()
           ->GetSurfaceFactoryOzone()
           ->CreateSurfacelessEGLSurfaceForWidget(window);
   if (!surface_ozone)
     return nullptr;
   scoped_refptr<GLSurface> surface = new GLSurfaceOzoneSurfacelessSurfaceImpl(
       std::move(surface_ozone), window);
   if (!surface->Initialize())
     return nullptr;
   return surface;
@@ skipping 18 matching lines @@
       return false;
   }
 }
 
 // static
 scoped_refptr<GLSurface> GLSurface::CreateSurfacelessViewGLSurface(
     gfx::AcceleratedWidget window) {
   if (GetGLImplementation() == kGLImplementationEGLGLES2 &&
       window != kNullAcceleratedWidget &&
       GLSurfaceEGL::IsEGLSurfacelessContextSupported()) {
-    scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
+    std::unique_ptr<ui::SurfaceOzoneEGL> surface_ozone =
         ui::OzonePlatform::GetInstance()
             ->GetSurfaceFactoryOzone()
             ->CreateSurfacelessEGLSurfaceForWidget(window);
     if (!surface_ozone)
       return nullptr;
     scoped_refptr<GLSurface> surface;
     surface = new GLSurfaceOzoneSurfaceless(std::move(surface_ozone), window);
     if (surface->Initialize())
       return surface;
   }
@@ skipping 59 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gfx