Create blobs from Disk Cache entries.

content/browser/fileapi/blob_url_request_job_unittest.cc

 // Copyright 2013 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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/browser/fileapi/mock_url_request_delegate.h"
 #include "content/public/test/async_file_test_helper.h"
 #include "content/public/test/test_file_system_context.h"
+#include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
+#include "net/base/test_completion_callback.h"
+#include "net/disk_cache/disk_cache.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
 #include "storage/browser/blob/blob_storage_context.h"
@@ skipping 11 matching lines @@
 
 namespace {
 
 const int kBufferSize = 1024;
 const char kTestData1[] = "Hello";
 const char kTestData2[] = "Here it is data.";
 const char kTestFileData1[] = "0123456789";
 const char kTestFileData2[] = "This is sample file.";
 const char kTestFileSystemFileData1[] = "abcdefghijklmnop";
 const char kTestFileSystemFileData2[] = "File system file test data.";
+const char kTestDiskCacheKey[] = "pipe";
+const char kTestDiskCacheData[] = "Ceci n'est pas un pamplemousse.";
 const char kTestContentType[] = "foo/bar";
 const char kTestContentDisposition[] = "attachment; filename=foo.txt";
 
 const char kFileSystemURLOrigin[] = "http://remote";
 const storage::FileSystemType kFileSystemType =
     storage::kFileSystemTypeTemporary;
 
+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, NULL, NULL, &cache,

[mmenke, 2015/06/18 20:49:05]

nit:  nullptr (x2)

[gavinp, 2015/06/18 22:52:50]

I found quite a few more of these. Thanks for the reminder.

I for the one wish to be among the first to welcome our new nullptr overlords.

+                                          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();
+}
+
 }  // namespace
 
 class BlobURLRequestJobTest : public testing::Test {
  public:
   // A simple ProtocolHandler implementation to create BlobURLRequestJob.
   class MockProtocolHandler :
       public net::URLRequestJobFactory::ProtocolHandler {
    public:
     MockProtocolHandler(BlobURLRequestJobTest* test) : test_(test) {}
 
@@ skipping 26 matching lines @@
     temp_file_modification_time1_ = file_info1.last_modified;
 
     temp_file2_ = temp_dir_.path().AppendASCII("BlobFile2.dat");
     ASSERT_EQ(static_cast<int>(arraysize(kTestFileData2) - 1),
               base::WriteFile(temp_file2_, kTestFileData2,
                                    arraysize(kTestFileData2) - 1));
     base::File::Info file_info2;
     base::GetFileInfo(temp_file2_, &file_info2);
     temp_file_modification_time2_ = file_info2.last_modified;
 
+    disk_cache_backend_ = CreateInMemoryDiskCache();
+    disk_cache_entry_ = CreateDiskCacheEntry(
+        disk_cache_backend_.get(), kTestDiskCacheKey, kTestDiskCacheData);
+
     url_request_job_factory_.SetProtocolHandler("blob",
                                                 new MockProtocolHandler(this));
     url_request_context_.set_job_factory(&url_request_job_factory_);
   }
 
   void TearDown() override {
     blob_handle_.reset();
     // Clean up for ASAN
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
@@ skipping 87 matching lines @@
 
     // Verify response.
     EXPECT_TRUE(request_->status().is_success());
     EXPECT_EQ(expected_status_code_,
               request_->response_headers()->response_code());
     EXPECT_EQ(expected_response_, url_request_delegate_.response_data());
   }
 
   void BuildComplicatedData(std::string* expected_result) {
     blob_data_->AppendData(kTestData1 + 1, 2);
+    *expected_result = std::string(kTestData1 + 1, 2);
+
     blob_data_->AppendFile(temp_file1_, 2, 3, temp_file_modification_time1_);
+    *expected_result += std::string(kTestFileData1 + 2, 3);
+
+    blob_data_->AppendDiskCacheEntry(new EmptyDataHandle(),
+                                     disk_cache_entry_.get(),
+                                     kTestDiskCacheStreamIndex);
+    *expected_result += std::string(kTestDiskCacheData);
+
     blob_data_->AppendFileSystemFile(temp_file_system_file1_, 3, 4,
                                      temp_file_system_file_modification_time1_);
+    *expected_result += std::string(kTestFileSystemFileData1 + 3, 4);
+
     blob_data_->AppendData(kTestData2 + 4, 5);
+    *expected_result += std::string(kTestData2 + 4, 5);
+
     blob_data_->AppendFile(temp_file2_, 5, 6, temp_file_modification_time2_);
+    *expected_result += std::string(kTestFileData2 + 5, 6);
+
     blob_data_->AppendFileSystemFile(temp_file_system_file2_, 6, 7,
                                      temp_file_system_file_modification_time2_);
-    *expected_result = std::string(kTestData1 + 1, 2);
-    *expected_result += std::string(kTestFileData1 + 2, 3);
-    *expected_result += std::string(kTestFileSystemFileData1 + 3, 4);
-    *expected_result += std::string(kTestData2 + 4, 5);
-    *expected_result += std::string(kTestFileData2 + 5, 6);
     *expected_result += std::string(kTestFileSystemFileData2 + 6, 7);
   }
 
   scoped_ptr<BlobDataSnapshot> GetSnapshotFromBuilder() {
     if (!blob_handle_) {
       blob_handle_ = blob_context_.AddFinishedBlob(blob_data_.get()).Pass();
     }
     return blob_handle_->CreateSnapshot().Pass();
   }
 
@@ skipping 16 matching lines @@
   base::FilePath temp_file1_;
   base::FilePath temp_file2_;
   base::Time temp_file_modification_time1_;
   base::Time temp_file_modification_time2_;
   GURL file_system_root_url_;
   GURL temp_file_system_file1_;
   GURL temp_file_system_file2_;
   base::Time temp_file_system_file_modification_time1_;
   base::Time temp_file_system_file_modification_time2_;
 
+  scoped_ptr<disk_cache::Backend> disk_cache_backend_;
+  disk_cache::ScopedEntryPtr disk_cache_entry_;
+
   base::MessageLoopForIO message_loop_;
   scoped_refptr<storage::FileSystemContext> file_system_context_;
 
   storage::BlobStorageContext blob_context_;
   scoped_ptr<storage::BlobDataHandle> blob_handle_;
   scoped_ptr<BlobDataBuilder> blob_data_;
   scoped_ptr<BlobDataSnapshot> blob_data_snapshot_;
   net::URLRequestJobFactoryImpl url_request_job_factory_;
   net::URLRequestContext url_request_context_;
   MockURLRequestDelegate url_request_delegate_;
@@ skipping 15 matching lines @@
 
 TEST_F(BlobURLRequestJobTest, TestGetLargeFileRequest) {
   base::FilePath large_temp_file =
       temp_dir_.path().AppendASCII("LargeBlob.dat");
   std::string large_data;
   large_data.reserve(kBufferSize * 5);
   for (int i = 0; i < kBufferSize * 5; ++i)
     large_data.append(1, static_cast<char>(i % 256));
   ASSERT_EQ(static_cast<int>(large_data.size()),
             base::WriteFile(large_temp_file, large_data.data(),
-                                 large_data.size()));
+                            large_data.size()));
   blob_data_->AppendFile(large_temp_file, 0, kuint64max, base::Time());
   TestSuccessNonrangeRequest(large_data, large_data.size());
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileRequest) {
   base::FilePath non_existent_file =
       temp_file1_.InsertBeforeExtension(FILE_PATH_LITERAL("-na"));
   blob_data_->AppendFile(non_existent_file, 0, kuint64max, base::Time());
   TestErrorRequest(404);
 }
