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

content/browser/blob_storage/blob_dispatcher_host_unittest.cc

 // Copyright 2016 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 "content/browser/blob_storage/blob_dispatcher_host.h"
 
+#include <memory>
 #include <vector>
 
 #include "base/command_line.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/run_loop.h"
 #include "base/tuple.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "ipc/ipc_sender.h"
 #include "ipc/ipc_test_sink.h"
@@ skipping 136 matching lines @@
     sink_.ClearMessages();
   }
 
   void ExpectAndResetBadMessage() {
     EXPECT_TRUE(host_->shutdown_for_bad_message_);
     host_->shutdown_for_bad_message_ = false;
   }
 
   void ExpectHandleEqualsData(BlobDataHandle* handle,
                               const std::vector<DataElement>& data) {
-    scoped_ptr<storage::BlobDataSnapshot> snapshot = handle->CreateSnapshot();
+    std::unique_ptr<storage::BlobDataSnapshot> snapshot =
+        handle->CreateSnapshot();
     EXPECT_FALSE(handle->IsBeingBuilt());
     for (size_t i = 0; i < data.size(); i++) {
       const DataElement& expected = data[i];
       const DataElement& actual = snapshot->items()[i]->data_element();
       EXPECT_EQ(expected, actual);
     }
     EXPECT_EQ(data.size(), snapshot->items().size());
   }
 
   void ExpectRequest(
@@ skipping 91 matching lines @@
   host_->OnMemoryItemResponse("", std::vector<BlobItemBytesResponse>());
   ExpectAndResetBadMessage();
   host_->OnCancelBuildingBlob("", IPCBlobCreationCancelCode::UNKNOWN);
   ExpectAndResetBadMessage();
 }
 
 TEST_F(BlobDispatcherHostTest, Shortcut) {
   const std::string kId = "uuid1";
   AsyncShortcutBlobTransfer(kId);
   EXPECT_TRUE(context_->registry().HasEntry(kId));
-  scoped_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
+  std::unique_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(handle);
 
   DataElement expected;
   expected.SetToBytes(kData, kDataSize);
   std::vector<DataElement> elements = {expected};
   ExpectHandleEqualsData(handle.get(), elements);
 }
 
 TEST_F(BlobDispatcherHostTest, RegularTransfer) {
   const std::string kId = "uuid1";
   AsyncBlobTransfer(kId);
   EXPECT_TRUE(context_->registry().HasEntry(kId));
-  scoped_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
+  std::unique_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(handle);
 
   DataElement expected;
   expected.SetToBytes(kData, kDataSize);
   std::vector<DataElement> elements = {expected};
   ExpectHandleEqualsData(handle.get(), elements);
 }
 
 TEST_F(BlobDispatcherHostTest, MultipleTransfers) {
   const std::string kId = "uuid";
@@ skipping 39 matching lines @@
   const std::string kId = "uuid1";
   const size_t kLargeSize = kTestBlobStorageMaxSharedMemoryBytes * 2;
   std::vector<base::SharedMemoryHandle> shared_memory_handles;
 
   ExpectBlobNotExist(kId);
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
 
   // Grab the handle.
-  scoped_ptr<BlobDataHandle> blob_data_handle =
+  std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_->GetBlobDataFromUUID(kId);
   bool built = false;
   IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
   blob_data_handle->RunOnConstructionComplete(
       base::Bind(&ConstructionCompletePopulator, &built, &error_code));
   EXPECT_FALSE(built);
 
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
   DataElement element;
   element.SetToBytesDescription(kLargeSize);
@@ skipping 51 matching lines @@
   }
   // Send the confirmation.
   responses = {BlobItemBytesResponse(1)};
   host_->OnMemoryItemResponse(kId, responses);
 
   ExpectDone(kId);
   sink_.ClearMessages();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(built) << "Error code: " << static_cast<int>(error_code);
   EXPECT_TRUE(context_->registry().HasEntry(kId));
