[BlobAsync] Disk support for blob storage

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 <tuple>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/shared_memory.h"
 #include "base/run_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "content/browser/blob_storage/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"
 #include "ipc/message_filter.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
@@ skipping 18 matching lines @@
 namespace content {
 namespace {
 
 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 size_t kTestBlobStorageMaxBlobMemorySize = 400;
+const size_t kTestBlobStorageMaxMemoryUsage = 500;
+const uint64_t kTestBlobStorageMaxDiskSpace = 1000;
+const size_t kTestBlobStorageInFlightMemory = 10;
+const uint64_t kTestBlobStorageMinFileSizeBytes = 10;
 const uint64_t kTestBlobStorageMaxFileSizeBytes = 100;
 
 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);
-  }
+      : BlobDispatcherHost(blob_storage_context), sink_(sink) {}
 
   bool Send(IPC::Message* message) override { return sink_->Send(message); }
 
   void ShutdownForBadMessage() override { shutdown_for_bad_message_ = true; }
 
   bool shutdown_for_bad_message_ = false;
 
  protected:
   ~TestableBlobDispatcherHost() override {}
 
  private:
   friend class base::RefCountedThreadSafe<TestableBlobDispatcherHost>;
 
   IPC::TestSink* sink_;
 };
+//
+// void SetElementToCharBytes(DataElement* element, char byte, size_t size) {
+//  std::vector<char> data(size);
+//  data.assign(size, byte);
+//  element->SetToBytes(data.data(), size);
+//}
 
 }  // namespace
 
 class BlobDispatcherHostTest : public testing::Test {
  protected:
   BlobDispatcherHostTest()
       : chrome_blob_storage_context_(
             ChromeBlobStorageContext::GetFor(&browser_context_)) {
     host_ =
         new TestableBlobDispatcherHost(chrome_blob_storage_context_, &sink_);
   }
   ~BlobDispatcherHostTest() override {}
 
   void SetUp() override {
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     if (!command_line->HasSwitch(switches::kDisableKillAfterBadIPC)) {
       command_line->AppendSwitch(switches::kDisableKillAfterBadIPC);
     }
     // We run the run loop to initialize the chrome blob storage context.
     base::RunLoop().RunUntilIdle();
     context_ = chrome_blob_storage_context_->context();
+    context_->mutable_memory_controller()->SetMemoryContantsForTesting(
+        kTestBlobStorageIPCThresholdBytes, kTestBlobStorageMaxSharedMemoryBytes,
+        kTestBlobStorageMaxBlobMemorySize, kTestBlobStorageMaxMemoryUsage,
+        kTestBlobStorageMaxDiskSpace, kTestBlobStorageInFlightMemory,
+        kTestBlobStorageMinFileSizeBytes, kTestBlobStorageMaxFileSizeBytes);
     DCHECK(context_);
   }
 
   void ExpectBlobNotExist(const std::string& id) {
     EXPECT_FALSE(context_->registry().HasEntry(id));
     EXPECT_FALSE(host_->IsInUseInHost(id));
     EXPECT_FALSE(IsBeingBuiltInHost(id));
   }
 
   void AsyncShortcutBlobTransfer(const std::string& id) {
     sink_.ClearMessages();
     ExpectBlobNotExist(id);
-    host_->OnRegisterBlobUUID(id, std::string(kContentType),
-                              std::string(kContentDisposition),
-                              std::set<std::string>());
-    EXPECT_FALSE(host_->shutdown_for_bad_message_);
     DataElement element;
     element.SetToBytes(kData, kDataSize);
     std::vector<DataElement> elements = {element};
-    host_->OnStartBuildingBlob(id, elements);
+    host_->OnRegisterBlob(id, std::string(kContentType),
+                          std::string(kContentDisposition), elements);
     EXPECT_FALSE(host_->shutdown_for_bad_message_);
     ExpectDone(id);
     sink_.ClearMessages();
   }
 
   void AsyncBlobTransfer(const std::string& id) {
     sink_.ClearMessages();
     ExpectBlobNotExist(id);
-    host_->OnRegisterBlobUUID(id, std::string(kContentType),
-                              std::string(kContentDisposition),
-                              std::set<std::string>());
-    EXPECT_FALSE(host_->shutdown_for_bad_message_);
     DataElement element;
     element.SetToBytesDescription(kDataSize);
     std::vector<DataElement> elements = {element};
-    host_->OnStartBuildingBlob(id, elements);
+    host_->OnRegisterBlob(id, std::string(kContentType),
+                          std::string(kContentDisposition), elements);
     EXPECT_FALSE(host_->shutdown_for_bad_message_);
 
     // Expect our request.
     std::vector<BlobItemBytesRequest> expected_requests = {
         BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)};
     ExpectRequest(id, expected_requests);
     sink_.ClearMessages();
 
     // Send results;
     BlobItemBytesResponse response(0);
@@ skipping 94 matching lines @@
         sink_.GetUniqueMessageMatching(BlobStorageMsg_DoneBuildingBlob::ID);
     std::tuple<std::string> args;
     BlobStorageMsg_DoneBuildingBlob::Read(message, &args);
     EXPECT_EQ(expected_uuid, std::get<0>(args));
   }
 
   bool IsBeingBuiltInHost(const std::string& uuid) {
     return host_->async_builder_.IsBeingBuilt(uuid);
   }
 
