[BlobAsync] Adding better error reporting and some new tests.

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 <vector>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 33 matching lines @@
 
 const char kContentType[] = "text/plain";
 const char kContentDisposition[] = "content_disposition";
 const char kData[] = "data!!";
 const size_t kDataSize = 6;
 
 const size_t kTestBlobStorageIPCThresholdBytes = 20;
 const size_t kTestBlobStorageMaxSharedMemoryBytes = 50;
 const uint64_t kTestBlobStorageMaxFileSizeBytes = 100;
 
-template <typename T>
-void SetPointerValue(T* pointer, T value) {
-  *pointer = value;
+void ConstructionCompletePopulator(bool* succeeded_pointer,
+                                   IPCBlobCreationCancelCode* reason_pointer,
+                                   bool succeeded,
+                                   IPCBlobCreationCancelCode reason) {
+  *succeeded_pointer = succeeded;
+  *reason_pointer = reason;
 }
 
 class TestableBlobDispatcherHost : public BlobDispatcherHost {
  public:
   TestableBlobDispatcherHost(ChromeBlobStorageContext* blob_storage_context,
                              IPC::TestSink* sink)
       : BlobDispatcherHost(blob_storage_context), sink_(sink) {
     this->SetMemoryConstantsForTesting(kTestBlobStorageIPCThresholdBytes,
                                        kTestBlobStorageMaxSharedMemoryBytes,
                                        kTestBlobStorageMaxFileSizeBytes);
@@ skipping 234 matching lines @@
   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 =
       context_->GetBlobDataFromUUID(kId);
   bool built = false;
+  IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
   blob_data_handle->RunOnConstructionComplete(
-      base::Bind(&SetPointerValue<bool>, &built));
+      base::Bind(&ConstructionCompletePopulator, &built, &error_code));
   EXPECT_FALSE(built);
 
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
   DataElement element;
   element.SetToBytesDescription(kLargeSize);
   std::vector<DataElement> elements = {element};
   host_->OnStartBuildingBlob(kId, elements);
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
 
   // Expect our first request.
@@ skipping 44 matching lines @@
     std::memset(memory.memory(), 'Z', kTestBlobStorageMaxSharedMemoryBytes);
     memory.Close();
   }
   // Send the confirmation.
   responses = {BlobItemBytesResponse(1)};
   host_->OnMemoryItemResponse(kId, responses);
 
   ExpectDone(kId);
   sink_.ClearMessages();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(built);
+  EXPECT_TRUE(built) << "Error code: " << static_cast<int>(error_code);
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   scoped_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);
@@ skipping 83 matching lines @@
   host_->OnRegisterBlobUUID(kId, std::string(kContentType),
                             std::string(kContentDisposition),
                             std::set<std::string>());
 
   // Grab the handle.
   scoped_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(&SetPointerValue<bool>, &built));
+      base::Bind(&ConstructionCompletePopulator, &built, &error_code));
 
   // Continue building.
   DataElement element;
   element.SetToBytesDescription(kDataSize);
   std::vector<DataElement> elements = {element};
   host_->OnStartBuildingBlob(kId, elements);
   sink_.ClearMessages();
 
   // Send data.
   BlobItemBytesResponse response(0);
   std::memcpy(response.allocate_mutable_data(kDataSize), kData, kDataSize);
   std::vector<BlobItemBytesResponse> responses = {response};
   sink_.ClearMessages();
   host_->OnMemoryItemResponse(kId, responses);
 
   ExpectDone(kId);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(built);
+  EXPECT_TRUE(built) << "Error code: " << static_cast<int>(error_code);
 }
 
 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 =
       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(&SetPointerValue<bool>, &built));
+      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);
+  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 =
       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(&SetPointerValue<bool>, &built));
+      base::Bind(&ConstructionCompletePopulator, &built, &error_code));
 
   // Cancel in middle of construction.
   host_->OnCancelBuildingBlob(kId, IPCBlobCreationCancelCode::UNKNOWN);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   EXPECT_TRUE(host_->IsInUseInHost(kId));
   EXPECT_FALSE(IsBeingBuiltInHost(kId));
   EXPECT_TRUE(blob_data_handle->IsBroken());
   EXPECT_FALSE(built);
+  EXPECT_EQ(IPCBlobCreationCancelCode::UNKNOWN, error_code);
+  error_code = IPCBlobCreationCancelCode::UNKNOWN;
   built = true;
   blob_data_handle->RunOnConstructionComplete(
-      base::Bind(&SetPointerValue<bool>, &built));
+      base::Bind(&ConstructionCompletePopulator, &built, &error_code));
   EXPECT_FALSE(built);
