[BlobAsync] Asynchronous Blob Construction Final Patch

content/browser/fileapi/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 <limits>
 #include <string>
 
 #include "base/files/file_path.h"
@@ skipping 54 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.Pass();
 }
 
-void SetupBasicBlob(BlobStorageHost* host, const std::string& id) {
-  EXPECT_TRUE(host->StartBuildingBlob(id));
-  DataElement item;
-  item.SetToBytes("1", 1);
-  EXPECT_TRUE(host->AppendBlobDataItem(id, item));
-  EXPECT_TRUE(host->FinishBuildingBlob(id, "text/plain"));
-  EXPECT_FALSE(host->StartBuildingBlob(id));
-}
 
 }  // namespace
 
-TEST(BlobStorageContextTest, IncrementDecrementRef) {
+class BlobStorageContextTest : public testing::Test {
+ protected:
+  BlobStorageContextTest()
+      : done_called_(false),
+        cancel_called_(false),
+        cancel_code_(storage::IPCBlobCreationCancelCode::UNKNOWN),
+        request_called_(false) {}
+  ~BlobStorageContextTest() override {}
+
+  // Callback Methods and Getters
+  base::Callback<void(storage::IPCBlobCreationCancelCode)> GetCancelCallback() {
+    cancel_called_ = false;
+    return base::Bind(&BlobStorageContextTest::CancelCallback,
+                      base::Unretained(this));
+  }
+
+  void CancelCallback(storage::IPCBlobCreationCancelCode code) {
+    cancel_called_ = true;
+    cancel_code_ = code;
+  }
+
+  base::Closure GetDoneCallback() {
+    done_called_ = false;
+    return base::Bind(&BlobStorageContextTest::DoneCallback,
+                      base::Unretained(this));
+  }
+
+  void DoneCallback() { done_called_ = true; }
+
+  base::Callback<void(const std::vector<storage::BlobItemBytesRequest>&,
+                      const std::vector<base::SharedMemoryHandle>&,
+                      const std::vector<IPC::PlatformFileForTransit>&)>
+  GetRequestCallback() {
+    request_called_ = false;
+    return base::Bind(&BlobStorageContextTest::RequestMemoryCallback,
+                      base::Unretained(this));
+  }
+
+  void RequestMemoryCallback(const std::vector<storage::BlobItemBytesRequest>&,
+                             const std::vector<base::SharedMemoryHandle>&,
+                             const std::vector<IPC::PlatformFileForTransit>&) {
+    request_called_ = true;
+  }
+
+  // Helper call to create basic blob.
+  void SetupBasicBlob(BlobStorageHost* host,
+                      BlobStorageContext* context,
+                      const std::string& id) {
+    EXPECT_FALSE(context->MaybeStartAsyncBlobTransfer(id));
+    EXPECT_TRUE(host->RegisterBlobUUID(id));
+    EXPECT_TRUE(context->MaybeStartAsyncBlobTransfer(id));
+    BlobDataBuilder builder(id);
+    builder.AppendData("1", 1);
+    builder.set_content_type("text/plain");
+    context->FinishAsyncBlobTransfer(GetDoneCallback(), GetCancelCallback(),
+                                     builder);
+    EXPECT_TRUE(done_called_);
+    EXPECT_FALSE(cancel_called_);
+    EXPECT_FALSE(host->RegisterBlobUUID(id));
+  }
+
+  // Delegating methods
+  bool MaybeStartAsyncBlobTransfer(BlobStorageContext* context,
+                                   const std::string& uuid) {
+    return context->MaybeStartAsyncBlobTransfer(uuid);
+  }
+
+  void FinishAsyncBlobTransfer(BlobStorageContext* context,
+                               const storage::BlobDataBuilder& builder) {
+    context->FinishAsyncBlobTransfer(GetDoneCallback(), GetCancelCallback(),
+                                     builder);
+  }
+
+  void AsyncBlobTransfer(BlobStorageHost* host, const std::string& uuid) {
+    DataElement e;
+    e.SetToBytes("1", 1);
+    std::vector<storage::DataElement> elements = {e};
+    host->StartBuildingBlob(uuid, "text/plain", elements, GetRequestCallback(),
+                            GetDoneCallback(), GetCancelCallback());
+  }
+
+  bool done_called_;
+  bool cancel_called_;
+  storage::IPCBlobCreationCancelCode cancel_code_;
+  bool request_called_;
+};
+
+TEST_F(BlobStorageContextTest, IncrementDecrementRef) {
   BlobStorageContext context;
   BlobStorageHost host(&context);
   base::MessageLoop fake_io_message_loop;
 
   // Build up a basic blob.
   const std::string kId("id");
-  SetupBasicBlob(&host, kId);
+  SetupBasicBlob(&host, &context, kId);
 
   // Make sure it's there, finish building implies a ref of one.
   scoped_ptr<BlobDataHandle> blob_data_handle;
   blob_data_handle = context.GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle);
   blob_data_handle.reset();
   base::RunLoop().RunUntilIdle();
 
   // Make sure its still there after inc/dec.
   EXPECT_TRUE(host.IncrementBlobRefCount(kId));
   EXPECT_TRUE(host.DecrementBlobRefCount(kId));
   blob_data_handle = context.GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle);
   blob_data_handle.reset();
   base::RunLoop().RunUntilIdle();
 
   // Make sure it goes away in the end.
   EXPECT_TRUE(host.DecrementBlobRefCount(kId));
   blob_data_handle = context.GetBlobDataFromUUID(kId);
   EXPECT_FALSE(blob_data_handle);
   EXPECT_FALSE(host.DecrementBlobRefCount(kId));
   EXPECT_FALSE(host.IncrementBlobRefCount(kId));
 }
 
