convert //gpu to std::unique_ptr

gpu/command_buffer/service/sync_point_manager_unittest.cc

 // Copyright (c) 2015 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 <stdint.h>
 

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

#include <memory>

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

Done.

 #include <queue>
 
 #include "base/bind.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
 
 class SyncPointManagerTest : public testing::Test {
  public:
@@ skipping 13 matching lines @@
 
   // Simple static function used for testing OnWaitCallback.
   static void OnWait(CommandBufferNamespace* namespace_id_ptr,
                      CommandBufferId* client_id_ptr,
                      CommandBufferNamespace namespace_id,
                      CommandBufferId client_id) {
     *namespace_id_ptr = namespace_id;
     *client_id_ptr = client_id;
   }
 
-  scoped_ptr<SyncPointManager> sync_point_manager_;
+  std::unique_ptr<SyncPointManager> sync_point_manager_;
 };
 
 struct SyncPointStream {
   scoped_refptr<SyncPointOrderData> order_data;
-  scoped_ptr<SyncPointClient> client;
+  std::unique_ptr<SyncPointClient> client;
   std::queue<uint32_t> order_numbers;
 
   SyncPointStream(SyncPointManager* sync_point_manager,
                   CommandBufferNamespace namespace_id,
                   CommandBufferId command_buffer_id)
       : order_data(SyncPointOrderData::Create()),
         client(sync_point_manager->CreateSyncPointClient(order_data,
                                                          namespace_id,
                                                          command_buffer_id)) {}
 
@@ skipping 57 matching lines @@
   const CommandBufferNamespace kNamespaceId =
       gpu::CommandBufferNamespace::GPU_IO;
   const CommandBufferId kBufferId = CommandBufferId::FromUnsafeValue(0x123);
 
   scoped_refptr<SyncPointClientState> empty_state =
       sync_point_manager_->GetSyncPointClientState(kNamespaceId, kBufferId);
   EXPECT_FALSE(empty_state);
 
   scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
 
-  scoped_ptr<SyncPointClient> client =
+  std::unique_ptr<SyncPointClient> client =
       sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
                                                  kBufferId);
 
   EXPECT_EQ(order_data, client->client_state()->order_data());
   EXPECT_EQ(
       client->client_state(),
       sync_point_manager_->GetSyncPointClientState(kNamespaceId, kBufferId));
 }
 
 TEST_F(SyncPointManagerTest, BasicFenceSyncRelease) {
   const CommandBufferNamespace kNamespaceId =
       gpu::CommandBufferNamespace::GPU_IO;
   const CommandBufferId kBufferId = CommandBufferId::FromUnsafeValue(0x123);
 
   scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
-  scoped_ptr<SyncPointClient> client =
+  std::unique_ptr<SyncPointClient> client =
       sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
                                                  kBufferId);
   scoped_refptr<SyncPointClientState> client_state = client->client_state();
 
   EXPECT_EQ(0u, client_state->fence_sync_release());
   EXPECT_FALSE(client_state->IsFenceSyncReleased(1));
 
   const uint32_t order_num =
       order_data->GenerateUnprocessedOrderNumber(sync_point_manager_.get());
   order_data->BeginProcessingOrderNumber(order_num);
   client->ReleaseFenceSync(1);
   order_data->FinishProcessingOrderNumber(order_num);
 
   EXPECT_EQ(1u, client_state->fence_sync_release());
   EXPECT_TRUE(client_state->IsFenceSyncReleased(1));
 }
 
 TEST_F(SyncPointManagerTest, MultipleClientsPerOrderData) {
   const CommandBufferNamespace kNamespaceId =
       gpu::CommandBufferNamespace::GPU_IO;
   const CommandBufferId kBufferId1 = CommandBufferId::FromUnsafeValue(0x123);
   const CommandBufferId kBufferId2 = CommandBufferId::FromUnsafeValue(0x234);
 
   scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
-  scoped_ptr<SyncPointClient> client1 =
+  std::unique_ptr<SyncPointClient> client1 =
       sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
                                                  kBufferId1);
-  scoped_ptr<SyncPointClient> client2 =
+  std::unique_ptr<SyncPointClient> client2 =
       sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
                                                  kBufferId2);
 
   scoped_refptr<SyncPointClientState> client_state1 = client1->client_state();
   scoped_refptr<SyncPointClientState> client_state2 = client2->client_state();
 
   const uint32_t order_num =
       order_data->GenerateUnprocessedOrderNumber(sync_point_manager_.get());
   order_data->BeginProcessingOrderNumber(order_num);
   client1->ReleaseFenceSync(1);
@@ skipping 306 matching lines @@
   EXPECT_TRUE(valid_wait);
   EXPECT_EQ(10, test_num);
   EXPECT_EQ(kNamespaceId, namespace_id);
   EXPECT_EQ(kBufferId2, client_id);
 
   release_stream.client->ReleaseFenceSync(2);
   EXPECT_EQ(123, test_num);
 }
 
 }  // namespace gpu