+  bool IsBeingBuiltInContext(const std::string& uuid) {
+    return context_->IsBeingBuilt(uuid);
+  }
+
   IPC::TestSink sink_;
   TestBrowserThreadBundle browser_thread_bundle_;
   TestBrowserContext browser_context_;
   ChromeBlobStorageContext* chrome_blob_storage_context_;
   BlobStorageContext* context_ = nullptr;
   scoped_refptr<TestableBlobDispatcherHost> host_;
 };
 
 TEST_F(BlobDispatcherHostTest, EmptyUUIDs) {
-  host_->OnRegisterBlobUUID("", "", "", std::set<std::string>());
-  ExpectAndResetBadMessage();
-  host_->OnStartBuildingBlob("", std::vector<DataElement>());
+  host_->OnRegisterBlob("", "", "", std::vector<DataElement>());
   ExpectAndResetBadMessage();
   host_->OnMemoryItemResponse("", std::vector<BlobItemBytesResponse>());
   ExpectAndResetBadMessage();
   host_->OnCancelBuildingBlob("", IPCBlobCreationCancelCode::UNKNOWN);
   ExpectAndResetBadMessage();
 }
 
 TEST_F(BlobDispatcherHostTest, Shortcut) {
   const std::string kId = "uuid1";
   AsyncShortcutBlobTransfer(kId);
@@ skipping 16 matching lines @@
 
   DataElement expected;
   expected.SetToBytes(kData, kDataSize);
   std::vector<DataElement> elements = {expected};
   ExpectHandleEqualsData(handle.get(), elements);
 }
 
 TEST_F(BlobDispatcherHostTest, MultipleTransfers) {
   const std::string kId = "uuid";
   const int kNumIters = 10;
+  sink_.ClearMessages();
   for (int i = 0; i < kNumIters; i++) {
     std::string id = kId;
     id += ('0' + i);
     ExpectBlobNotExist(id);
-    host_->OnRegisterBlobUUID(id, std::string(kContentType),
-                              std::string(kContentDisposition),
-                              std::set<std::string>());
-    EXPECT_FALSE(host_->shutdown_for_bad_message_);
-  }
-  sink_.ClearMessages();
-  for (int i = 0; i < kNumIters; i++) {
-    std::string id = kId;
-    id += ('0' + i);
     DataElement element;
     element.SetToBytesDescription(kDataSize);
     std::vector<DataElement> elements = {element};
-    host_->OnStartBuildingBlob(id, elements);
+    host_->OnRegisterBlob(id, std::string(kContentType),
+                          std::string(kContentDisposition), elements);
     EXPECT_FALSE(host_->shutdown_for_bad_message_);
     // Expect our request.
     std::vector<BlobItemBytesRequest> expected_requests = {
         BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)};
     ExpectRequest(id, expected_requests);
     sink_.ClearMessages();
   }
   for (int i = 0; i < kNumIters; i++) {
     std::string id = kId;
     id += ('0' + i);
     // Send results;
     BlobItemBytesResponse response(0);
     std::memcpy(response.allocate_mutable_data(kDataSize), kData, kDataSize);
     std::vector<BlobItemBytesResponse> responses = {response};
     host_->OnMemoryItemResponse(id, responses);
     ExpectDone(id);
     sink_.ClearMessages();
   }
 }
 
 TEST_F(BlobDispatcherHostTest, SharedMemoryTransfer) {
   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>());