+  EXPECT_EQ(IPCBlobCreationCancelCode::UNKNOWN, error_code);
 
   // Remove it.
   blob_data_handle.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   host_->OnDecrementBlobRefCount(kId);
   ExpectBlobNotExist(kId);
 }
 
 TEST_F(BlobDispatcherHostTest, DecrementRefAfterRegister) {
@@ skipping 105 matching lines @@
   // 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 =
       context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle->IsBeingBuilt());
   bool built = true;
+  IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
   blob_data_handle->RunOnConstructionComplete(
-      base::Bind(&SetPointerValue<bool>, &built));
+      base::Bind(&ConstructionCompletePopulator, &built, &error_code));
 
   DataElement element;
   element.SetToBytesDescription(kDataSize);
   std::vector<DataElement> elements = {element};
   host_->OnStartBuildingBlob(kId, elements);
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
 
   // Check that we got the expected request.
   std::vector<BlobItemBytesRequest> expected_requests = {
       BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)};
   ExpectRequest(kId, expected_requests);
   sink_.ClearMessages();
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   EXPECT_TRUE(IsBeingBuiltInHost(kId));
   // Decrement, simulating where the ref goes out of scope in renderer.
   host_->OnDecrementBlobRefCount(kId);
   // We still have the blob as it's not done.
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   EXPECT_TRUE(blob_data_handle->IsBeingBuilt());
   EXPECT_TRUE(IsBeingBuiltInHost(kId));
   // Cancel to clean up.
   host_->OnCancelBuildingBlob(kId, IPCBlobCreationCancelCode::UNKNOWN);
   // Run loop to propagate the handle decrement in the host.
   base::RunLoop().RunUntilIdle();
   // We still have the entry because of our earlier handle.
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   EXPECT_FALSE(IsBeingBuiltInHost(kId));
+  EXPECT_FALSE(built);
+  EXPECT_EQ(IPCBlobCreationCancelCode::UNKNOWN, error_code);
   sink_.ClearMessages();
 
   // Should disappear after dropping the handle.
   EXPECT_TRUE(blob_data_handle->IsBroken());
   blob_data_handle.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(context_->registry().HasEntry(kId));
 }
 
 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 =
       context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle->IsBeingBuilt());
   bool built = true;
+  IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
   blob_data_handle->RunOnConstructionComplete(
-      base::Bind(&SetPointerValue<bool>, &built));
+      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 =
       context_->GetBlobDataFromUUID(kId);
   EXPECT_TRUE(another_handle);
 
   // Should disappear after dropping both handles.
   blob_data_handle.reset();
   another_handle.reset();
   base::RunLoop().RunUntilIdle();
@@ skipping 168 matching lines @@
   host2->OnDecrementBlobRefCount(kId);
   // So no more blob in the context, but we're still being built in host 1.
   EXPECT_FALSE(context_->registry().HasEntry(kId));
   EXPECT_TRUE(host_->async_builder_.IsBeingBuilt(kId));
   host_->OnCancelBuildingBlob(kId, IPCBlobCreationCancelCode::UNKNOWN);
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
   // We should be cleaned up.
   EXPECT_FALSE(host_->async_builder_.IsBeingBuilt(kId));
 }
 
