[BlobAsync] Disk support for blob storage

content/browser/blob_storage/blob_storage_context_unittest.cc

 // Copyright 2014 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_storage_context.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <memory>
 #include <string>
 
+#include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
+#include "base/files/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/browser/blob_storage/blob_dispatcher_host.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/public/test/test_browser_context.h"
 #include "net/base/io_buffer.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/disk_cache.h"
 #include "storage/browser/blob/blob_async_builder_host.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_data_item.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
-#include "storage/browser/blob/blob_transport_result.h"
 #include "storage/common/blob_storage/blob_item_bytes_request.h"
 #include "storage/common/blob_storage/blob_item_bytes_response.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using RequestMemoryCallback =
     storage::BlobAsyncBuilderHost::RequestMemoryCallback;
+using FileCreationInfo = storage::BlobMemoryController::FileCreationInfo;
 
 namespace storage {
 namespace {
+using base::TestSimpleTaskRunner;
 
-const char kContentType[] = "text/plain";
-const char kContentDisposition[] = "content_disposition";
 const int kTestDiskCacheStreamIndex = 0;
 
+const std::string kBlobStorageDirectory = "blob_storage";
+const size_t kTestBlobStorageIPCThresholdBytes = 20;
+const size_t kTestBlobStorageMaxSharedMemoryBytes = 50;
+
+const size_t kTestBlobStorageMaxBlobMemorySize = 400;
+const uint64_t kTestBlobStorageMaxDiskSpace = 4000;
+const size_t kTestBlobStorageInFlightMemory = 10;
+const uint64_t kTestBlobStorageMinFileSizeBytes = 10;
+const uint64_t kTestBlobStorageMaxFileSizeBytes = 100;
+
 // Our disk cache tests don't need a real data handle since the tests themselves
 // scope the disk cache and entries.
 class EmptyDataHandle : public storage::BlobDataBuilder::DataHandle {
  private:
   ~EmptyDataHandle() override {}
 };
 
 std::unique_ptr<disk_cache::Backend> CreateInMemoryDiskCache() {
   std::unique_ptr<disk_cache::Backend> cache;
   net::TestCompletionCallback callback;
@@ skipping 17 matching lines @@
     return nullptr;
   disk_cache::ScopedEntryPtr entry(temp_entry);
 
   scoped_refptr<net::StringIOBuffer> iobuffer = new net::StringIOBuffer(data);
   rv = entry->WriteData(kTestDiskCacheStreamIndex, 0, iobuffer.get(),
                         iobuffer->size(), callback.callback(), false);
   EXPECT_EQ(static_cast<int>(data.size()), callback.GetResult(rv));
   return entry;
 }
 
+void SaveBlobStatus(BlobStatus* status_ptr, BlobStatus status) {
+  *status_ptr = status;
+}
+
+void SaveBlobStatusAndFiles(BlobStatus* status_ptr,
+                            std::vector<FileCreationInfo>* files_ptr,
+                            BlobStatus status,
+                            std::vector<FileCreationInfo> files) {
+  *status_ptr = status;
+  for (FileCreationInfo& info : files) {
+    files_ptr->push_back(std::move(info));
+  }
+}
+
+void IncrementPointer(size_t* number, BlobStatus status) {
+  EXPECT_EQ(BlobStatus::DONE, status);
+  *number = *number + 1;
+}
 
 }  // namespace
 
 class BlobStorageContextTest : public testing::Test {
  protected:
   BlobStorageContextTest() {}
   ~BlobStorageContextTest() override {}
 
+  void SetUp() override {
+    ASSERT_TRUE(base::CreateNewTempDirectory("BlobContextTest", &temp_dir_));
+  }
+
+  void TearDown() override {
+    // Make sure we clean up the files.
+    files_.clear();
+    base::RunLoop().RunUntilIdle();
+    file_runner_->RunPendingTasks();
+    base::RunLoop().RunUntilIdle();
+    ASSERT_EQ(true, base::DeleteFile(temp_dir_, true));
+  }
+
   std::unique_ptr<BlobDataHandle> SetupBasicBlob(const std::string& id) {
     BlobDataBuilder builder(id);
     builder.AppendData("1", 1);
     builder.set_content_type("text/plain");
     return context_.AddFinishedBlob(builder);
   }
 
+  void SetTestMemoryLimits() {
+    context_.mutable_memory_controller()->SetMemoryConstantsForTesting(
+        kTestBlobStorageIPCThresholdBytes, kTestBlobStorageMaxSharedMemoryBytes,
+        kTestBlobStorageMaxBlobMemorySize, kTestBlobStorageMaxDiskSpace,
+        kTestBlobStorageInFlightMemory, kTestBlobStorageMinFileSizeBytes,
+        kTestBlobStorageMaxFileSizeBytes);
+  }
+
+  void IncrementRefCount(const std::string& uuid) {
+    context_.IncrementBlobRefCount(uuid);
+  }
+
+  void DecrementRefCount(const std::string& uuid) {
+    context_.DecrementBlobRefCount(uuid);
+  }
+
+  base::FilePath temp_dir_;
+  scoped_refptr<TestSimpleTaskRunner> file_runner_ = new TestSimpleTaskRunner();
+  std::vector<FileCreationInfo> files_;
+
+  base::MessageLoop fake_io_message_loop_;
   BlobStorageContext context_;
 };
 
+TEST_F(BlobStorageContextTest, BuildBlobAsync) {
+  const std::string kId("id");
+  const size_t kSize = 10u;
+  BlobStatus status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+
+  BlobDataBuilder builder(kId);
+  builder.AppendFutureData(kSize);
+  builder.set_content_type("text/plain");
+  EXPECT_EQ(0lu, context_.memory_controller().memory_usage());
+  std::unique_ptr<BlobDataHandle> handle = context_.BuildBlob(
+      builder, base::Bind(&SaveBlobStatusAndFiles, &status, &files_));
+  EXPECT_EQ(10lu, context_.memory_controller().memory_usage());
+  EXPECT_TRUE(handle->IsBeingBuilt());
+  EXPECT_EQ(BlobStatus::PENDING, status);
+
+  BlobStatus construction_done = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+  handle->RunOnConstructionComplete(
+      base::Bind(&SaveBlobStatus, &construction_done));
+
+  EXPECT_EQ(10u, context_.memory_controller().memory_usage());
+
+  builder.PopulateFutureData(0, "abcdefghij", 0, 10u);
+  context_.FinishedPopulatingPendingBlob(kId);
+
+  // Check we're done.
+  EXPECT_EQ(BlobStatus::DONE, handle->GetBlobStatus());
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(BlobStatus::DONE, construction_done);
+
+  EXPECT_EQ(builder, *handle->CreateSnapshot());
+
+  handle.reset();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(0lu, context_.memory_controller().memory_usage());
+}
+
+TEST_F(BlobStorageContextTest, BuildBlobAndCancel) {
+  const std::string kId("id");
+  const size_t kSize = 10u;
+  BlobStatus status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+
+  BlobDataBuilder builder(kId);
+  builder.AppendFutureData(kSize);
+  builder.set_content_type("text/plain");
+  EXPECT_EQ(0lu, context_.memory_controller().memory_usage());
+  std::unique_ptr<BlobDataHandle> handle = context_.BuildBlob(
+      builder, base::Bind(&SaveBlobStatusAndFiles, &status, &files_));
+  EXPECT_EQ(10lu, context_.memory_controller().memory_usage());
+  EXPECT_TRUE(handle->IsBeingBuilt());
+  EXPECT_EQ(BlobStatus::PENDING, status);
+  EXPECT_EQ(10u, context_.memory_controller().memory_usage());
+
+  BlobStatus construction_done = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+  handle->RunOnConstructionComplete(
+      base::Bind(&SaveBlobStatus, &construction_done));
+
+  context_.BreakAndFinishPendingBlob(kId,
+                                     BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT);
+  EXPECT_TRUE(handle->IsBroken());
+  EXPECT_EQ(0lu, context_.memory_controller().memory_usage());
+
+  // Check we're broken.
+  EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, handle->GetBlobStatus());
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, construction_done);
+}
+
+TEST_F(BlobStorageContextTest, BuildBlobFuzzy) {
+  scoped_refptr<BlobDataBuilder::DataHandle> disk_cache_data_handle =
+      new EmptyDataHandle();
+  const std::string kTestBlobData = "Test Blob Data";
+  const std::string kId("id");
+  const size_t kTotalRawBlobs = 200;
+  const size_t kTotalSlicedBlobs = 100;
+  SetTestMemoryLimits();
+  std::unique_ptr<disk_cache::Backend> cache = CreateInMemoryDiskCache();
+  ASSERT_TRUE(cache);
+  disk_cache::ScopedEntryPtr entry =
+      CreateDiskCacheEntry(cache.get(), "test entry", kTestBlobData);
+
+  // This tests mixed blob content, both async and synchronous content, and
+
+  std::vector<std::unique_ptr<BlobDataBuilder>> builders;
+  std::vector<size_t> sizes;
+
+  for (size_t i = 0; i < kTotalRawBlobs; i++) {
+    builders.emplace_back(new BlobDataBuilder(base::SizeTToString(i)));
+    auto& builder = *builders.back();
+    size_t size = 0;
+    if (i % 2 != 0) {
+      builder.AppendFutureData(5u);
+      size += 5u;
+      if (i % 3 == 1) {
+        builder.AppendData("abcdefghij", 4u);
+        size += 4u;
+      }
+      if (i % 3 == 0) {
+        builder.AppendFutureData(1u);
+        size += 1u;
+      }
+    } else if (i % 3 == 0) {
+      builder.AppendFutureFile(0lu, 3lu, "fileid");
+      size += 3u;
+    }
+    if (i % 5 != 0) {
+      builder.AppendFile(base::FilePath(base::SizeTToString(i)), 0ul, 20ul,
+                         base::Time::Max());
+      size += 20u;
+    }
+    builder.AppendDiskCacheEntry(disk_cache_data_handle, entry.get(),
+                                 kTestDiskCacheStreamIndex);
+    size += 14;
+    EXPECT_NE(0u, size);
+    sizes.push_back(size);
+  }
+
+  for (size_t i = 0; i < kTotalSlicedBlobs; i++) {
+    builders.emplace_back(
+        new BlobDataBuilder(base::SizeTToString(i + kTotalRawBlobs)));
+    size_t source_size = sizes[i];
+    size_t offset = sizes[i] == 1 ? 0 : i % (source_size - 1);
+    size_t size = (i % (source_size - offset)) + 1;
+    builders.back()->AppendBlob(base::SizeTToString(i), offset, size);
+    sizes.push_back(size);
+  }
+
+  size_t total_finished_blobs = 0;
+  std::vector<std::unique_ptr<BlobDataHandle>> handles;
+  std::vector<BlobStatus> statuses;
+  std::vector<bool> populated;
+  statuses.resize(kTotalRawBlobs,
+                  BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
+  populated.resize(kTotalRawBlobs, false);
+  context_.EnableDisk(temp_dir_, file_runner_);
+
+  for (size_t i = 0; i < builders.size(); i++) {
+    BlobDataBuilder& builder = *builders[i];
+    builder.set_content_type("text/plain");
+    bool has_pending_memory = i < kTotalRawBlobs && (i % 2 != 0 || i % 3 == 0);
+    std::unique_ptr<BlobDataHandle> handle = context_.BuildBlob(
+        builder,
+        has_pending_memory
+            ? base::Bind(&SaveBlobStatusAndFiles, &statuses[0] + i, &files_)
+            : BlobStorageContext::PopulatationAllowedCallback());
+    handle->RunOnConstructionComplete(
+        base::Bind(&IncrementPointer, &total_finished_blobs));
+    handles.push_back(std::move(handle));
+  }
+  base::RunLoop().RunUntilIdle();
+
+  // We should be needing to send a page or two to disk.
+  EXPECT_TRUE(file_runner_->HasPendingTask());
+
+  do {
+    file_runner_->RunPendingTasks();
+    base::RunLoop().RunUntilIdle();
+
+    // Continue populating data for items that can fit.
+    for (size_t i = 0; i < kTotalRawBlobs; i++) {
+      auto& builder = *builders[i];
+      bool has_pending_memory = (i % 2 != 0 || i % 3 == 0);
+      if (has_pending_memory && !populated[i] &&
+          statuses[i] == BlobStatus::PENDING) {
+        if (i % 2 != 0) {
+          builder.PopulateFutureData(0, "abcde", 0, 5);
+          if (i % 3 == 0) {
+            builder.PopulateFutureData(1, "z", 0, 1);
+          }
+        } else if (i % 3 == 0) {
+          scoped_refptr<ShareableFileReference> file_ref =
+              ShareableFileReference::GetOrCreate(
+                  base::FilePath(base::SizeTToString(i + kTotalRawBlobs)),
+                  ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE,
+                  file_runner_.get());
+          builder.PopulateFutureFile(0, file_ref, base::Time::Max());
+        }
+        context_.FinishedPopulatingPendingBlob(base::SizeTToString(i));
+        populated[i] = true;
+      }
+    }
+    base::RunLoop().RunUntilIdle();
+  } while (file_runner_->HasPendingTask());
+
+  for (size_t i = 0; i < populated.size(); i++) {
+    bool has_pending_memory = (i % 2 != 0 || i % 3 == 0);
+    if (has_pending_memory)
+      EXPECT_TRUE(populated[i]) << i;
+  }
+
+  // We should be completely built now.
+  EXPECT_EQ(kTotalRawBlobs + kTotalSlicedBlobs, total_finished_blobs);
+
+  handles.clear();
+  base::RunLoop().RunUntilIdle();
+  files_.clear();
+  // We should have file cleanup tasks.
+  EXPECT_TRUE(file_runner_->HasPendingTask());
+  file_runner_->RunPendingTasks();
+  base::RunLoop().RunUntilIdle();
+
+  for (size_t i = 0; i < kTotalRawBlobs; i++) {
+    bool has_pending_memory = (i % 2 != 0 || i % 3 == 0);
+    if (has_pending_memory)
+      EXPECT_EQ(BlobStatus::PENDING, statuses[i]) << i;
+  }
+  EXPECT_EQ(0lu, context_.memory_controller().memory_usage());
+  EXPECT_EQ(0lu, context_.memory_controller().disk_usage());
+}
+
+TEST_F(BlobStorageContextTest, CancelledReference) {
+  const std::string kId1("id1");
+  const std::string kId2("id2");
+  const size_t kSize = 10u;
+  BlobStatus status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+
+  // Start our first blob.
+  BlobDataBuilder builder(kId1);
+  builder.AppendFutureData(kSize);
+  builder.set_content_type("text/plain");
+  EXPECT_EQ(0lu, context_.memory_controller().memory_usage());
+  std::unique_ptr<BlobDataHandle> handle = context_.BuildBlob(
+      builder, base::Bind(&SaveBlobStatusAndFiles, &status, &files_));
+  EXPECT_EQ(10lu, context_.memory_controller().memory_usage());
+  EXPECT_TRUE(handle->IsBeingBuilt());
+  EXPECT_EQ(BlobStatus::PENDING, status);
+
+  BlobStatus construction_done = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+  handle->RunOnConstructionComplete(
+      base::Bind(&SaveBlobStatus, &construction_done));
+
+  EXPECT_EQ(10u, context_.memory_controller().memory_usage());
+
+  // Create our second blob, which depends on the first.
+  BlobDataBuilder builder2(kId2);
+  builder2.AppendBlob(kId1);
+  builder2.set_content_type("text/plain");
+  std::unique_ptr<BlobDataHandle> handle2 = context_.BuildBlob(
+      builder2, BlobStorageContext::PopulatationAllowedCallback());
+  BlobStatus construction_done2 =
+      BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+  handle->RunOnConstructionComplete(
+      base::Bind(&SaveBlobStatus, &construction_done2));
+  EXPECT_TRUE(handle2->IsBeingBuilt());
+
+  EXPECT_EQ(10lu, context_.memory_controller().memory_usage());
+
+  // Cancel the first blob.
+  context_.BreakAndFinishPendingBlob(kId1,
+                                     BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT);
+
+  base::RunLoop().RunUntilIdle();
+  // Check we broke successfully.
+  EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, construction_done);
+  EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, handle->GetBlobStatus());
+  EXPECT_EQ(0lu, context_.memory_controller().memory_usage());
+  EXPECT_TRUE(handle->IsBroken());
+
+  // Check that it propagated.
+  EXPECT_TRUE(handle2->IsBroken());
+  EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, construction_done2);
+  EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, handle->GetBlobStatus());
+}
+
+TEST_F(BlobStorageContextTest, IncorrectSlice) {
+  const std::string kId1("id1");
+  const std::string kId2("id2");
+
+  std::unique_ptr<BlobDataHandle> handle = SetupBasicBlob(kId1);
+
+  EXPECT_EQ(1lu, context_.memory_controller().memory_usage());
+
+  BlobDataBuilder builder(kId2);
+  builder.AppendBlob(kId1, 1, 10);
+  std::unique_ptr<BlobDataHandle> handle2 = context_.BuildBlob(
+      builder, BlobStorageContext::PopulatationAllowedCallback());
+
+  EXPECT_TRUE(handle2->IsBroken());
+  EXPECT_EQ(BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS,
+            handle2->GetBlobStatus());
+}
+
 TEST_F(BlobStorageContextTest, IncrementDecrementRef) {
-  base::MessageLoop fake_io_message_loop;
-
   // Build up a basic blob.
   const std::string kId("id");
   std::unique_ptr<BlobDataHandle> blob_data_handle = SetupBasicBlob(kId);
 
   // Do an extra increment to keep it around after we kill the handle.
-  context_.IncrementBlobRefCount(kId);
-  context_.IncrementBlobRefCount(kId);
-  context_.DecrementBlobRefCount(kId);
+  IncrementRefCount(kId);
+  IncrementRefCount(kId);
+  DecrementRefCount(kId);
   blob_data_handle = context_.GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle);
   blob_data_handle.reset();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(context_.registry().HasEntry(kId));