+  DataElement element;
+  element.SetToBytesDescription(kLargeSize);
+  std::vector<DataElement> elements = {element};
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
+  EXPECT_FALSE(host_->shutdown_for_bad_message_);
 
   // Grab the 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);
-  std::vector<DataElement> elements = {element};
-  host_->OnStartBuildingBlob(kId, elements);
-  EXPECT_FALSE(host_->shutdown_for_bad_message_);
 
   // Expect our first request.
   std::vector<BlobItemBytesRequest> expected_requests = {
       BlobItemBytesRequest::CreateSharedMemoryRequest(
           0 /* request_number */, 0 /* renderer_item_index */,
           0 /* renderer_item_offset */,
           static_cast<uint64_t>(
               kTestBlobStorageMaxSharedMemoryBytes) /* size */,
           0 /* handle_index */, 0 /* handle_offset */)};
   ExpectRequestWithSharedMemoryHandles(kId, expected_requests,
@@ skipping 58 matching lines @@
 }
 
 TEST_F(BlobDispatcherHostTest, OnCancelBuildingBlob) {
   const std::string kId("id");
   // We ignore blobs that are unknown, as it could have been cancelled earlier
   // and the renderer didn't know about it yet.
   host_->OnCancelBuildingBlob(kId, IPCBlobCreationCancelCode::UNKNOWN);
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
 
   // Start building blob.
-  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
-                            std::string(kContentDisposition),
-                            std::set<std::string>());
-  EXPECT_FALSE(host_->shutdown_for_bad_message_);
   DataElement element;
   element.SetToBytesDescription(kDataSize);
   std::vector<DataElement> elements = {element};
-  host_->OnStartBuildingBlob(kId, elements);
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
   // 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.
@@ skipping 45 matching lines @@
   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>());
+  DataElement element;
+  element.SetToBytesDescription(kDataSize);
+  std::vector<DataElement> elements = {element};
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
 
   // Grab the 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.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) << "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.
-  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>());
+  DataElement element;
+  element.SetToBytesDescription(kDataSize);
+  std::vector<DataElement> elements = {element};
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
 
   // Grab the 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));
@@ skipping 15 matching lines @@
   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) {
-  const std::string kId("id");
-  // Decrement the refcount while building (renderer blob gc'd before
-  // construction was completed).
-  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
-                            std::string(kContentDisposition),
-                            std::set<std::string>());
-  EXPECT_TRUE(context_->registry().HasEntry(kId));
-  host_->OnDecrementBlobRefCount(kId);
-  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>());
-  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);
-  EXPECT_FALSE(host_->shutdown_for_bad_message_);
-  ExpectDone(kId);
-  sink_.ClearMessages();
-  // Get rid of the handle, and verify it's gone.
-  blob_data_handle.reset();
-  base::RunLoop().RunUntilIdle();
-  // Check that it's no longer around.
-  EXPECT_FALSE(context_->registry().HasEntry(kId));
-  EXPECT_FALSE(IsBeingBuiltInHost(kId));
-}
-
 TEST_F(BlobDispatcherHostTest, DecrementRefAfterOnStart) {
   const std::string kId("id");
 
   // Decrement the refcount while building, after we call OnStartBuildlingBlob.
-  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
-                            std::string(kContentDisposition),
-                            std::set<std::string>());
-  EXPECT_FALSE(host_->shutdown_for_bad_message_);
   DataElement element;
   element.SetToBytesDescription(kDataSize);
   std::vector<DataElement> elements = {element};
-  host_->OnStartBuildingBlob(kId, elements);
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
 
   std::vector<BlobItemBytesRequest> expected_requests = {
       BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)};
   ExpectRequest(kId, expected_requests);
   sink_.ClearMessages();
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   host_->OnDecrementBlobRefCount(kId);
   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 to keep it alive.
-  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
-                            std::string(kContentDisposition),
-                            std::set<std::string>());
-  EXPECT_FALSE(host_->shutdown_for_bad_message_);
-  host_->OnStartBuildingBlob(kId, elements);
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), 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.
   std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_->GetBlobDataFromUUID(kId);
   host_->OnDecrementBlobRefCount(kId);
   EXPECT_TRUE(context_->registry().HasEntry(kId));
   EXPECT_TRUE(IsBeingBuiltInHost(kId));