-  scoped_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
+  std::unique_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(handle);
 
   DataElement expected;
   expected.SetToAllocatedBytes(kLargeSize / 2);
   std::memset(expected.mutable_bytes(), 'X', kLargeSize / 2);
   elements = {expected};
   std::memset(expected.mutable_bytes(), 'Z', kLargeSize / 2);
   elements.push_back(expected);
   ExpectHandleEqualsData(handle.get(), elements);
 }
@@ skipping 17 matching lines @@
   // It should have requested memory here.
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
   sink_.ClearMessages();
 
   // Cancel in middle of construction.
   host_->OnCancelBuildingBlob(kId, IPCBlobCreationCancelCode::UNKNOWN);
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   EXPECT_TRUE(host_->IsInUseInHost(kId));
   EXPECT_FALSE(IsBeingBuiltInHost(kId));
   // Check that's it's broken.
-  scoped_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
+  std::unique_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(handle->IsBroken());
   handle.reset();
   base::RunLoop().RunUntilIdle();
 
   // Get rid of it in the host.
   host_->OnDecrementBlobRefCount(kId);
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
   ExpectBlobNotExist(kId);
 
   // Create blob again to verify we don't have any old construction state lying
@@ skipping 10 matching lines @@
 
   // Verify we can't cancel after the fact.
   host_->OnCancelBuildingBlob(kId, IPCBlobCreationCancelCode::UNKNOWN);
   ExpectAndResetBadMessage();
 }
 
 TEST_F(BlobDispatcherHostTest, BlobDataWithHostDeletion) {
   // Build up a basic blob.
   const std::string kId("id");
   AsyncShortcutBlobTransfer(kId);
-  scoped_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
+  std::unique_ptr<BlobDataHandle> handle = context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(handle);
 
   // Kill the host.
   host_ = nullptr;
   base::RunLoop().RunUntilIdle();
   // Should still be there due to the handle.
-  scoped_ptr<BlobDataHandle> another_handle =
+  std::unique_ptr<BlobDataHandle> another_handle =
       context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(another_handle);
 
   // Should disappear after dropping both handles.
   handle.reset();
   another_handle.reset();
   base::RunLoop().RunUntilIdle();
 
   handle = context_->GetBlobDataFromUUID(kId);
   EXPECT_FALSE(handle);
 }
 
 TEST_F(BlobDispatcherHostTest, BlobReferenceWhileConstructing) {
   const std::string kId("id");
 
   // Start building blob.
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
 
   // Grab the handle.
-  scoped_ptr<BlobDataHandle> blob_data_handle =
+  std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle);
   EXPECT_TRUE(blob_data_handle->IsBeingBuilt());
   bool built = false;
   IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
   blob_data_handle->RunOnConstructionComplete(
       base::Bind(&ConstructionCompletePopulator, &built, &error_code));
 
   // Continue building.
   DataElement element;
@@ skipping 16 matching lines @@
 
 TEST_F(BlobDispatcherHostTest, BlobReferenceWhileShortcutConstructing) {
   const std::string kId("id");
 
   // Start building blob.
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
 
   // Grab the handle.
-  scoped_ptr<BlobDataHandle> blob_data_handle =
+  std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle);
   EXPECT_TRUE(blob_data_handle->IsBeingBuilt());
   bool built = false;
   IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
   blob_data_handle->RunOnConstructionComplete(
       base::Bind(&ConstructionCompletePopulator, &built, &error_code));
 
   // Continue building.
   DataElement element;
   element.SetToBytes(kData, kDataSize);
   std::vector<DataElement> elements = {element};
   host_->OnStartBuildingBlob(kId, elements);
   ExpectDone(kId);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(built) << "Error code: " << static_cast<int>(error_code);
 }
 
 TEST_F(BlobDispatcherHostTest, BlobReferenceWhileConstructingCancelled) {
   const std::string kId("id");
 
   // Start building blob.
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
 
   // Grab the handle.
-  scoped_ptr<BlobDataHandle> blob_data_handle =
+  std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle);
   EXPECT_TRUE(blob_data_handle->IsBeingBuilt());
   bool built = true;
   IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
   blob_data_handle->RunOnConstructionComplete(
       base::Bind(&ConstructionCompletePopulator, &built, &error_code));
 
   // Cancel in middle of construction.
   host_->OnCancelBuildingBlob(kId, IPCBlobCreationCancelCode::UNKNOWN);
