Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/compositor/buffer_queue.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 "content/browser/compositor/buffer_queue.h"
 
 #include "base/containers/adapters.h"
+#include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "content/browser/compositor/gl_helper.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "third_party/skia/include/core/SkRect.h"
@@ skipping 131 matching lines @@
 
   if (current_surface_) {
     // If we have a texture bound, we will need to re-bind it.
     gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
     gl->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
     gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                              texture_target_, current_surface_->texture, 0);
   }
 }
 
-scoped_ptr<BufferQueue::AllocatedSurface> BufferQueue::RecreateBuffer(
-    scoped_ptr<AllocatedSurface> surface) {
+std::unique_ptr<BufferQueue::AllocatedSurface> BufferQueue::RecreateBuffer(
+    std::unique_ptr<AllocatedSurface> surface) {
   if (!surface)
     return nullptr;
 
-  scoped_ptr<AllocatedSurface> new_surface(GetNextSurface());
+  std::unique_ptr<AllocatedSurface> new_surface(GetNextSurface());
   if (!new_surface)
     return nullptr;
 
   new_surface->damage = surface->damage;
 
   // Copy the entire texture.
   CopyBufferDamage(new_surface->texture, surface->texture, gfx::Rect(),
                    gfx::Rect(size_));
   return new_surface;
 }
@@ skipping 22 matching lines @@
 
   gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
   gl->BindTexture(texture_target_, surface->texture);
   gl->ReleaseTexImage2DCHROMIUM(texture_target_, surface->image);
   gl->DeleteTextures(1, &surface->texture);
   gl->DestroyImageCHROMIUM(surface->image);
   surface->buffer.reset();
   allocated_count_--;
 }
 
-scoped_ptr<BufferQueue::AllocatedSurface> BufferQueue::GetNextSurface() {
+std::unique_ptr<BufferQueue::AllocatedSurface> BufferQueue::GetNextSurface() {
   if (!available_surfaces_.empty()) {
-    scoped_ptr<AllocatedSurface> surface =
+    std::unique_ptr<AllocatedSurface> surface =
         std::move(available_surfaces_.back());
     available_surfaces_.pop_back();
     return surface;
   }
 
   unsigned int texture = 0;
   gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
   gl->GenTextures(1, &texture);
   if (!texture)
     return nullptr;
 
   // We don't want to allow anything more than triple buffering.
   DCHECK_LT(allocated_count_, 4U);
 
-  scoped_ptr<gfx::GpuMemoryBuffer> buffer(
+  std::unique_ptr<gfx::GpuMemoryBuffer> buffer(
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
           size_, gpu::DefaultBufferFormatForImageFormat(internal_format_),
           gfx::BufferUsage::SCANOUT, surface_id_));
   if (!buffer.get()) {
     gl->DeleteTextures(1, &texture);
     DLOG(ERROR) << "Failed to allocate GPU memory buffer";
     return nullptr;
   }
 
   unsigned int id = gl->CreateImageCHROMIUM(
       buffer->AsClientBuffer(), size_.width(), size_.height(),
       internal_format_);
   if (!id) {
     LOG(ERROR) << "Failed to allocate backing image surface";
     gl->DeleteTextures(1, &texture);
     return nullptr;
   }
 
   allocated_count_++;
   gl->BindTexture(texture_target_, texture);
   gl->BindTexImage2DCHROMIUM(texture_target_, id);
-  return make_scoped_ptr(new AllocatedSurface(this, std::move(buffer), texture,
-                                              id, gfx::Rect(size_)));
+  return base::WrapUnique(new AllocatedSurface(this, std::move(buffer), texture,
+                                               id, gfx::Rect(size_)));
 }
 
 BufferQueue::AllocatedSurface::AllocatedSurface(
     BufferQueue* buffer_queue,
-    scoped_ptr<gfx::GpuMemoryBuffer> buffer,
+    std::unique_ptr<gfx::GpuMemoryBuffer> buffer,
     unsigned int texture,
     unsigned int image,
     const gfx::Rect& rect)
     : buffer_queue(buffer_queue),
       buffer(buffer.release()),
       texture(texture),
       image(image),
       damage(rect) {}
 
 BufferQueue::AllocatedSurface::~AllocatedSurface() {
   buffer_queue->FreeSurfaceResources(this);
 }
 
 }  // namespace content