convert //gpu to std::unique_ptr

gpu/command_buffer/service/cmd_parser_test.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.
 
 // Tests for the command parser.
 
+#include "gpu/command_buffer/service/cmd_parser.h"

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

nit: This can stay where it was

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

Done.

+
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
-#include "gpu/command_buffer/service/cmd_parser.h"
 #include "gpu/command_buffer/service/mocks.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
 
 using testing::_;
 using testing::Invoke;
 using testing::Mock;
 using testing::Return;
 using testing::Sequence;
@@ skipping 32 matching lines @@
 
     parser->SetBuffer(buffer(), shm_size, 0, command_buffer_size);
     return parser;
   }
 
   unsigned int buffer_entry_count() { return 20; }
   AsyncAPIMock *api_mock() { return api_mock_.get(); }
   CommandBufferEntry *buffer() { return buffer_.get(); }
  private:
   unsigned int buffer_entry_count_;
-  scoped_ptr<AsyncAPIMock> api_mock_;
-  scoped_ptr<CommandBufferEntry[]> buffer_;
+  std::unique_ptr<AsyncAPIMock> api_mock_;
+  std::unique_ptr<CommandBufferEntry[]> buffer_;
   Sequence sequence_;
 };
 
 // Tests initialization conditions.
 TEST_F(CommandParserTest, TestInit) {
-  scoped_ptr<CommandParser> parser(MakeParser(10));
+  std::unique_ptr<CommandParser> parser(MakeParser(10));
   EXPECT_EQ(0, parser->get());
   EXPECT_EQ(0, parser->put());
   EXPECT_TRUE(parser->IsEmpty());
 }
 
 // Tests simple commands.
 TEST_F(CommandParserTest, TestSimple) {
-  scoped_ptr<CommandParser> parser(MakeParser(10));
+  std::unique_ptr<CommandParser> parser(MakeParser(10));
   CommandBufferOffset put = parser->put();
   CommandHeader header;
 
   // add a single command, no args
   header.size = 1;
   header.command = 123;
   buffer()[put++].value_header = header;
   parser->set_put(put);
   EXPECT_EQ(put, parser->put());
 
@@ skipping 12 matching lines @@
   EXPECT_EQ(put, parser->put());
 
   AddDoCommandsExpect(error::kNoError, 1, 3, 3);
   EXPECT_EQ(error::kNoError, parser->ProcessCommands(1));
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 }
 
 // Tests having multiple commands in the buffer.
 TEST_F(CommandParserTest, TestMultipleCommands) {
-  scoped_ptr<CommandParser> parser(MakeParser(10));
+  std::unique_ptr<CommandParser> parser(MakeParser(10));
   CommandBufferOffset put = parser->put();
   CommandHeader header;
 
   // add 2 commands, test with single ProcessCommands()
   header.size = 2;
   header.command = 789;
   buffer()[put++].value_header = header;
   buffer()[put++].value_int32 = 5151;
 
   CommandBufferOffset put_cmd2 = put;
@@ skipping 31 matching lines @@
   // 4 entries remaining.
   AddDoCommandsExpect(
       error::kNoError, CommandParser::kParseCommandsSlice, 4, 4);
   EXPECT_EQ(error::kNoError, parser->ProcessAllCommands());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 }
 
 // Tests that the parser will wrap correctly at the end of the buffer.
 TEST_F(CommandParserTest, TestWrap) {
-  scoped_ptr<CommandParser> parser(MakeParser(5));
+  std::unique_ptr<CommandParser> parser(MakeParser(5));
   CommandBufferOffset put = parser->put();
   CommandHeader header;
 
   // add 3 commands with no args (1 word each)
   for (unsigned int i = 0; i < 3; ++i) {
     header.size = 1;
     header.command = i;
     buffer()[put++].value_header = header;
   }
   parser->set_put(put);
@@ skipping 31 matching lines @@
   EXPECT_EQ(put, parser->put());
 
   EXPECT_EQ(error::kNoError, parser->ProcessAllCommands());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 }
 
 // Tests error conditions.
 TEST_F(CommandParserTest, TestError) {
   const unsigned int kNumEntries = 5;
-  scoped_ptr<CommandParser> parser(MakeParser(kNumEntries));
+  std::unique_ptr<CommandParser> parser(MakeParser(kNumEntries));
   CommandBufferOffset put = parser->put();
   CommandHeader header;
 
   EXPECT_FALSE(parser->set_get(-1));
   EXPECT_FALSE(parser->set_get(kNumEntries));
 
   // Generate a command with size 0.
   header.size = 0;
   header.command = 3;
   buffer()[put++].value_header = header;
@@ skipping 51 matching lines @@
   Mock::VerifyAndClearExpectations(api_mock());
   // make the second one succeed, and check that the parser recovered fine.
   AddDoCommandsExpect(
       error::kNoError, CommandParser::kParseCommandsSlice, 1, 1);
   EXPECT_EQ(error::kNoError, parser->ProcessAllCommands());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 }
 
 TEST_F(CommandParserTest, SetBuffer) {
-  scoped_ptr<CommandParser> parser(MakeParser(3));
+  std::unique_ptr<CommandParser> parser(MakeParser(3));
   CommandBufferOffset put = parser->put();
   CommandHeader header;
 
   // add a single command, no args
   header.size = 2;
   header.command = 123;
   buffer()[put++].value_header = header;
   buffer()[put++].value_int32 = 456;
   parser->set_put(put);
 
   AddDoCommandsExpect(
       error::kNoError, CommandParser::kParseCommandsSlice, 2, 2);
   EXPECT_EQ(error::kNoError, parser->ProcessAllCommands());
   // We should have advanced 2 entries
   EXPECT_EQ(2, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 
-  scoped_ptr<CommandBufferEntry[]> buffer2(new CommandBufferEntry[2]);
+  std::unique_ptr<CommandBufferEntry[]> buffer2(new CommandBufferEntry[2]);
   parser->SetBuffer(
       buffer2.get(), sizeof(CommandBufferEntry) * 2, 0,
       sizeof(CommandBufferEntry) * 2);
   // The put and get should have reset to 0.
   EXPECT_EQ(0, parser->get());
   EXPECT_EQ(0, parser->put());
 }
 
 }  // namespace gpu