-TEST(BlobStorageContextTest, CancelBuildingBlob) {
+TEST_F(BlobStorageContextTest, CancelBuildingBlob) {
   BlobStorageContext context;
   BlobStorageHost host(&context);
   base::MessageLoop fake_io_message_loop;
 
   // Build up a basic blob.
   const std::string kId("id");
-  EXPECT_TRUE(host.StartBuildingBlob(kId));
-  DataElement item;
-  item.SetToBytes("1", 1);
-  EXPECT_TRUE(host.AppendBlobDataItem(kId, item));
+  EXPECT_FALSE(host.CancelBuildingBlob(kId));
+  EXPECT_TRUE(host.RegisterBlobUUID(kId));
+  EXPECT_TRUE(MaybeStartAsyncBlobTransfer(&context, kId));
   EXPECT_TRUE(host.CancelBuildingBlob(kId));
-  EXPECT_FALSE(host.FinishBuildingBlob(kId, "text/plain"));
-  EXPECT_TRUE(host.StartBuildingBlob(kId));
+
+  BlobDataBuilder builder(kId);
+  builder.AppendData("1", 1);
+  builder.set_content_type("text/plain");
+  FinishAsyncBlobTransfer(&context, builder);
+  EXPECT_FALSE(done_called_);
+  EXPECT_TRUE(cancel_called_);
+
+  EXPECT_TRUE(host.RegisterBlobUUID(kId));
 }
 
-TEST(BlobStorageContextTest, BlobDataHandle) {
+TEST_F(BlobStorageContextTest, BlobDataHandle) {
   BlobStorageContext context;
   BlobStorageHost host(&context);
   base::MessageLoop fake_io_message_loop;
 
   // Build up a basic blob.
   const std::string kId("id");
-  SetupBasicBlob(&host, kId);
+  SetupBasicBlob(&host, &context, kId);
 
   // Get a handle to it.
   scoped_ptr<BlobDataHandle> blob_data_handle =
       context.GetBlobDataFromUUID(kId);
   EXPECT_TRUE(blob_data_handle);
 
   // Drop the host's ref to it.
   EXPECT_TRUE(host.DecrementBlobRefCount(kId));
 
   // 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();
 
   blob_data_handle = context.GetBlobDataFromUUID(kId);
   EXPECT_FALSE(blob_data_handle);
 }
 
-TEST(BlobStorageContextTest, MemoryUsage) {
+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);
 
   BlobStorageContext context;
   EXPECT_EQ(0lu, context.memory_usage());
 
   scoped_ptr<BlobDataHandle> blob_data_handle =
       context.AddFinishedBlob(&builder1);
   EXPECT_EQ(10lu, context.memory_usage());
   scoped_ptr<BlobDataHandle> blob_data_handle2 =
       context.AddFinishedBlob(&builder2);
   EXPECT_EQ(10lu, context.memory_usage());
 
+  EXPECT_EQ(2u, context.registry().blob_count());
+
   blob_data_handle.reset();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(10lu, context.memory_usage());
+  EXPECT_EQ(1u, context.registry().blob_count());
   blob_data_handle2.reset();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0lu, context.memory_usage());
+  EXPECT_EQ(0u, context.registry().blob_count());
 }
 