@@ skipping 14 matching lines @@
   base::RunLoop().RunUntilIdle();
   // Check that it's no longer around.
   EXPECT_FALSE(context_->registry().HasEntry(kId));
   EXPECT_FALSE(IsBeingBuiltInHost(kId));
 }
 
 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>());
+  DataElement element;
+  element.SetToBytesDescription(kDataSize);
+  std::vector<DataElement> elements = {element};
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
 
   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};
-  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.
@@ skipping 11 matching lines @@
   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>());
-
-  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.
-  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));
-}
-
 TEST_F(BlobDispatcherHostTest, HostDisconnectAfterOnStart) {
   const std::string kId("id");
 
   // Host deleted after OnStartBuilding.
-  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
-                            std::string(kContentDisposition),
-                            std::set<std::string>());
-
   DataElement element;
   element.SetToBytesDescription(kDataSize);
   std::vector<DataElement> elements = {element};
-  host_->OnStartBuildingBlob(kId, elements);
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
 
   std::vector<BlobItemBytesRequest> expected_requests = {
       BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)};
   ExpectRequest(kId, expected_requests);
   sink_.ClearMessages();
   host_ = nullptr;
   // We need to run the message loop because of the handle in the async builder.
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(context_->registry().HasEntry(kId));
 }
 
 TEST_F(BlobDispatcherHostTest, HostDisconnectAfterOnMemoryResponse) {
   const std::string kId("id");
 
   // Host deleted after OnMemoryItemResponse.
-  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
-                            std::string(kContentDisposition),
-                            std::set<std::string>());
-
-  // Create list of two items.
   DataElement element;
   element.SetToBytesDescription(kDataSize);
   std::vector<DataElement> elements = {element, element};
