convert //gpu to std::unique_ptr

gpu/command_buffer/client/gles2_implementation_unittest.cc

 // Copyright (c) 2012 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.
 
 // Tests for GLES2Implementation.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <GLES3/gl3.h>
+
 #include <stddef.h>
 #include <stdint.h>
+
+#include <memory>
+
 #include "base/compiler_specific.h"
 #include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/program_info_manager.h"
 #include "gpu/command_buffer/client/query_tracker.h"
 #include "gpu/command_buffer/client/ring_buffer.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 503 matching lines @@
       return command_buffer_.get();
     }
 
     int GetNextToken() { return ++token_; }
 
     void ClearCommands() {
       scoped_refptr<Buffer> ring_buffer = helper_->get_ring_buffer();
       memset(ring_buffer->memory(), kInitialValue, ring_buffer->size());
     }
 
-    scoped_ptr<MockClientCommandBuffer> command_buffer_;
-    scoped_ptr<MockClientGpuControl> gpu_control_;
-    scoped_ptr<GLES2CmdHelper> helper_;
-    scoped_ptr<MockTransferBuffer> transfer_buffer_;
-    scoped_ptr<GLES2Implementation> gl_;
+    std::unique_ptr<MockClientCommandBuffer> command_buffer_;
+    std::unique_ptr<MockClientGpuControl> gpu_control_;
+    std::unique_ptr<GLES2CmdHelper> helper_;
+    std::unique_ptr<MockTransferBuffer> transfer_buffer_;
+    std::unique_ptr<GLES2Implementation> gl_;
     CommandBufferEntry* commands_;
     int token_;
   };
 
   GLES2ImplementationTest() : commands_(NULL) {}
 
   void SetUp() override;
   void TearDown() override;
 
   bool NoCommandsWritten() {
@@ skipping 303 matching lines @@
 #endif
 
 TEST_F(GLES2ImplementationTest, Basic) {
   EXPECT_TRUE(gl_->share_group() != NULL);
 }
 
 TEST_F(GLES2ImplementationTest, GetBucketContents) {
   const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const uint32_t kTestSize = MaxTransferBufferSize() + 32;
 
-  scoped_ptr<uint8_t[]> buf(new uint8_t[kTestSize]);
+  std::unique_ptr<uint8_t[]> buf(new uint8_t[kTestSize]);
   uint8_t* expected_data = buf.get();
   for (uint32_t ii = 0; ii < kTestSize; ++ii) {
     expected_data[ii] = ii * 3;
   }
 
   struct Cmds {
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::GetBucketData get_bucket_data;
     cmd::SetToken set_token2;
@@ skipping 846 matching lines @@
   Cmds expected;
   expected.read1.Init(
       0, 0, kWidth, kHeight / 2, kFormat, kType,
       mem1.id, mem1.offset, result1.id, result1.offset,
       false);
   expected.set_token1.Init(GetNextToken());
   expected.read2.Init(
       0, kHeight / 2, kWidth, kHeight / 2, kFormat, kType,
       mem2.id, mem2.offset, result2.id, result2.offset, false);
   expected.set_token2.Init(GetNextToken());
-  scoped_ptr<int8_t[]> buffer(new int8_t[kWidth * kHeight * kBytesPerPixel]);
+  std::unique_ptr<int8_t[]> buffer(
+      new int8_t[kWidth * kHeight * kBytesPerPixel]);
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, static_cast<uint32_t>(1)))
       .WillOnce(SetMemory(result2.ptr, static_cast<uint32_t>(1)))
       .RetiresOnSaturation();
 
   gl_->ReadPixels(0, 0, kWidth, kHeight, kFormat, kType, buffer.get());
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
@@ skipping 11 matching lines @@
   ExpectedMemoryInfo mem1 =
       GetExpectedMemory(kWidth * kHeight * kBytesPerPixel);
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmds::ReadPixels::Result));
 
   Cmds expected;
   expected.read.Init(
       0, 0, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset, result1.id, result1.offset, false);
   expected.set_token.Init(GetNextToken());
-  scoped_ptr<int8_t[]> buffer(new int8_t[kWidth * kHeight * kBytesPerPixel]);
+  std::unique_ptr<int8_t[]> buffer(
+      new int8_t[kWidth * kHeight * kBytesPerPixel]);
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .Times(1)
       .RetiresOnSaturation();
 
   gl_->ReadPixels(0, 0, kWidth, kHeight, kFormat, kType, buffer.get());
 }
 
 TEST_F(GLES2ImplementationTest, FreeUnusedSharedMemory) {
   struct Cmds {
@@ skipping 649 matching lines @@
   uint32_t padded_row_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
   const GLsizei kMaxHeight = (MaxTransferBufferSize() / padded_row_size) * 2;
   const GLsizei kHeight = kMaxHeight * 2;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
 
-  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  std::unique_ptr<uint8_t[]> pixels(new uint8_t[size]);
   for (uint32_t ii = 0; ii < size; ++ii) {
     pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   ExpectedMemoryInfo mem1 = GetExpectedMappedMemory(size);
 
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset);
@@ skipping 35 matching lines @@
       &size, &unpadded_row_size, &padded_row_size));
   const GLsizei kHeight = (MaxTransferBufferSize() / padded_row_size) * 2;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
   uint32_t half_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight / 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &half_size, NULL, NULL));
 