@@ skipping 31 matching lines @@
   EXPECT_FALSE(context_->registry().HasEntry(kId));
   EXPECT_FALSE(IsBeingBuiltInHost(kId));
   ExpectCancel(kId,
                IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING);
   sink_.ClearMessages();
 
   // Do the same, but this time grab a handle before we decrement.
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
-  scoped_ptr<BlobDataHandle> blob_data_handle =
+  std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_->GetBlobDataFromUUID(kId);
   host_->OnDecrementBlobRefCount(kId);
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   EXPECT_TRUE(IsBeingBuiltInHost(kId));
 
   // Finish up the blob, and verify we got the done message.
   DataElement element;
   element.SetToBytes(kData, kDataSize);
   std::vector<DataElement> elements = {element};
   host_->OnStartBuildingBlob(kId, elements);
@@ skipping 38 matching lines @@
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
   host_->OnStartBuildingBlob(kId, elements);
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
   ExpectRequest(kId, expected_requests);
   sink_.ClearMessages();
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   // Grab the handle before decrementing.
-  scoped_ptr<BlobDataHandle> blob_data_handle =
+  std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_->GetBlobDataFromUUID(kId);
   host_->OnDecrementBlobRefCount(kId);
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   EXPECT_TRUE(IsBeingBuiltInHost(kId));
 
   // We finish the blob, and verify that we send 'Done' back to the renderer.
   BlobItemBytesResponse response(0);
   std::memcpy(response.allocate_mutable_data(kDataSize), kData, kDataSize);
   std::vector<BlobItemBytesResponse> responses = {response};
   host_->OnMemoryItemResponse(kId, responses);
@@ skipping 13 matching lines @@
 
 TEST_F(BlobDispatcherHostTest, DecrementRefAfterOnStartWithHandle) {
   const std::string kId("id");
   // Decrement the refcount while building, after we call
   // OnStartBuildlingBlob, except we have another handle.
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
 
-  scoped_ptr<BlobDataHandle> blob_data_handle =
+  std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle->IsBeingBuilt());
   bool built = true;
   IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
   blob_data_handle->RunOnConstructionComplete(
       base::Bind(&ConstructionCompletePopulator, &built, &error_code));
 
   DataElement element;
   element.SetToBytesDescription(kDataSize);
   std::vector<DataElement> elements = {element};
@@ skipping 32 matching lines @@
 }
 
 TEST_F(BlobDispatcherHostTest, HostDisconnectAfterRegisterWithHandle) {
   const std::string kId("id");
 
   // Delete host with a handle to the blob.
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
 
-  scoped_ptr<BlobDataHandle> blob_data_handle =
+  std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle->IsBeingBuilt());
   bool built = true;
   IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
   blob_data_handle->RunOnConstructionComplete(
       base::Bind(&ConstructionCompletePopulator, &built, &error_code));
   // Get rid of host, which was doing the constructing.
   host_ = nullptr;
   EXPECT_FALSE(blob_data_handle->IsBeingBuilt());
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(built);
   EXPECT_EQ(IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT, error_code);
 
   // Should still be there due to the handle.
-  scoped_ptr<BlobDataHandle> another_handle =
+  std::unique_ptr<BlobDataHandle> another_handle =
       context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(another_handle);
 
   // Should disappear after dropping both handles.
   blob_data_handle.reset();
   another_handle.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(context_->registry().HasEntry(kId));
 }
 