-  host_->OnStartBuildingBlob(kId, elements);
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
+
+  // Create list of two items.
   std::vector<BlobItemBytesRequest> expected_requests = {
       BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize),
       BlobItemBytesRequest::CreateIPCRequest(1, 1, 0, kDataSize)};
   ExpectRequest(kId, expected_requests);
   sink_.ClearMessages();
 
   // Send just one response so the blob isn't 'done' yet.
   BlobItemBytesResponse response(0);
   std::memcpy(response.allocate_mutable_data(kDataSize), kData, kDataSize);
   std::vector<BlobItemBytesResponse> responses = {response};
   host_->OnMemoryItemResponse(kId, responses);
   EXPECT_EQ(0u, sink_.message_count());
 
   host_ = nullptr;
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(context_->registry().HasEntry(kId));
 }
 
 TEST_F(BlobDispatcherHostTest, CreateBlobWithBrokenReference) {
   const std::string kBrokenId("id1");
   const std::string kReferencingId("id2");
 
   // First, let's test a circular reference.
   const std::string kCircularId("id1");
-  host_->OnRegisterBlobUUID(kCircularId, std::string(kContentType),
-                            std::string(kContentDisposition), {kCircularId});
+  DataElement element;
+  element.SetToBlob(kCircularId);
+  std::vector<DataElement> elements = {element};
+  host_->OnRegisterBlob(kCircularId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
   ExpectAndResetBadMessage();
 
   // Next, test a blob that references a broken blob.
-  host_->OnRegisterBlobUUID(kBrokenId, std::string(kContentType),
-                            std::string(kContentDisposition),
-                            std::set<std::string>());
+  element.SetToBytesDescription(kDataSize);
+  elements = {element};
+  host_->OnRegisterBlob(kBrokenId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
+  sink_.ClearMessages();
   host_->OnCancelBuildingBlob(kBrokenId, IPCBlobCreationCancelCode::UNKNOWN);
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
   EXPECT_TRUE(context_->GetBlobDataFromUUID(kBrokenId)->IsBroken());
 
   // Create referencing blob. We should be broken right away, but also ignore
   // the subsequent OnStart message.
-  host_->OnRegisterBlobUUID(kReferencingId, std::string(kContentType),
-                            std::string(kContentDisposition), {kBrokenId});
+  element.SetToBytesDescription(kDataSize);
+  elements = {element};
+  element.SetToBlob(kBrokenId);
+  elements.push_back(element);
+  host_->OnRegisterBlob(kReferencingId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
   EXPECT_TRUE(context_->GetBlobDataFromUUID(kReferencingId)->IsBroken());
   EXPECT_FALSE(IsBeingBuiltInHost(kReferencingId));
   EXPECT_TRUE(context_->registry().HasEntry(kReferencingId));
   ExpectCancel(kReferencingId,
                IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN);
   sink_.ClearMessages();
-
-  DataElement element;
-  element.SetToBytesDescription(kDataSize);
-  std::vector<DataElement> elements = {element};
-  element.SetToBlob(kBrokenId);
-  elements.push_back(element);
-  host_->OnStartBuildingBlob(kReferencingId, elements);
-  EXPECT_EQ(0u, sink_.message_count());
-  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(BlobDispatcherHostTest, DeferenceBlobOnDifferentHost) {
   const std::string kId("id");
   // Data elements for our transfer & checking messages.
   DataElement element;
   element.SetToBytesDescription(kDataSize);
   std::vector<DataElement> elements = {element};
   std::vector<BlobItemBytesRequest> expected_requests = {
       BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)};
   BlobItemBytesResponse response(0);
   std::memcpy(response.allocate_mutable_data(kDataSize), kData, kDataSize);
   std::vector<BlobItemBytesResponse> responses = {response};
 
   scoped_refptr<TestableBlobDispatcherHost> host2(
       new TestableBlobDispatcherHost(chrome_blob_storage_context_, &sink_));
 
   // Delete host with another host having a referencing, then dereference on
   // second host. Verify we're still building it on first host, and then
   // verify that a building message from the renderer will kill it.
 
   // Test OnStartBuilding after double dereference.
-  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
-                            std::string(kContentDisposition),
-                            std::set<std::string>());
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
+  EXPECT_FALSE(host_->shutdown_for_bad_message_);
+  ExpectRequest(kId, expected_requests);
+  sink_.ClearMessages();
   host2->OnIncrementBlobRefCount(kId);
   host_->OnDecrementBlobRefCount(kId);
   EXPECT_FALSE(host_->IsInUseInHost(kId));
   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));
+  // Send the memory. When the host sees the entry doesn't exist, it should
+  // cancel and clean up.
   EXPECT_TRUE(host_->async_builder_.IsBeingBuilt(kId));
-  host_->OnStartBuildingBlob(kId, elements);
-  EXPECT_FALSE(host_->shutdown_for_bad_message_);
+  host_->OnMemoryItemResponse(kId, responses);
   // We should be cleaned up.
   EXPECT_FALSE(host_->async_builder_.IsBeingBuilt(kId));
   ExpectCancel(kId,
-               IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING);
-  sink_.ClearMessages();
-
-  // Same as above, but test OnMemoryItemResponse after double dereference.
-  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
-                            std::string(kContentDisposition),
-                            std::set<std::string>());
-  host2->OnIncrementBlobRefCount(kId);
-  host_->OnDecrementBlobRefCount(kId);
-  EXPECT_FALSE(host_->IsInUseInHost(kId));
-  host_->OnStartBuildingBlob(kId, elements);
-  ExpectRequest(kId, expected_requests);
-  sink_.ClearMessages();
-
-  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_->OnMemoryItemResponse(kId, responses);
-  EXPECT_FALSE(host_->shutdown_for_bad_message_);
-  // We should be cleaned up.
-  EXPECT_FALSE(host_->async_builder_.IsBeingBuilt(kId));
-  ExpectCancel(kId,
                IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING);
   sink_.ClearMessages();
 
   // Same, but now for OnCancel.
-  host_->OnRegisterBlobUUID(kId, std::string(kContentType),
-                            std::string(kContentDisposition),
-                            std::set<std::string>());
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
   host2->OnIncrementBlobRefCount(kId);
   host_->OnDecrementBlobRefCount(kId);
   EXPECT_FALSE(host_->IsInUseInHost(kId));
-  host_->OnStartBuildingBlob(kId, elements);
   ExpectRequest(kId, expected_requests);
   sink_.ClearMessages();
 
   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};
+  element.SetToBytesDescription(kDataSize);
   DataElement referencing_element;
   referencing_element.SetToBlob(kId);
+  std::vector<DataElement> elements = {element};
   std::vector<DataElement> referencing_elements = {referencing_element};
-  std::set<std::string> referenced_blobs_set = {kId};
+  std::vector<BlobItemBytesRequest> expected_requests = {
+      BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)};
+  BlobItemBytesResponse response(0);
+  std::memcpy(response.allocate_mutable_data(kDataSize), kData, kDataSize);
+  std::vector<BlobItemBytesResponse> responses = {response};
 
   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>());
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
+  ExpectRequest(kId, expected_requests);
+  sink_.ClearMessages();
   EXPECT_TRUE(host_->IsInUseInHost(kId));