+TEST_F(BlobDispatcherHostTest, BuildingReferenceChain) {
+  const std::string kId("id");
+  const std::string kSameHostReferencingId("id2");
+  const std::string kDifferentHostReferencingId("id3");
+  // Data elements for our transfer & checking messages.
+  DataElement element;
+  element.SetToBytes(kData, kDataSize);
+  std::vector<DataElement> elements = {element};
+  DataElement referencing_element;
+  referencing_element.SetToBlob(kId);
+  std::vector<DataElement> referencing_elements = {referencing_element};
+  std::set<std::string> referenced_blobs_set = {kId};
+
+  scoped_refptr<TestableBlobDispatcherHost> host2(
+      new TestableBlobDispatcherHost(chrome_blob_storage_context_, &sink_));
+
+  // We want to have a blob referencing another blob that is building, both on
+  // the same host and a different host. We should successfully build all blobs
+  // after the referenced blob is finished.
+
+  // First we start the referenced blob.
+  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
+                            std::string(kContentDisposition),
+                            std::set<std::string>());
+  EXPECT_TRUE(host_->IsInUseInHost(kId));
+
+  // Next we start the referencing blobs in both the same and different host.
+  host_->OnRegisterBlobUUID(kSameHostReferencingId, std::string(kContentType),
+                            std::string(kContentDisposition),
+                            referenced_blobs_set);
+  EXPECT_FALSE(host_->shutdown_for_bad_message_);
+  host_->OnStartBuildingBlob(kSameHostReferencingId, referencing_elements);
+  EXPECT_FALSE(host_->shutdown_for_bad_message_);
+  ExpectDone(kSameHostReferencingId);
+  EXPECT_TRUE(host_->async_builder_.IsBeingBuilt(kSameHostReferencingId));
+  sink_.ClearMessages();
+  // Now the other host.
+  host2->OnRegisterBlobUUID(
+      kDifferentHostReferencingId, std::string(kContentType),
+      std::string(kContentDisposition), referenced_blobs_set);
+  EXPECT_FALSE(host2->shutdown_for_bad_message_);
+  host2->OnStartBuildingBlob(kDifferentHostReferencingId, referencing_elements);
+  EXPECT_FALSE(host2->shutdown_for_bad_message_);
+  ExpectDone(kDifferentHostReferencingId);
+  EXPECT_TRUE(host2->async_builder_.IsBeingBuilt(kDifferentHostReferencingId));
+  sink_.ClearMessages();
+
+  // Now we finish the first blob, and we expect all blobs to finish.
+  host_->OnStartBuildingBlob(kId, elements);
+  ExpectDone(kId);
+  // We need to run the message loop to propagate the construction callbacks.
+  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 =
+      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;
+  referencing_element.SetToBlob(kId);
+  std::vector<DataElement> referencing_elements = {referencing_element};
+  std::set<std::string> referenced_blobs_set = {kId};
+
+  scoped_refptr<TestableBlobDispatcherHost> host2(
+      new TestableBlobDispatcherHost(chrome_blob_storage_context_, &sink_));
+
+  // We want to have a blob referencing another blob that is building, both on
+  // the same host and a different host. After we cancel the first blob, the
+  // others should cancel as well.
+
+  // First we start the referenced blob.
+  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
+                            std::string(kContentDisposition),
+                            std::set<std::string>());
+  EXPECT_TRUE(host_->IsInUseInHost(kId));
+
+  // Next we start the referencing blobs in both the same and different host.
+  host_->OnRegisterBlobUUID(kSameHostReferencingId, std::string(kContentType),
+                            std::string(kContentDisposition),
+                            referenced_blobs_set);
+  host_->OnStartBuildingBlob(kSameHostReferencingId, referencing_elements);
+  ExpectDone(kSameHostReferencingId);
+  EXPECT_TRUE(host_->async_builder_.IsBeingBuilt(kSameHostReferencingId));
+  sink_.ClearMessages();
+  // Now the other host.
+  host2->OnRegisterBlobUUID(
+      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();
+  bool built = false;
+  IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
+  context_->GetBlobDataFromUUID(kDifferentHostReferencingId)
+      ->RunOnConstructionComplete(
+          base::Bind(&ConstructionCompletePopulator, &built, &error_code));
+
+  // Now we cancel the first blob, and we expect all blobs to cancel.
+  host_->OnCancelBuildingBlob(kId, IPCBlobCreationCancelCode::UNKNOWN);
+  // We need to run the message loop to propagate the construction callbacks.
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(host2->async_builder_.IsBeingBuilt(kDifferentHostReferencingId));
+  EXPECT_FALSE(host_->async_builder_.IsBeingBuilt(kSameHostReferencingId));
+  EXPECT_TRUE(
+      context_->GetBlobDataFromUUID(kSameHostReferencingId)->IsBroken());
+  EXPECT_TRUE(
+      context_->GetBlobDataFromUUID(kDifferentHostReferencingId)->IsBroken());
+  EXPECT_FALSE(built);
+  EXPECT_EQ(IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN, error_code);
+  sink_.ClearMessages();
+}
+
+TEST_F(BlobDispatcherHostTest, BuildingReferenceChainWithSourceDeath) {
+  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;
+  referencing_element.SetToBlob(kId);
+  std::vector<DataElement> referencing_elements = {referencing_element};
+  std::set<std::string> referenced_blobs_set = {kId};
+
+  scoped_refptr<TestableBlobDispatcherHost> host2(
+      new TestableBlobDispatcherHost(chrome_blob_storage_context_, &sink_));
+
+  // We want to have a blob referencing another blob that is building, both on
+  // the same host and a different host. When we destroy the host, the other
+  // blob should cancel, as well as the blob on the other host.
+
+  // First we start the referenced blob.
+  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
+                            std::string(kContentDisposition),
+                            std::set<std::string>());
+  EXPECT_TRUE(host_->IsInUseInHost(kId));
+
+  // Next we start the referencing blobs in both the same and different host.
+  host_->OnRegisterBlobUUID(kSameHostReferencingId, std::string(kContentType),
+                            std::string(kContentDisposition),
+                            referenced_blobs_set);
+  host_->OnStartBuildingBlob(kSameHostReferencingId, referencing_elements);
+  ExpectDone(kSameHostReferencingId);
+  EXPECT_TRUE(host_->async_builder_.IsBeingBuilt(kSameHostReferencingId));
+  sink_.ClearMessages();
+  // Now the other host.
+  host2->OnRegisterBlobUUID(
+      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);
+  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 =
+      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 =
+      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