-  context_.DecrementBlobRefCount(kId);
+  DecrementRefCount(kId);
   EXPECT_FALSE(context_.registry().HasEntry(kId));
 
   // Make sure it goes away in the end.
   blob_data_handle = context_.GetBlobDataFromUUID(kId);
   EXPECT_FALSE(blob_data_handle);
 }
 
-TEST_F(BlobStorageContextTest, OnCancelBuildingBlob) {
-  base::MessageLoop fake_io_message_loop;
-
-  // Build up a basic blob.
-  const std::string kId("id");
-  context_.CreatePendingBlob(kId, std::string(kContentType),
-                             std::string(kContentDisposition));
-  EXPECT_TRUE(context_.IsBeingBuilt(kId));
-  context_.CancelPendingBlob(kId, IPCBlobCreationCancelCode::OUT_OF_MEMORY);
-  EXPECT_TRUE(context_.registry().HasEntry(kId));
-  EXPECT_FALSE(context_.IsBeingBuilt(kId));
-  EXPECT_TRUE(context_.IsBroken(kId));
-}
-
 TEST_F(BlobStorageContextTest, BlobDataHandle) {
-  base::MessageLoop fake_io_message_loop;
-
   // Build up a basic blob.
   const std::string kId("id");
   std::unique_ptr<BlobDataHandle> blob_data_handle = SetupBasicBlob(kId);
   EXPECT_TRUE(blob_data_handle);
 
   // Get 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();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(context_.registry().HasEntry(kId));
 
   another_handle.reset();
   base::RunLoop().RunUntilIdle();
 
   blob_data_handle = context_.GetBlobDataFromUUID(kId);
   EXPECT_FALSE(blob_data_handle);
 }
 
 TEST_F(BlobStorageContextTest, MemoryUsage) {
   const std::string kId1("id1");
   const std::string kId2("id2");
 
-  base::MessageLoop fake_io_message_loop;
-
   BlobDataBuilder builder1(kId1);
   BlobDataBuilder builder2(kId2);
   builder1.AppendData("Data1Data2");
   builder2.AppendBlob(kId1);
   builder2.AppendBlob(kId1);
   builder2.AppendBlob(kId1);
   builder2.AppendBlob(kId1);
   builder2.AppendBlob(kId1);
   builder2.AppendBlob(kId1);
   builder2.AppendBlob(kId1);
 
-  EXPECT_EQ(0lu, context_.memory_usage());
+  EXPECT_EQ(0lu, context_.memory_controller().memory_usage());
 
   std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_.AddFinishedBlob(&builder1);
-  EXPECT_EQ(10lu, context_.memory_usage());
+  EXPECT_EQ(10lu, context_.memory_controller().memory_usage());
   std::unique_ptr<BlobDataHandle> blob_data_handle2 =
       context_.AddFinishedBlob(&builder2);
-  EXPECT_EQ(10lu, context_.memory_usage());
+  EXPECT_EQ(10lu, context_.memory_controller().memory_usage());
 
   EXPECT_EQ(2u, context_.registry().blob_count());
 
   blob_data_handle.reset();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(10lu, context_.memory_usage());
+  EXPECT_EQ(10lu, context_.memory_controller().memory_usage());
   EXPECT_EQ(1u, context_.registry().blob_count());
   blob_data_handle2.reset();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(0lu, context_.memory_usage());
+  EXPECT_EQ(0lu, context_.memory_controller().memory_usage());
   EXPECT_EQ(0u, context_.registry().blob_count());
 }
 
 TEST_F(BlobStorageContextTest, AddFinishedBlob) {
   const std::string kId1("id1");
   const std::string kId2("id12");
   const std::string kId2Prime("id2.prime");
   const std::string kId3("id3");
   const std::string kId3Prime("id3.prime");
 
-  base::MessageLoop fake_io_message_loop;
-
   BlobDataBuilder builder1(kId1);
   BlobDataBuilder builder2(kId2);
   BlobDataBuilder canonicalized_blob_data2(kId2Prime);
   builder1.AppendData("Data1Data2");
   builder2.AppendBlob(kId1, 5, 5);
   builder2.AppendData(" is the best");
   canonicalized_blob_data2.AppendData("Data2");
   canonicalized_blob_data2.AppendData(" is the best");
 
   BlobStorageContext context;
 
   std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_.AddFinishedBlob(&builder1);
   std::unique_ptr<BlobDataHandle> blob_data_handle2 =
       context_.AddFinishedBlob(&builder2);
 
+  EXPECT_EQ(10u + 12u + 5u, context_.memory_controller().memory_usage());
+
   ASSERT_TRUE(blob_data_handle);
   ASSERT_TRUE(blob_data_handle2);
   std::unique_ptr<BlobDataSnapshot> data1 = blob_data_handle->CreateSnapshot();
   std::unique_ptr<BlobDataSnapshot> data2 = blob_data_handle2->CreateSnapshot();
   EXPECT_EQ(*data1, builder1);
   EXPECT_EQ(*data2, canonicalized_blob_data2);
   blob_data_handle.reset();
   data2.reset();
 
   base::RunLoop().RunUntilIdle();
 
+  EXPECT_EQ(12u + 5u, context_.memory_controller().memory_usage());
+
   blob_data_handle = context_.GetBlobDataFromUUID(kId1);
   EXPECT_FALSE(blob_data_handle);
   EXPECT_TRUE(blob_data_handle2);
   data2 = blob_data_handle2->CreateSnapshot();
   EXPECT_EQ(*data2, canonicalized_blob_data2);
 
   // Test shared elements stick around.
   BlobDataBuilder builder3(kId3);
   builder3.AppendBlob(kId2);
   builder3.AppendBlob(kId2);
   std::unique_ptr<BlobDataHandle> blob_data_handle3 =
       context_.AddFinishedBlob(&builder3);
   blob_data_handle2.reset();
   base::RunLoop().RunUntilIdle();
 
+  EXPECT_EQ(12u + 5u, context_.memory_controller().memory_usage());
+
   blob_data_handle2 = context_.GetBlobDataFromUUID(kId2);
   EXPECT_FALSE(blob_data_handle2);
   EXPECT_TRUE(blob_data_handle3);
   std::unique_ptr<BlobDataSnapshot> data3 = blob_data_handle3->CreateSnapshot();
 
   BlobDataBuilder canonicalized_blob_data3(kId3Prime);
   canonicalized_blob_data3.AppendData("Data2");
   canonicalized_blob_data3.AppendData(" is the best");
   canonicalized_blob_data3.AppendData("Data2");
   canonicalized_blob_data3.AppendData(" is the best");
   EXPECT_EQ(*data3, canonicalized_blob_data3);
 
   blob_data_handle.reset();
   blob_data_handle2.reset();
   blob_data_handle3.reset();
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(BlobStorageContextTest, AddFinishedBlob_LargeOffset) {
   // A value which does not fit in a 4-byte data type. Used to confirm that
   // large values are supported on 32-bit Chromium builds. Regression test for:
   // crbug.com/458122.
-  const uint64_t kLargeSize = std::numeric_limits<uint64_t>::max();
+  const uint64_t kLargeSize = std::numeric_limits<uint64_t>::max() - 1;
 
   const uint64_t kBlobLength = 5;
   const std::string kId1("id1");
   const std::string kId2("id2");
-  base::MessageLoop fake_io_message_loop;
 
   BlobDataBuilder builder1(kId1);
   builder1.AppendFileSystemFile(GURL(), 0, kLargeSize, base::Time::Now());
 
   BlobDataBuilder builder2(kId2);
   builder2.AppendBlob(kId1, kLargeSize - kBlobLength, kBlobLength);
 
   std::unique_ptr<BlobDataHandle> blob_data_handle1 =
       context_.AddFinishedBlob(&builder1);
   std::unique_ptr<BlobDataHandle> blob_data_handle2 =
       context_.AddFinishedBlob(&builder2);
 
   ASSERT_TRUE(blob_data_handle1);
   ASSERT_TRUE(blob_data_handle2);
   std::unique_ptr<BlobDataSnapshot> data = blob_data_handle2->CreateSnapshot();
   ASSERT_EQ(1u, data->items().size());
   const scoped_refptr<BlobDataItem> item = data->items()[0];
   EXPECT_EQ(kLargeSize - kBlobLength, item->offset());
   EXPECT_EQ(kBlobLength, item->length());
 
   blob_data_handle1.reset();
   blob_data_handle2.reset();
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(BlobStorageContextTest, BuildDiskCacheBlob) {
-  base::MessageLoop fake_io_message_loop;
   scoped_refptr<BlobDataBuilder::DataHandle>
       data_handle = new EmptyDataHandle();
 
   {
     BlobStorageContext context;
 
     std::unique_ptr<disk_cache::Backend> cache = CreateInMemoryDiskCache();
     ASSERT_TRUE(cache);
 
     const std::string kTestBlobData = "Test Blob Data";
@@ skipping 21 matching lines @@
       << "Data handle was not destructed along with blob storage context.";
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(BlobStorageContextTest, CompoundBlobs) {
   const std::string kId1("id1");
   const std::string kId2("id2");
   const std::string kId3("id3");
   const std::string kId2Prime("id2.prime");
 
-  base::MessageLoop fake_io_message_loop;
-
   // Setup a set of blob data for testing.
   base::Time time1, time2;
   base::Time::FromString("Tue, 15 Nov 1994, 12:45:26 GMT", &time1);
   base::Time::FromString("Mon, 14 Nov 1994, 11:30:49 GMT", &time2);
 
   BlobDataBuilder blob_data1(kId1);
   blob_data1.AppendData("Data1");
   blob_data1.AppendData("Data2");
   blob_data1.AppendFile(base::FilePath(FILE_PATH_LITERAL("File1.txt")), 10,
                         1024, time1);
@@ skipping 43 matching lines @@
   blob_data_handle = context_.AddFinishedBlob(&blob_data3);
   data = blob_data_handle->CreateSnapshot();
   ASSERT_TRUE(blob_data_handle);
   EXPECT_EQ(*data, blob_data3);
 
   blob_data_handle.reset();
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(BlobStorageContextTest, PublicBlobUrls) {
-  base::MessageLoop fake_io_message_loop;
-
   // Build up a basic blob.
   const std::string kId("id");
   std::unique_ptr<BlobDataHandle> first_handle = SetupBasicBlob(kId);
 
   // Now register a url for that blob.
   GURL kUrl("blob:id");
   context_.RegisterPublicBlobURL(kUrl, kId);
   std::unique_ptr<BlobDataHandle> blob_data_handle =
       context_.GetBlobDataFromPublicURL(kUrl);
   ASSERT_TRUE(blob_data_handle.get());
   EXPECT_EQ(kId, blob_data_handle->uuid());
   std::unique_ptr<BlobDataSnapshot> data = blob_data_handle->CreateSnapshot();
   blob_data_handle.reset();
   first_handle.reset();
   base::RunLoop().RunUntilIdle();
 
   // The url registration should keep the blob alive even after
   // explicit references are dropped.
   blob_data_handle = context_.GetBlobDataFromPublicURL(kUrl);
   EXPECT_TRUE(blob_data_handle);
   blob_data_handle.reset();
+
   base::RunLoop().RunUntilIdle();
-
   // Finally get rid of the url registration and the blob.
   context_.RevokePublicBlobURL(kUrl);
   blob_data_handle = context_.GetBlobDataFromPublicURL(kUrl);
   EXPECT_FALSE(blob_data_handle.get());
   EXPECT_FALSE(context_.registry().HasEntry(kId));
 }
 
 TEST_F(BlobStorageContextTest, TestUnknownBrokenAndBuildingBlobReference) {
-  base::MessageLoop fake_io_message_loop;
   const std::string kBrokenId("broken_id");
   const std::string kBuildingId("building_id");
   const std::string kReferencingId("referencing_id");
   const std::string kUnknownId("unknown_id");
 
-  // Create a broken blob and a building blob.
-  context_.CreatePendingBlob(kBuildingId, "", "");
-  context_.CreatePendingBlob(kBrokenId, "", "");
-  context_.CancelPendingBlob(kBrokenId, IPCBlobCreationCancelCode::UNKNOWN);
-  EXPECT_TRUE(context_.IsBroken(kBrokenId));
+  // Create a broken blob.
+  std::unique_ptr<BlobDataHandle> broken_handle =
+      context_.AddBrokenBlob(kBrokenId, "", "", BlobStatus::ERR_OUT_OF_MEMORY);
+  EXPECT_TRUE(broken_handle->GetBlobStatus() == BlobStatus::ERR_OUT_OF_MEMORY);
   EXPECT_TRUE(context_.registry().HasEntry(kBrokenId));
 
   // Try to create a blob with a reference to an unknown blob.
   BlobDataBuilder builder(kReferencingId);
   builder.AppendData("data");
   builder.AppendBlob(kUnknownId);
   std::unique_ptr<BlobDataHandle> handle = context_.AddFinishedBlob(builder);
   EXPECT_TRUE(handle->IsBroken());
   EXPECT_TRUE(context_.registry().HasEntry(kReferencingId));
   handle.reset();
@@ skipping 19 matching lines @@
   EXPECT_TRUE(handle->IsBroken());
   EXPECT_TRUE(context_.registry().HasEntry(kReferencingId));
   handle.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(context_.registry().HasEntry(kReferencingId));
 }
 
 // TODO(michaeln): tests for the depcrecated url stuff
 
 }  // namespace content