-TEST(BlobStorageContextTest, AddFinishedBlob) {
+TEST_F(BlobStorageContextTest, AsyncPipeline) {
+  BlobStorageContext context;
+  BlobStorageHost host(&context);
+
+  // Build up a basic blob.
+  const std::string kId("id");
+  EXPECT_FALSE(MaybeStartAsyncBlobTransfer(&context, kId));
+  AsyncBlobTransfer(&host, kId);
+  EXPECT_TRUE(cancel_called_);
+  EXPECT_FALSE(done_called_);
+
+  EXPECT_TRUE(host.RegisterBlobUUID(kId));
+  AsyncBlobTransfer(&host, kId);
+  EXPECT_TRUE(done_called_);
+  EXPECT_FALSE(cancel_called_);
+  // We assume that it uses the shortcut method, and immediately returns.
+  EXPECT_FALSE(request_called_);
+
+  EXPECT_EQ(1u, 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);
@@ skipping 48 matching lines @@
   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(BlobStorageContextTest, AddFinishedBlob_LargeOffset) {
+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 kBlobLength = 5;
   const std::string kId1("id1");
   const std::string kId2("id2");
   base::MessageLoop fake_io_message_loop;
 
@@ skipping 15 matching lines @@
   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(BlobStorageContextTest, BuildDiskCacheBlob) {
+TEST_F(BlobStorageContextTest, BuildDiskCacheBlob) {
   base::MessageLoop fake_io_message_loop;
   scoped_refptr<BlobDataBuilder::DataHandle>
       data_handle = new EmptyDataHandle();
 
   {
     scoped_ptr<BlobStorageContext> context(new BlobStorageContext);
     BlobStorageHost host(context.get());
 
     scoped_ptr<disk_cache::Backend> cache = CreateInMemoryDiskCache();
     ASSERT_TRUE(cache);
@@ skipping 17 matching lines @@
     scoped_ptr<BlobDataSnapshot> data = blob_data_handle->CreateSnapshot();
     EXPECT_EQ(*data, builder);
     EXPECT_FALSE(data_handle->HasOneRef())
         << "Data handle was destructed while context and builder still exist.";
   }
   EXPECT_TRUE(data_handle->HasOneRef())
       << "Data handle was not destructed along with blob storage context.";
   base::RunLoop().RunUntilIdle();
 }
 
-TEST(BlobStorageContextTest, CompoundBlobs) {
+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);
@@ skipping 49 matching lines @@
   // Test a blob referring to only data and a disk cache entry.
   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(BlobStorageContextTest, PublicBlobUrls) {
+TEST_F(BlobStorageContextTest, PublicBlobUrls) {
   BlobStorageContext context;
   BlobStorageHost host(&context);
   base::MessageLoop fake_io_message_loop;
 
   // Build up a basic blob.
   const std::string kId("id");
-  SetupBasicBlob(&host, kId);
+  SetupBasicBlob(&host, &context, kId);
 
   // Now register a url for that blob.
   GURL kUrl("blob:id");
   EXPECT_TRUE(host.RegisterPublicBlobURL(kUrl, kId));
   scoped_ptr<BlobDataHandle> blob_data_handle =
       context.GetBlobDataFromPublicURL(kUrl);
   ASSERT_TRUE(blob_data_handle.get());
   EXPECT_EQ(kId, blob_data_handle->uuid());
   scoped_ptr<BlobDataSnapshot> data = blob_data_handle->CreateSnapshot();
   blob_data_handle.reset();
   base::RunLoop().RunUntilIdle();
 
   // The url registration should keep the blob alive even after
   // explicit references are dropped.
   EXPECT_TRUE(host.DecrementBlobRefCount(kId));
   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.
   EXPECT_TRUE(host.RevokePublicBlobURL(kUrl));
   blob_data_handle = context.GetBlobDataFromPublicURL(kUrl);
   EXPECT_TRUE(!blob_data_handle.get());
   EXPECT_FALSE(host.RevokePublicBlobURL(kUrl));
 }
 
-TEST(BlobStorageContextTest, HostCleanup) {
+TEST_F(BlobStorageContextTest, HostCleanup) {
   BlobStorageContext context;
   scoped_ptr<BlobStorageHost> host(new BlobStorageHost(&context));
   base::MessageLoop fake_io_message_loop;
 
   // Build up a basic blob and register a url
   const std::string kId("id");
   GURL kUrl("blob:id");
-  SetupBasicBlob(host.get(), kId);
+  SetupBasicBlob(host.get(), &context, kId);
   EXPECT_TRUE(host->RegisterPublicBlobURL(kUrl, kId));
 
   // All should disappear upon host deletion.
   host.reset();
   scoped_ptr<BlobDataHandle> handle = context.GetBlobDataFromPublicURL(kUrl);
   EXPECT_TRUE(!handle.get());
   handle = context.GetBlobDataFromUUID(kId);
   EXPECT_TRUE(!handle.get());
 }
 
-TEST(BlobStorageContextTest, EarlyContextDeletion) {
+TEST_F(BlobStorageContextTest, EarlyContextDeletion) {
   scoped_ptr<BlobStorageContext> context(new BlobStorageContext);
   BlobStorageHost host(context.get());
   base::MessageLoop fake_io_message_loop;
 
   // Deleting the context should not induce crashes.
   context.reset();
 
   const std::string kId("id");
   GURL kUrl("blob:id");
-  EXPECT_FALSE(host.StartBuildingBlob(kId));
+  EXPECT_FALSE(host.RegisterBlobUUID(kId));
   DataElement item;
   item.SetToBytes("1", 1);
-  EXPECT_FALSE(host.AppendBlobDataItem(kId, item));
-  EXPECT_FALSE(host.FinishBuildingBlob(kId, "text/plain"));
+  EXPECT_FALSE(host.CancelBuildingBlob(kId));
+  AsyncBlobTransfer(&host, kId);
+  EXPECT_FALSE(request_called_);
+  EXPECT_FALSE(done_called_);
+  EXPECT_TRUE(cancel_called_);
   EXPECT_FALSE(host.RegisterPublicBlobURL(kUrl, kId));
   EXPECT_FALSE(host.IncrementBlobRefCount(kId));
   EXPECT_FALSE(host.DecrementBlobRefCount(kId));
   EXPECT_FALSE(host.RevokePublicBlobURL(kUrl));
 }
 
 // TODO(michaeln): tests for the depcrecated url stuff
 
 }  // namespace content