convert //gpu to std::unique_ptr

gpu/command_buffer/service/command_executor_unittest.cc

 // Copyright (c) 2011 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 "gpu/command_buffer/service/command_executor.h"
 
 #include <stddef.h>
 #include <stdint.h>
 

[no sievers, 2016/04/05 19:02:40]

#include <memory>

[Mostyn Bramley-Moore, 2016/04/05 21:35:31]

Done.

 #include "gpu/command_buffer/common/command_buffer_mock.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/mocks.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::Invoke;
 using testing::NiceMock;
 using testing::Return;
 using testing::SetArgumentPointee;
 using testing::StrictMock;
 
 namespace gpu {
 
 const size_t kRingBufferSize = 1024;
 
 class CommandExecutorTest : public testing::Test {
  protected:
   static const int32_t kTransferBufferId = 123;
 
   void SetUp() override {
-    scoped_ptr<base::SharedMemory> shared_memory(new ::base::SharedMemory);
+    std::unique_ptr<base::SharedMemory> shared_memory(new ::base::SharedMemory);
     shared_memory->CreateAndMapAnonymous(kRingBufferSize);
     buffer_ = static_cast<int32_t*>(shared_memory->memory());
     shared_memory_buffer_ =
         MakeBufferFromSharedMemory(std::move(shared_memory), kRingBufferSize);
     memset(buffer_, 0, kRingBufferSize);
 
     command_buffer_.reset(new MockCommandBuffer);
 
     CommandBuffer::State default_state;
     ON_CALL(*command_buffer_.get(), GetLastState())
@@ skipping 16 matching lines @@
   }
 
   void TearDown() override {
     // Ensure that any unexpected tasks posted by the GPU scheduler are executed
     // in order to fail the test.
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   error::Error GetError() { return command_buffer_->GetLastState().error; }
 
-  scoped_ptr<MockCommandBuffer> command_buffer_;
+  std::unique_ptr<MockCommandBuffer> command_buffer_;
   scoped_refptr<Buffer> shared_memory_buffer_;
   int32_t* buffer_;
-  scoped_ptr<gles2::MockGLES2Decoder> decoder_;
-  scoped_ptr<CommandExecutor> executor_;
+  std::unique_ptr<gles2::MockGLES2Decoder> decoder_;
+  std::unique_ptr<CommandExecutor> executor_;
   base::MessageLoop message_loop_;
 };
 
 TEST_F(CommandExecutorTest, ExecutorDoesNothingIfRingBufferIsEmpty) {
   CommandBuffer::State state;
 
   EXPECT_CALL(*command_buffer_, GetLastState()).WillRepeatedly(Return(state));
 
   EXPECT_CALL(*command_buffer_, SetParseError(_)).Times(0);
 
@@ skipping 109 matching lines @@
 
   EXPECT_EQ(kRingBufferSize, executor_->GetSharedMemoryBuffer(7)->size());
 }
 
 TEST_F(CommandExecutorTest, SetTokenForwardsToCommandBuffer) {
   EXPECT_CALL(*command_buffer_, SetToken(7));
   executor_->set_token(7);
 }
 
 }  // namespace gpu