Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/blob_storage/blob_async_builder_host_unittest.cc

 // Copyright 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 "storage/browser/blob/blob_async_builder_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
@@ skipping 68 matching lines @@
     host_.SetMemoryConstantsForTesting(kTestBlobStorageIPCThresholdBytes,
                                        kTestBlobStorageMaxSharedMemoryBytes,
                                        kTestBlobStorageMaxFileSizeBytes);
     BlobDataBuilder builder(kCompletedBlobUUID);
     builder.AppendData(kCompletedBlobData);
     completed_blob_handle_ = context_.AddFinishedBlob(builder);
     completed_blob_uuid_set_ = {kCompletedBlobUUID};
   }
 
   void RequestMemoryCallback(
-      scoped_ptr<std::vector<storage::BlobItemBytesRequest>> requests,
-      scoped_ptr<std::vector<base::SharedMemoryHandle>> shared_memory_handles,
-      scoped_ptr<std::vector<base::File>> files) {
+      std::unique_ptr<std::vector<storage::BlobItemBytesRequest>> requests,
+      std::unique_ptr<std::vector<base::SharedMemoryHandle>>
+          shared_memory_handles,
+      std::unique_ptr<std::vector<base::File>> files) {
     requests_ = std::move(*requests);
     memory_handles_ = std::move(*shared_memory_handles);
     request_called_ = true;
   }
 
   BlobTransportResult BuildBlobAsync(
       const std::vector<DataElement>& descriptions,
       const std::set<std::string>& referenced_blob_uuids,
       size_t memory_available) {
     request_called_ = false;
@@ skipping 20 matching lines @@
   content::TestBrowserThreadBundle browser_thread_bundle_;
   BlobStorageContext context_;
   BlobAsyncBuilderHost host_;
   IPCBlobCreationCancelCode cancel_code_;
 
   bool request_called_;
   std::vector<storage::BlobItemBytesRequest> requests_;
   std::vector<base::SharedMemoryHandle> memory_handles_;
   std::set<std::string> completed_blob_uuid_set_;
 
-  scoped_ptr<BlobDataHandle> completed_blob_handle_;
+  std::unique_ptr<BlobDataHandle> completed_blob_handle_;
 };
 
 // The 'shortcut' method is when the data is included in the initial IPCs and
 // the browser uses that instead of requesting the memory.
 TEST_F(BlobAsyncBuilderHostTest, TestShortcut) {
   std::vector<DataElement> descriptions;
 
   AddShortcutMemoryItem(10, &descriptions);
   AddBlobItem(&descriptions);
   AddShortcutMemoryItem(5000, &descriptions);
 
   BlobDataBuilder expected(kBlobUUID);
   expected.set_content_type(kContentType);
   expected.set_content_disposition(kContentDisposition);
   AddShortcutMemoryItem(10, &expected);
   expected.AppendData(kCompletedBlobData);
   AddShortcutMemoryItem(5000, &expected);
 
   EXPECT_EQ(BlobTransportResult::DONE,
             BuildBlobAsync(descriptions, completed_blob_uuid_set_, 5010));
 
   EXPECT_FALSE(request_called_);
   EXPECT_EQ(0u, host_.blob_building_count());
-  scoped_ptr<BlobDataHandle> handle = context_.GetBlobDataFromUUID(kBlobUUID);
+  std::unique_ptr<BlobDataHandle> handle =
+      context_.GetBlobDataFromUUID(kBlobUUID);
   EXPECT_FALSE(handle->IsBeingBuilt());
   EXPECT_FALSE(handle->IsBroken());
-  scoped_ptr<BlobDataSnapshot> data = handle->CreateSnapshot();
+  std::unique_ptr<BlobDataSnapshot> data = handle->CreateSnapshot();
   EXPECT_EQ(expected, *data);
   data.reset();
   handle.reset();
   base::RunLoop().RunUntilIdle();
 };
 
 TEST_F(BlobAsyncBuilderHostTest, TestShortcutNoRoom) {
   std::vector<DataElement> descriptions;
 
   AddShortcutMemoryItem(10, &descriptions);
@@ skipping 80 matching lines @@
             requests_.at(0));
 
   memset(shared_memory.memory(), kSecondBlockByte, 1);
 
   response.request_number = 1;
   responses[0] = response;
   EXPECT_EQ(BlobTransportResult::DONE,
             host_.OnMemoryResponses(kBlobUUID, responses, &context_));
   EXPECT_FALSE(request_called_);
   EXPECT_EQ(0u, host_.blob_building_count());
-  scoped_ptr<BlobDataHandle> blob_handle =
+  std::unique_ptr<BlobDataHandle> blob_handle =
       context_.GetBlobDataFromUUID(kBlobUUID);
   EXPECT_FALSE(blob_handle->IsBeingBuilt());
   EXPECT_FALSE(blob_handle->IsBroken());