@@ skipping 59 matching lines @@
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) {
   SetUpFileSystem();
   blob_data_->AppendFileSystemFile(temp_file_system_file1_, 2, 4,
                                   temp_file_system_file_modification_time1_);
   std::string result(kTestFileSystemFileData1 + 2, 4);
   TestSuccessNonrangeRequest(result, 4);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataAndFileRequest) {
+TEST_F(BlobURLRequestJobTest, TestGetSimpleDiskCacheRequest) {
+  blob_data_->AppendDiskCacheEntry(new EmptyDataHandle(),
+                                   disk_cache_entry_.get(),
+                                   kTestDiskCacheStreamIndex);
+  TestSuccessNonrangeRequest(kTestDiskCacheData,
+                             arraysize(kTestDiskCacheData) - 1);
+}
+
+TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataFileAndDiskCacheRequest) {
   SetUpFileSystem();
   std::string result;
   BuildComplicatedData(&result);
   TestSuccessNonrangeRequest(result, GetTotalBlobLength());
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest1) {
   SetUpFileSystem();
   std::string result;
   BuildComplicatedData(&result);
@@ skipping 48 matching lines @@
   EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type));
   EXPECT_EQ(kTestContentType, content_type);
   void* iter = NULL;
   std::string content_disposition;
   EXPECT_TRUE(request_->response_headers()->EnumerateHeader(
       &iter, "Content-Disposition", &content_disposition));
   EXPECT_EQ(kTestContentDisposition, content_disposition);
 }
 
 }  // namespace content