+  EXPECT_TRUE(IsBeingBuiltInContext(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);
+  host_->OnRegisterBlob(kSameHostReferencingId, std::string(kContentType),
+                        std::string(kContentDisposition), referencing_elements);
   EXPECT_FALSE(host_->shutdown_for_bad_message_);
   ExpectDone(kSameHostReferencingId);
-  EXPECT_TRUE(host_->async_builder_.IsBeingBuilt(kSameHostReferencingId));
   sink_.ClearMessages();
+  EXPECT_FALSE(
+      context_->GetBlobDataFromUUID(kSameHostReferencingId)->IsBroken());
+  EXPECT_FALSE(host_->async_builder_.IsBeingBuilt(kSameHostReferencingId));
+  EXPECT_TRUE(IsBeingBuiltInContext(kSameHostReferencingId));
+
   // 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);
+  host2->OnRegisterBlob(kDifferentHostReferencingId, std::string(kContentType),
+                        std::string(kContentDisposition), referencing_elements);
   EXPECT_FALSE(host2->shutdown_for_bad_message_);
   ExpectDone(kDifferentHostReferencingId);
-  EXPECT_TRUE(host2->async_builder_.IsBeingBuilt(kDifferentHostReferencingId));
   sink_.ClearMessages();
+  EXPECT_FALSE(
+      context_->GetBlobDataFromUUID(kDifferentHostReferencingId)->IsBroken());
+  EXPECT_FALSE(host2->async_builder_.IsBeingBuilt(kDifferentHostReferencingId));
+  EXPECT_TRUE(IsBeingBuiltInContext(kDifferentHostReferencingId));
 
   // Now we finish the first blob, and we expect all blobs to finish.
-  host_->OnStartBuildingBlob(kId, elements);
+  host_->OnMemoryItemResponse(kId, responses);
   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.
   std::unique_ptr<BlobDataHandle> handle =
       context_->GetBlobDataFromUUID(kDifferentHostReferencingId);
-  ExpectHandleEqualsData(handle.get(), elements);
+  DataElement expected;
+  expected.SetToBytes(kData, kDataSize);
+  std::vector<DataElement> expecteds = {expected};
+  ExpectHandleEqualsData(handle.get(), expecteds);
 }
 
 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 element;
+  element.SetToBytesDescription(kDataSize);
   DataElement referencing_element;
   referencing_element.SetToBlob(kId);
+  std::vector<DataElement> elements = {element};
   std::vector<DataElement> referencing_elements = {referencing_element};
-  std::set<std::string> referenced_blobs_set = {kId};
+  std::vector<BlobItemBytesRequest> expected_requests = {
+      BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)};
 
   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.
+  // 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>());
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
+  ExpectRequest(kId, expected_requests);
+  sink_.ClearMessages();
   EXPECT_TRUE(host_->IsInUseInHost(kId));
+  EXPECT_TRUE(IsBeingBuiltInContext(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);
+  host_->OnRegisterBlob(kSameHostReferencingId, std::string(kContentType),
+                        std::string(kContentDisposition), referencing_elements);
+  EXPECT_FALSE(host_->shutdown_for_bad_message_);
   ExpectDone(kSameHostReferencingId);
-  EXPECT_TRUE(host_->async_builder_.IsBeingBuilt(kSameHostReferencingId));
   sink_.ClearMessages();
+  EXPECT_FALSE(
+      context_->GetBlobDataFromUUID(kSameHostReferencingId)->IsBroken());
+  EXPECT_FALSE(host_->async_builder_.IsBeingBuilt(kSameHostReferencingId));
+  EXPECT_TRUE(IsBeingBuiltInContext(kSameHostReferencingId));
+
   // Now the other host.
-  host2->OnRegisterBlobUUID(
-      kDifferentHostReferencingId, std::string(kContentType),
-      std::string(kContentDisposition), referenced_blobs_set);
-  host2->OnStartBuildingBlob(kDifferentHostReferencingId, referencing_elements);
+  host2->OnRegisterBlob(kDifferentHostReferencingId, std::string(kContentType),
+                        std::string(kContentDisposition), referencing_elements);
+  EXPECT_FALSE(host2->shutdown_for_bad_message_);
   ExpectDone(kDifferentHostReferencingId);
-  EXPECT_TRUE(host2->async_builder_.IsBeingBuilt(kDifferentHostReferencingId));
   sink_.ClearMessages();
+  EXPECT_FALSE(
+      context_->GetBlobDataFromUUID(kDifferentHostReferencingId)->IsBroken());
+  EXPECT_FALSE(host2->async_builder_.IsBeingBuilt(kDifferentHostReferencingId));
+  EXPECT_TRUE(IsBeingBuiltInContext(kDifferentHostReferencingId));
+
   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 element;
+  element.SetToBytesDescription(kDataSize);
   DataElement referencing_element;
   referencing_element.SetToBlob(kId);
+  std::vector<DataElement> elements = {element};
   std::vector<DataElement> referencing_elements = {referencing_element};
-  std::set<std::string> referenced_blobs_set = {kId};
+  std::vector<BlobItemBytesRequest> expected_requests = {
+      BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)};
+  BlobItemBytesResponse response(0);
+  std::memcpy(response.allocate_mutable_data(kDataSize), kData, kDataSize);
+  std::vector<BlobItemBytesResponse> responses = {response};
 
   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.