@@ skipping 226 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(host2->async_builder_.IsBeingBuilt(kDifferentHostReferencingId));
   EXPECT_FALSE(host_->async_builder_.IsBeingBuilt(kSameHostReferencingId));
   EXPECT_FALSE(
       context_->GetBlobDataFromUUID(kSameHostReferencingId)->IsBroken());
   EXPECT_FALSE(
       context_->GetBlobDataFromUUID(kDifferentHostReferencingId)->IsBroken());
   sink_.ClearMessages();
 
   // Finally check that our data is correct in the child elements.
-  scoped_ptr<BlobDataHandle> handle =
+  std::unique_ptr<BlobDataHandle> handle =
       context_->GetBlobDataFromUUID(kDifferentHostReferencingId);
   ExpectHandleEqualsData(handle.get(), elements);
 }
 
 TEST_F(BlobDispatcherHostTest, BuildingReferenceChainWithCancel) {
   const std::string kId("id");
   const std::string kSameHostReferencingId("id2");
   const std::string kDifferentHostReferencingId("id3");
   // Data elements for our transfer & checking messages.
   DataElement referencing_element;
@@ skipping 87 matching lines @@
       kDifferentHostReferencingId, std::string(kContentType),
       std::string(kContentDisposition), referenced_blobs_set);
   host2->OnStartBuildingBlob(kDifferentHostReferencingId, referencing_elements);
   ExpectDone(kDifferentHostReferencingId);
   EXPECT_TRUE(host2->async_builder_.IsBeingBuilt(kDifferentHostReferencingId));
   sink_.ClearMessages();
 
   // Grab handles & add listeners.
   bool built = true;
   IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
-  scoped_ptr<BlobDataHandle> blob_handle = context_->GetBlobDataFromUUID(kId);
+  std::unique_ptr<BlobDataHandle> blob_handle =
+      context_->GetBlobDataFromUUID(kId);
   blob_handle->RunOnConstructionComplete(
       base::Bind(&ConstructionCompletePopulator, &built, &error_code));
 
   bool same_host_built = true;
   IPCBlobCreationCancelCode same_host_error_code =
       IPCBlobCreationCancelCode::UNKNOWN;
-  scoped_ptr<BlobDataHandle> same_host_blob_handle =
+  std::unique_ptr<BlobDataHandle> same_host_blob_handle =
       context_->GetBlobDataFromUUID(kSameHostReferencingId);
   same_host_blob_handle->RunOnConstructionComplete(base::Bind(
       &ConstructionCompletePopulator, &same_host_built, &same_host_error_code));
 
   bool other_host_built = true;
   IPCBlobCreationCancelCode other_host_error_code =
       IPCBlobCreationCancelCode::UNKNOWN;
-  scoped_ptr<BlobDataHandle> other_host_blob_handle =
+  std::unique_ptr<BlobDataHandle> other_host_blob_handle =
       context_->GetBlobDataFromUUID(kDifferentHostReferencingId);
   other_host_blob_handle->RunOnConstructionComplete(
       base::Bind(&ConstructionCompletePopulator, &other_host_built,
                  &other_host_error_code));
 
   // Now we kill the host.
   host_ = nullptr;
   // We need to run the message loop to propagate the construction callbacks.
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(host2->async_builder_.IsBeingBuilt(kDifferentHostReferencingId));
   EXPECT_TRUE(
       context_->GetBlobDataFromUUID(kSameHostReferencingId)->IsBroken());
   EXPECT_TRUE(
       context_->GetBlobDataFromUUID(kDifferentHostReferencingId)->IsBroken());
 
   // Check our callbacks
   EXPECT_FALSE(built);
   EXPECT_EQ(IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT, error_code);
   EXPECT_FALSE(same_host_built);
   EXPECT_EQ(IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT,
             same_host_error_code);
   EXPECT_FALSE(other_host_built);
   EXPECT_EQ(IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT,
             other_host_error_code);
 
   sink_.ClearMessages();
 }
 
 }  // namespace content