-  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  std::unique_ptr<uint8_t[]> pixels(new uint8_t[size]);
   for (uint32_t ii = 0; ii < size; ++ii) {
     pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(half_size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(half_size);
 
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
@@ skipping 60 matching lines @@
     cmds::TexSubImage2D tex_sub_image_2d;
   } texSubImageExpected;
 
   uint32_t pixel_size;
   PixelStoreParams pixel_params;
   // Makes sure the pixels size is large enough for all tests.
   pixel_params.alignment = 8;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizesES3(
       kSrcWidth, kSrcSubImageY1, 1, kFormat, kType,
       pixel_params, &pixel_size, nullptr, nullptr, nullptr, nullptr));
-  scoped_ptr<uint8_t[]> src_pixels;
+  std::unique_ptr<uint8_t[]> src_pixels;
   src_pixels.reset(new uint8_t[pixel_size]);
   for (size_t i = 0; i < pixel_size; ++i) {
     src_pixels[i] = static_cast<uint8_t>(i % 255);
   }
 
   for (int sub = 0; sub < 2; ++sub) {
     for (size_t a = 0; a < arraysize(unpack_alignments); ++a) {
       const void* commands = GetPut();
 
       GLint alignment = unpack_alignments[a];
@@ skipping 120 matching lines @@
     cmds::TexSubImage3D tex_sub_image_3d;
   } texSubImageExpected;
 
   uint32_t pixel_size;
   PixelStoreParams pixel_params;
   // Makes sure the pixels size is large enough for all tests.
   pixel_params.alignment = 8;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizesES3(
       kSrcWidth, kSrcSubImageY1, kSrcSubImageZ1, kFormat, kType,
       pixel_params, &pixel_size, nullptr, nullptr, nullptr, nullptr));
-  scoped_ptr<uint8_t[]> src_pixels;
+  std::unique_ptr<uint8_t[]> src_pixels;
   src_pixels.reset(new uint8_t[pixel_size]);
   for (size_t i = 0; i < pixel_size; ++i) {
     src_pixels[i] = static_cast<uint8_t>(i % 255);
   }
 
   for (int sub = 0; sub < 2; ++sub) {
     for (size_t a = 0; a < arraysize(unpack_alignments); ++a) {
       const void* commands = GetPut();
 
       GLint alignment = unpack_alignments[a];
@@ skipping 194 matching lines @@
   uint32_t padded_row_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, 2, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
   // Makes sure we can just send over the data in one command.
   const GLsizei kHeight = MaxTransferBufferSize() / padded_row_size / kDepth;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
 
-  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  std::unique_ptr<uint8_t[]> pixels(new uint8_t[size]);
   for (uint32_t ii = 0; ii < size; ++ii) {
     pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   ExpectedMemoryInfo mem = GetExpectedMemory(size);
 
   Cmds expected;
   expected.tex_image_3d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kDepth,
       kFormat, kType, mem.id, mem.offset);
@@ skipping 32 matching lines @@
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, 2, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
   // Makes sure we can just send over the data in one command.
   const GLsizei kMaxHeight = MaxTransferBufferSize() / padded_row_size / kDepth;
   const GLsizei kHeight = kMaxHeight * 2;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
 
-  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  std::unique_ptr<uint8_t[]> pixels(new uint8_t[size]);
   for (uint32_t ii = 0; ii < size; ++ii) {
     pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   ExpectedMemoryInfo mem = GetExpectedMappedMemory(size);
 
   Cmds expected;
   expected.tex_image_3d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kDepth,
       kFormat, kType, mem.id, mem.offset);
@@ skipping 36 matching lines @@
   const GLsizei kHeight = MaxTransferBufferSize() / padded_row_size + 3;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
   uint32_t first_size = padded_row_size * (kHeight - 3);
   uint32_t second_size =
       padded_row_size * 3 - (padded_row_size - unpadded_row_size);
   EXPECT_EQ(size, first_size + second_size);
   ExpectedMemoryInfo mem1 = GetExpectedMemory(first_size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(second_size);
-  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  std::unique_ptr<uint8_t[]> pixels(new uint8_t[size]);
   for (uint32_t ii = 0; ii < size; ++ii) {
     pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   Cmds expected;
   expected.tex_image_3d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, 1, kFormat, kType, 0, 0);
   expected.tex_sub_image_3d1.Init(
       kTarget, kLevel, 0, 0, 0, kWidth, kHeight - 3, 1, kFormat, kType,
       mem1.id, mem1.offset, GL_TRUE);
@@ skipping 39 matching lines @@
   const GLsizei kHeight = MaxTransferBufferSize() / padded_row_size + 2;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
   uint32_t first_size = (kHeight - 2) * padded_row_size;
   uint32_t second_size = 2 * padded_row_size;
   uint32_t third_size = first_size;
   uint32_t fourth_size = second_size - (padded_row_size - unpadded_row_size);
   EXPECT_EQ(size, first_size + second_size + third_size + fourth_size);
 
-  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  std::unique_ptr<uint8_t[]> pixels(new uint8_t[size]);
   for (uint32_t ii = 0; ii < size; ++ii) {
     pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   ExpectedMemoryInfo mem1_1 = GetExpectedMemory(first_size);
   ExpectedMemoryInfo mem1_2 = GetExpectedMemory(second_size);
   ExpectedMemoryInfo mem2_1 = GetExpectedMemory(third_size);
   ExpectedMemoryInfo mem2_2 = GetExpectedMemory(fourth_size);
 
   Cmds expected;
@@ skipping 1393 matching lines @@
   ContextInitOptions init_options;
   init_options.transfer_buffer_initialize_fail = true;
   EXPECT_FALSE(Initialize(init_options));
 }
 
 #include "base/macros.h"
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu