remove linked_ptr from gpu/

gpu/command_buffer/client/cmd_buffer_helper_test.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 the Command Buffer Helper.
 
 #include <stddef.h>
 #include <stdint.h>
 
-#include <list>
 #include <memory>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
-#include "base/memory/linked_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/mocks.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
 
@@ skipping 130 matching lines @@
         .InSequence(sequence_)
         .WillOnce(Return(_return));
   }
 
   void AddUniqueCommandWithExpect(error::Error _return, int cmd_size) {
     EXPECT_GE(cmd_size, 1);
     EXPECT_LT(cmd_size, kTotalNumCommandEntries);
     int arg_count = cmd_size - 1;
 
     // Allocate array for args.
-    linked_ptr<std::vector<CommandBufferEntry> > args_ptr(
-        new std::vector<CommandBufferEntry>(arg_count ? arg_count : 1));
+    auto args_ptr =
+        base::MakeUnique<CommandBufferEntry[]>(arg_count ? arg_count : 1);
 
     for (int32_t ii = 0; ii < arg_count; ++ii) {
-      (*args_ptr)[ii].value_uint32 = 0xF00DF00D + ii;
+      args_ptr[ii].value_uint32 = 0xF00DF00D + ii;
     }
 
     // Add command and save args in test_command_args_ until the test completes.
     AddCommandWithExpect(
-        _return, test_command_next_id_++, arg_count, &(*args_ptr)[0]);
-    test_command_args_.insert(test_command_args_.end(), args_ptr);
+        _return, test_command_next_id_++, arg_count, args_ptr.get());
+    test_command_args_.push_back(std::move(args_ptr));
   }
 
   void TestCommandWrappingFull(int32_t cmd_size, int32_t start_commands) {
     const int32_t num_args = cmd_size - 1;
     EXPECT_EQ(kTotalNumCommandEntries % cmd_size, 0);
 
     std::vector<CommandBufferEntry> args(num_args);
     for (int32_t ii = 0; ii < num_args; ++ii) {
       args[ii].value_uint32 = ii + 1;
     }
@@ skipping 69 matching lines @@
     return command_buffer_->GetLastState().error;
   }
 
   CommandBufferOffset get_helper_put() { return helper_->put_; }
 
   std::unique_ptr<AsyncAPIMock> api_mock_;
   scoped_refptr<TransferBufferManagerInterface> transfer_buffer_manager_;
   std::unique_ptr<CommandBufferServiceLocked> command_buffer_;
   std::unique_ptr<CommandExecutor> executor_;
   std::unique_ptr<CommandBufferHelper> helper_;
-  std::list<linked_ptr<std::vector<CommandBufferEntry> > > test_command_args_;
+  std::vector<std::unique_ptr<CommandBufferEntry[]>> test_command_args_;
   unsigned int test_command_next_id_;
   Sequence sequence_;
   base::MessageLoop message_loop_;
 };
 
 // Checks immediate_entry_count_ changes based on 'usable' state.
 TEST_F(CommandBufferHelperTest, TestCalcImmediateEntriesNotUsable) {
   // Auto flushing mode is tested separately.
   helper_->SetAutomaticFlushes(false);
   EXPECT_EQ(helper_->usable(), true);
@@ skipping 485 matching lines @@
   helper_->OrderingBarrier();
   flush_count2 = command_buffer_->FlushCount();
   helper_->OrderingBarrier();
   flush_count3 = command_buffer_->FlushCount();
 
   EXPECT_EQ(flush_count2, flush_count1 + 1);
   EXPECT_EQ(flush_count3, flush_count2 + 1);
 }
 
 }  // namespace gpu