Create blobs from Disk Cache entries.

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"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "content/browser/fileapi/blob_storage_host.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_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 "testing/gtest/include/gtest/gtest.h"
 
 using storage::BlobDataBuilder;
 using storage::BlobDataHandle;
 using storage::BlobDataItem;
 using storage::BlobDataSnapshot;
 using storage::BlobStorageContext;
 using storage::DataElement;
 
 namespace content {
 namespace {
 
+const int kTestDiskCacheStreamIndex = 0;
+
+// 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 {}
+};
+
+scoped_ptr<disk_cache::Backend> CreateInMemoryDiskCache() {
+  scoped_ptr<disk_cache::Backend> cache;
+  net::TestCompletionCallback callback;
+  int rv = disk_cache::CreateCacheBackend(net::MEMORY_CACHE,
+                                          net::CACHE_BACKEND_DEFAULT,
+                                          base::FilePath(), 0,
+                                          false, nullptr, nullptr, &cache,
+                                          callback.callback());
+  EXPECT_EQ(net::OK, callback.GetResult(rv));
+
+  return cache.Pass();
+}
+
+disk_cache::ScopedEntryPtr CreateDiskCacheEntry(disk_cache::Backend* cache,
+                                                const char* key,
+                                                const std::string& data) {
+  disk_cache::Entry* temp_entry = nullptr;
+  net::TestCompletionCallback callback;
+  int rv = cache->CreateEntry(key, &temp_entry, callback.callback());
+  if (callback.GetResult(rv) != net::OK)
+    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
@@ skipping 212 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) {
+  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);
+
+    const std::string kTestBlobData = "Test Blob Data";
+    disk_cache::ScopedEntryPtr entry =
+        CreateDiskCacheEntry(cache.get(), "test entry", kTestBlobData);
+
+    const std::string kId1Prime("id1.prime");
+    BlobDataBuilder canonicalized_blob_data(kId1Prime);
+    canonicalized_blob_data.AppendData(kTestBlobData.c_str());
+
+    const std::string kId1("id1");
+    BlobDataBuilder builder(kId1);
+
+    builder.AppendDiskCacheEntry(
+        data_handle, entry.get(), kTestDiskCacheStreamIndex);
+
+    scoped_ptr<BlobDataHandle> blob_data_handle =
+        context->AddFinishedBlob(&builder);
+    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) {
   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);
 
   BlobDataBuilder blob_data2(kId2);
   blob_data2.AppendData("Data3");
   blob_data2.AppendBlob(kId1, 8, 100);
   blob_data2.AppendFile(base::FilePath(FILE_PATH_LITERAL("File2.txt")), 0, 20,
                         time2);
 
+  BlobDataBuilder blob_data3(kId3);
+  blob_data3.AppendData("Data4");
+  scoped_ptr<disk_cache::Backend> cache = CreateInMemoryDiskCache();
+  ASSERT_TRUE(cache);
+  disk_cache::ScopedEntryPtr disk_cache_entry =
+      CreateDiskCacheEntry(cache.get(), "another key", "Data5");
+  blob_data3.AppendDiskCacheEntry(new EmptyDataHandle(), disk_cache_entry.get(),
+                                  kTestDiskCacheStreamIndex);
+
   BlobDataBuilder canonicalized_blob_data2(kId2Prime);
   canonicalized_blob_data2.AppendData("Data3");
   canonicalized_blob_data2.AppendData("a2___", 2);
   canonicalized_blob_data2.AppendFile(
       base::FilePath(FILE_PATH_LITERAL("File1.txt")), 10, 98, time1);
   canonicalized_blob_data2.AppendFile(
       base::FilePath(FILE_PATH_LITERAL("File2.txt")), 0, 20, time2);
 
   BlobStorageContext context;
   scoped_ptr<BlobDataHandle> blob_data_handle;
 
   // Test a blob referring to only data and a file.
   blob_data_handle = context.AddFinishedBlob(&blob_data1);
 
   ASSERT_TRUE(blob_data_handle);
   scoped_ptr<BlobDataSnapshot> data = blob_data_handle->CreateSnapshot();
   ASSERT_TRUE(blob_data_handle);
   EXPECT_EQ(*data, blob_data1);
 
   // Test a blob composed in part with another blob.
   blob_data_handle = context.AddFinishedBlob(&blob_data2);
   data = blob_data_handle->CreateSnapshot();
   ASSERT_TRUE(blob_data_handle);
   ASSERT_TRUE(data);
   EXPECT_EQ(*data, canonicalized_blob_data2);
 
+  // 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) {
   BlobStorageContext context;
   BlobStorageHost host(&context);
   base::MessageLoop fake_io_message_loop;
 
   // Build up a basic blob.
@@ skipping 62 matching lines @@
   EXPECT_FALSE(host.FinishBuildingBlob(kId, "text/plain"));
   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