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

content/browser/compositor/buffer_queue_unittest.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 <stddef.h>
 #include <stdint.h>
+
 #include <set>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "content/browser/compositor/gl_helper.h"
 #include "content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 
@@ skipping 28 matching lines @@
   }
 };
 
 class StubBrowserGpuMemoryBufferManager : public BrowserGpuMemoryBufferManager {
  public:
   StubBrowserGpuMemoryBufferManager()
       : BrowserGpuMemoryBufferManager(1, 1), allocate_succeeds_(true) {}
 
   void set_allocate_succeeds(bool value) { allocate_succeeds_ = value; }
 
-  scoped_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBuffer(
+  std::unique_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBuffer(
       const gfx::Size& size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
       int32_t surface_id) override {
     if (!surface_id) {
       return BrowserGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
           size, format, usage, surface_id);
     }
     if (allocate_succeeds_)
-      return make_scoped_ptr<gfx::GpuMemoryBuffer>(new StubGpuMemoryBufferImpl);
+      return base::WrapUnique<gfx::GpuMemoryBuffer>(
+          new StubGpuMemoryBufferImpl);
     return nullptr;
   }
 
  private:
   bool allocate_succeeds_;
 };
 
 class MockBufferQueue : public BufferQueue {
  public:
   MockBufferQueue(scoped_refptr<cc::ContextProvider> context_provider,
@@ skipping 11 matching lines @@
 };
 
 class BufferQueueTest : public ::testing::Test {
  public:
   BufferQueueTest() : doublebuffering_(true), first_frame_(true) {}
 
   void SetUp() override {
     InitWithContext(cc::TestWebGraphicsContext3D::Create());
   }
 
-  void InitWithContext(scoped_ptr<cc::TestWebGraphicsContext3D> context) {
+  void InitWithContext(std::unique_ptr<cc::TestWebGraphicsContext3D> context) {
     scoped_refptr<cc::TestContextProvider> context_provider =
         cc::TestContextProvider::Create(std::move(context));
     context_provider->BindToCurrentThread();
     gpu_memory_buffer_manager_.reset(new StubBrowserGpuMemoryBufferManager);
     mock_output_surface_ =
         new MockBufferQueue(context_provider, gpu_memory_buffer_manager_.get(),
                             GL_TEXTURE_2D, GL_RGBA);
     output_surface_.reset(mock_output_surface_);
     output_surface_->Initialize();
   }
 
   unsigned current_surface() {
     return output_surface_->current_surface_
                ? output_surface_->current_surface_->image
                : 0;
   }
-  const std::vector<scoped_ptr<BufferQueue::AllocatedSurface>>&
+  const std::vector<std::unique_ptr<BufferQueue::AllocatedSurface>>&
   available_surfaces() {
     return output_surface_->available_surfaces_;
   }
-  std::deque<scoped_ptr<BufferQueue::AllocatedSurface>>& in_flight_surfaces() {
+  std::deque<std::unique_ptr<BufferQueue::AllocatedSurface>>&
+  in_flight_surfaces() {
     return output_surface_->in_flight_surfaces_;
   }
 
   const BufferQueue::AllocatedSurface* displayed_frame() {
     return output_surface_->displayed_surface_.get();
   }
   const BufferQueue::AllocatedSurface* current_frame() {
     return output_surface_->current_surface_.get();
   }
   const BufferQueue::AllocatedSurface* next_frame() {
@@ skipping 42 matching lines @@
  protected:
   bool InsertUnique(std::set<unsigned>* set, unsigned value) {
     if (!value)
       return true;
     if (set->find(value) != set->end())
       return false;
     set->insert(value);
     return true;
   }
 
-  scoped_ptr<StubBrowserGpuMemoryBufferManager> gpu_memory_buffer_manager_;
-  scoped_ptr<BufferQueue> output_surface_;
+  std::unique_ptr<StubBrowserGpuMemoryBufferManager> gpu_memory_buffer_manager_;
+  std::unique_ptr<BufferQueue> output_surface_;
   MockBufferQueue* mock_output_surface_;
   bool doublebuffering_;
   bool first_frame_;
 };
 
 namespace {
 const gfx::Size screen_size = gfx::Size(30, 30);
 const gfx::Rect screen_rect = gfx::Rect(screen_size);
 const gfx::Rect small_damage = gfx::Rect(gfx::Size(10, 10));
 const gfx::Rect large_damage = gfx::Rect(gfx::Size(20, 20));
@@ skipping 17 matching lines @@
                GLuint(ClientBuffer, GLsizei, GLsizei, GLenum));
   MOCK_METHOD1(destroyImageCHROMIUM, void(GLuint));
   MOCK_METHOD5(framebufferTexture2D,
                void(GLenum, GLenum, GLenum, GLuint, GLint));
 };
 
 class BufferQueueMockedContextTest : public BufferQueueTest {
  public:
   void SetUp() override {
     context_ = new MockedContext();
-    InitWithContext(scoped_ptr<cc::TestWebGraphicsContext3D>(context_));
+    InitWithContext(std::unique_ptr<cc::TestWebGraphicsContext3D>(context_));
   }
 
  protected:
   MockedContext* context_;
 };
 
-scoped_ptr<BufferQueue> CreateOutputSurfaceWithMock(
+std::unique_ptr<BufferQueue> CreateOutputSurfaceWithMock(
     unsigned int target,
     MockedContext** context,
     BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager) {
   *context = new MockedContext();
   scoped_refptr<cc::TestContextProvider> context_provider =
       cc::TestContextProvider::Create(
-          scoped_ptr<cc::TestWebGraphicsContext3D>(*context));
+          std::unique_ptr<cc::TestWebGraphicsContext3D>(*context));
   context_provider->BindToCurrentThread();
-  scoped_ptr<BufferQueue> buffer_queue(
+  std::unique_ptr<BufferQueue> buffer_queue(
       new BufferQueue(context_provider, target, GL_RGBA, nullptr,
                       gpu_memory_buffer_manager, 1));
   buffer_queue->Initialize();
   return buffer_queue;
 }
 
 TEST(BufferQueueStandaloneTest, FboInitialization) {
   MockedContext* context;
-  scoped_ptr<BrowserGpuMemoryBufferManager> gpu_memory_buffer_manager(
+  std::unique_ptr<BrowserGpuMemoryBufferManager> gpu_memory_buffer_manager(
       new StubBrowserGpuMemoryBufferManager);
-  scoped_ptr<BufferQueue> output_surface = CreateOutputSurfaceWithMock(
+  std::unique_ptr<BufferQueue> output_surface = CreateOutputSurfaceWithMock(
       GL_TEXTURE_2D, &context, gpu_memory_buffer_manager.get());
 
   EXPECT_CALL(*context, bindFramebuffer(GL_FRAMEBUFFER, Ne(0U)));
   ON_CALL(*context, framebufferTexture2D(_, _, _, _, _))
       .WillByDefault(Return());
 
   output_surface->Reshape(gfx::Size(10, 20), 1.0f);
 }
 
 TEST(BufferQueueStandaloneTest, FboBinding) {
   GLenum targets[] = { GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_ARB };
   for (size_t i = 0; i < 2; ++i) {
     GLenum target = targets[i];
     MockedContext* context;
-    scoped_ptr<BrowserGpuMemoryBufferManager> gpu_memory_buffer_manager(
+    std::unique_ptr<BrowserGpuMemoryBufferManager> gpu_memory_buffer_manager(
         new StubBrowserGpuMemoryBufferManager);
-    scoped_ptr<BufferQueue> output_surface = CreateOutputSurfaceWithMock(
+    std::unique_ptr<BufferQueue> output_surface = CreateOutputSurfaceWithMock(
         target, &context, gpu_memory_buffer_manager.get());
     EXPECT_CALL(*context, bindTexture(target, Ne(0U)));
     EXPECT_CALL(*context, destroyImageCHROMIUM(1));
     Expectation image =
         EXPECT_CALL(*context, createImageCHROMIUM(_, 0, 0, GL_RGBA))
             .WillOnce(Return(1));
     Expectation fb =
         EXPECT_CALL(*context, bindFramebuffer(GL_FRAMEBUFFER, Ne(0U)));
     Expectation tex = EXPECT_CALL(*context, bindTexture(target, Ne(0U)));
     Expectation bind_tex =
         EXPECT_CALL(*context, bindTexImage2DCHROMIUM(target, 1))
             .After(tex, image);
     EXPECT_CALL(
         *context,
         framebufferTexture2D(
             GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, Ne(0U), _))
         .After(fb, bind_tex);
 
     output_surface->BindFramebuffer();
   }
 }
 
 TEST(BufferQueueStandaloneTest, CheckBoundFramebuffer) {
-  scoped_ptr<BrowserGpuMemoryBufferManager> gpu_memory_buffer_manager;
-  scoped_ptr<BufferQueue> output_surface;
+  std::unique_ptr<BrowserGpuMemoryBufferManager> gpu_memory_buffer_manager;
+  std::unique_ptr<BufferQueue> output_surface;
   scoped_refptr<cc::TestContextProvider> context_provider =
       cc::TestContextProvider::Create(cc::TestWebGraphicsContext3D::Create());
   context_provider->BindToCurrentThread();
   gpu_memory_buffer_manager.reset(new StubBrowserGpuMemoryBufferManager);
 
-  scoped_ptr<GLHelper> gl_helper;
+  std::unique_ptr<GLHelper> gl_helper;
   gl_helper.reset(new GLHelper(context_provider->ContextGL(),
                                context_provider->ContextSupport()));
 
   output_surface.reset(new BufferQueue(context_provider, GL_TEXTURE_2D, GL_RGBA,
                                        gl_helper.get(),
                                        gpu_memory_buffer_manager.get(), 1));
   output_surface->Initialize();
   output_surface->Reshape(screen_size, 1.0f);
   // Trigger a sub-buffer copy to exercise all paths.
   output_surface->BindFramebuffer();
@@ skipping 308 matching lines @@
   testing::Mock::VerifyAndClearExpectations(mock_output_surface_);
   EXPECT_CALL(*mock_output_surface_,
               CopyBufferDamage(target_texture, source_texture, small_damage, _))
       .Times(1);
   output_surface_->SwapBuffers(small_damage);
   testing::Mock::VerifyAndClearExpectations(mock_output_surface_);
 }
 
 }  // namespace
 }  // namespace content