-  scoped_ptr<BlobDataSnapshot> blob_data = blob_handle->CreateSnapshot();
+  std::unique_ptr<BlobDataSnapshot> blob_data = blob_handle->CreateSnapshot();
   EXPECT_EQ(expected, *blob_data);
 };
 
 TEST_F(BlobAsyncBuilderHostTest, TestBasicIPCAndStopBuilding) {
   std::vector<DataElement> descriptions;
 
   AddMemoryItem(2, &descriptions);
   AddBlobItem(&descriptions);
   AddMemoryItem(2, &descriptions);
 
   BlobDataBuilder expected(kBlobUUID);
   expected.set_content_type(kContentType);
   expected.set_content_disposition(kContentDisposition);
   AddShortcutMemoryItem(2, &expected);
   expected.AppendData(kCompletedBlobData);
   AddShortcutMemoryItem(2, &expected);
 
   EXPECT_EQ(BlobTransportResult::PENDING_RESPONSES,
             BuildBlobAsync(descriptions, completed_blob_uuid_set_, 5010));
   host_.CancelBuildingBlob(kBlobUUID, IPCBlobCreationCancelCode::UNKNOWN,
                            &context_);
 
   // Check that we're broken, and then remove the blob.
-  scoped_ptr<BlobDataHandle> blob_handle =
+  std::unique_ptr<BlobDataHandle> blob_handle =
       context_.GetBlobDataFromUUID(kBlobUUID);
   EXPECT_FALSE(blob_handle->IsBeingBuilt());
   EXPECT_TRUE(blob_handle->IsBroken());
   blob_handle.reset();
   DecrementBlobRefCount(kBlobUUID);
   base::RunLoop().RunUntilIdle();
   blob_handle = context_.GetBlobDataFromUUID(kBlobUUID);
   EXPECT_FALSE(blob_handle.get());
 
   // This should succeed because we've removed all references to the blob.
@@ skipping 10 matching lines @@
   PopulateBytes(response2.allocate_mutable_data(2), 2);
   std::vector<BlobItemBytesResponse> responses = {response1, response2};
 
   EXPECT_EQ(BlobTransportResult::DONE,
             host_.OnMemoryResponses(kBlobUUID, responses, &context_));
   EXPECT_FALSE(request_called_);
   EXPECT_EQ(0u, host_.blob_building_count());
   blob_handle = context_.GetBlobDataFromUUID(kBlobUUID);
   EXPECT_FALSE(blob_handle->IsBeingBuilt());
   EXPECT_FALSE(blob_handle->IsBroken());
-  scoped_ptr<BlobDataSnapshot> blob_data = blob_handle->CreateSnapshot();
+  std::unique_ptr<BlobDataSnapshot> blob_data = blob_handle->CreateSnapshot();
   EXPECT_EQ(expected, *blob_data);
 };
 
 TEST_F(BlobAsyncBuilderHostTest, TestBreakingAllBuilding) {
   const std::string& kBlob1 = "blob1";
   const std::string& kBlob2 = "blob2";
   const std::string& kBlob3 = "blob3";
 
   // Register blobs.
   EXPECT_EQ(BlobTransportResult::DONE,
             host_.RegisterBlobUUID(kBlob1, kContentType, kContentDisposition,
                                    std::set<std::string>(), &context_));
   EXPECT_EQ(BlobTransportResult::DONE,
             host_.RegisterBlobUUID(kBlob2, kContentType, kContentDisposition,
                                    std::set<std::string>(), &context_));
   EXPECT_EQ(BlobTransportResult::DONE,
             host_.RegisterBlobUUID(kBlob3, kContentType, kContentDisposition,
                                    std::set<std::string>(), &context_));
 
   // Start building one of them.
   std::vector<DataElement> descriptions;
   AddMemoryItem(2, &descriptions);
   EXPECT_EQ(BlobTransportResult::PENDING_RESPONSES,
             host_.StartBuildingBlob(
                 kBlob1, descriptions, 2, &context_,
                 base::Bind(&BlobAsyncBuilderHostTest::RequestMemoryCallback,
                            base::Unretained(this))));
   EXPECT_TRUE(request_called_);
 
-  scoped_ptr<BlobDataHandle> blob_handle1 =
+  std::unique_ptr<BlobDataHandle> blob_handle1 =
       context_.GetBlobDataFromUUID(kBlob1);
-  scoped_ptr<BlobDataHandle> blob_handle2 =
+  std::unique_ptr<BlobDataHandle> blob_handle2 =
       context_.GetBlobDataFromUUID(kBlob2);
-  scoped_ptr<BlobDataHandle> blob_handle3 =
+  std::unique_ptr<BlobDataHandle> blob_handle3 =
       context_.GetBlobDataFromUUID(kBlob2);
   EXPECT_TRUE(blob_handle1->IsBeingBuilt() && blob_handle2->IsBeingBuilt() &&
               blob_handle3->IsBeingBuilt());
   EXPECT_FALSE(blob_handle1->IsBroken() || blob_handle2->IsBroken() ||
                blob_handle3->IsBroken());
 
   host_.CancelAll(&context_);
 
   EXPECT_FALSE(blob_handle1->IsBeingBuilt() || blob_handle2->IsBeingBuilt() ||
                blob_handle3->IsBeingBuilt());
@@ skipping 242 matching lines @@
                            &context_);
   EXPECT_EQ(BlobTransportResult::CANCEL_REFERENCED_BLOB_BROKEN,
             host_.RegisterBlobUUID(kBlob2, kContentType, kContentDisposition,
                                    {kBlob1}, &context_));
   EXPECT_FALSE(host_.IsBeingBuilt(kBlob2));
   EXPECT_FALSE(IsBeingBuiltInContext(kBlob2));
   EXPECT_TRUE(context_.GetBlobDataFromUUID(kBlob2)->IsBroken());
 };
 
 }  // namespace storage