+  // 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>());
+  host_->OnRegisterBlob(kId, std::string(kContentType),
+                        std::string(kContentDisposition), elements);
+  ExpectRequest(kId, expected_requests);
+  sink_.ClearMessages();
   EXPECT_TRUE(host_->IsInUseInHost(kId));
+  EXPECT_TRUE(IsBeingBuiltInContext(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);
+  host_->OnRegisterBlob(kSameHostReferencingId, std::string(kContentType),
+                        std::string(kContentDisposition), 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);
-  host2->OnStartBuildingBlob(kDifferentHostReferencingId, referencing_elements);
+  host2->OnRegisterBlob(kDifferentHostReferencingId, std::string(kContentType),
+                        std::string(kContentDisposition), referencing_elements);
+  EXPECT_FALSE(host2->shutdown_for_bad_message_);
   ExpectDone(kDifferentHostReferencingId);
-  EXPECT_TRUE(host2->async_builder_.IsBeingBuilt(kDifferentHostReferencingId));
   sink_.ClearMessages();
 
   // Grab handles & add listeners.
   bool built = true;
   IPCBlobCreationCancelCode error_code = IPCBlobCreationCancelCode::UNKNOWN;
   std::unique_ptr<BlobDataHandle> blob_handle =
       context_->GetBlobDataFromUUID(kId);
   blob_handle->RunOnConstructionComplete(
       base::Bind(&ConstructionCompletePopulator, &built, &error_code));
 
@@ skipping 29 matching lines @@
   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();
 }
+//
+// TEST_F(BlobDispatcherHostTest, BlobChaos) {
+//  DataElement element;
+//  element.SetToBytesDescription(kTestBlobStorageMaxMemoryUsage / 3 + 1);
+//  std::vector<DataElement> elements = {element};
+//
+//  int memory_left = kTestBlobStorageMaxDiskSpace
+//      + kTestBlobStorageMaxDiskSpace;
+//
+//  // Option 1:
+//  // * shortcut
+//  // * shared mem
+//  // * multiple shared mem
+//
+//  for (int i = 0; i < 1000; i++) {
+//    std::string id = base::IntToString(i);
+//    int option1 = i % 3;
+//    size_t size;
+//    switch(option1) {
+//      case 0:
+//        size = kTestBlobStorageIPCThresholdBytes;
+//        break;
+//      case 1:
+//        size = kTestBlobStorageMaxSharedMemoryBytes;
+//        break;
+//      case 2:
+//        size = kTestBlobStorageMaxSharedMemoryBytes * 3 + 1;
+//        break;
+//    }
+//    if (memory_left - size <= 0) {
+//      break;
+//    }
+//    DataElement element;
+//    std::vector<DataElement> elements;
+//    if (option1 == 0) {
+//      SetElementToCharBytes(&element, 'z', size);
+//    } else {
+//      element.SetToBytesDescription(size);
+//    }
+//    elements.push_back(element);
+//
+//    host_->OnRegisterBlob(id, std::string(kContentType),
+//                          std::string(kContentDisposition), elements);
+//  }
+//
+//  for (int i = 0; i < sink_.message_count(); i++) {
+//
+//  }
+//}
 
 }  // namespace content