[Blob] BlobReader class & tests, and removal of all redundant reading.

content/browser/loader/upload_data_stream_builder_unittest.cc

Index: content/browser/loader/upload_data_stream_builder_unittest.cc
diff --git a/content/browser/loader/upload_data_stream_builder_unittest.cc b/content/browser/loader/upload_data_stream_builder_unittest.cc
index b3edd5d65843b69b80439896ecde6caf3feca5f3..e323a4e9e3118b644f8db438c1f33ea956e14279 100644
--- a/content/browser/loader/upload_data_stream_builder_unittest.cc
+++ b/content/browser/loader/upload_data_stream_builder_unittest.cc
@@ -18,11 +18,11 @@
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
-#include "net/base/upload_disk_cache_entry_element_reader.h"
 #include "net/base/upload_file_element_reader.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_storage_context.h"
+#include "storage/browser/blob/upload_blob_element_reader.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
@@ -31,351 +31,59 @@ using storage::BlobDataHandle;
 using storage::BlobStorageContext;
 
 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();
-}
-
-bool AreElementsEqual(const net::UploadElementReader& reader,
-                      const ResourceRequestBody::Element& element) {
-  switch(element.type()) {
-    case ResourceRequestBody::Element::TYPE_BYTES: {
-      const net::UploadBytesElementReader* bytes_reader =
-          reader.AsBytesReader();
-      return bytes_reader &&
-          element.length() == bytes_reader->length() &&
-          std::equal(element.bytes(), element.bytes() + element.length(),
-                     bytes_reader->bytes());
-    }
-    case ResourceRequestBody::Element::TYPE_FILE: {
-      const net::UploadFileElementReader* file_reader = reader.AsFileReader();
-      return file_reader &&
-          file_reader->path() == element.path() &&
-          file_reader->range_offset() == element.offset() &&
-          file_reader->range_length() == element.length() &&
-          file_reader->expected_modification_time() ==
-          element.expected_modification_time();
-      break;
-    }
-    case ResourceRequestBody::Element::TYPE_DISK_CACHE_ENTRY: {
-      // TODO(gavinp): Should we be comparing a higher level structure
-      // such as the BlobDataItem so that we can do stronger equality
-      // comparisons?
-      const net::UploadDiskCacheEntryElementReader* disk_cache_entry_reader =
-          reader.AsDiskCacheEntryReaderForTests();
-      return disk_cache_entry_reader &&
-          disk_cache_entry_reader->range_offset_for_tests() ==
-              static_cast<int>(element.offset()) &&
-          disk_cache_entry_reader->range_length_for_tests() ==
-              static_cast<int>(element.length());
-      break;
-    }
-    default:
-      NOTREACHED();
-  }
-  return false;
-}
-
-}  // namespace
-
-TEST(UploadDataStreamBuilderTest, CreateUploadDataStreamWithoutBlob) {
-  base::MessageLoop message_loop;
-  scoped_refptr<ResourceRequestBody> request_body = new ResourceRequestBody;
-
-  const char kData[] = "123";
-  const base::FilePath::StringType kFilePath = FILE_PATH_LITERAL("abc");
-  const uint64 kFileOffset = 10U;
-  const uint64 kFileLength = 100U;
-  const base::Time kFileTime = base::Time::FromDoubleT(999);
-  const int64 kIdentifier = 12345;
-
-  request_body->AppendBytes(kData, arraysize(kData) - 1);
-  request_body->AppendFileRange(base::FilePath(kFilePath),
-                                kFileOffset, kFileLength, kFileTime);
-  request_body->set_identifier(kIdentifier);
-
-  scoped_ptr<net::UploadDataStream> upload(UploadDataStreamBuilder::Build(
-      request_body.get(), NULL, NULL,
-      base::ThreadTaskRunnerHandle::Get().get()));
-
-  EXPECT_EQ(kIdentifier, upload->identifier());
-  ASSERT_TRUE(upload->GetElementReaders());
-  ASSERT_EQ(request_body->elements()->size(),
-            upload->GetElementReaders()->size());
-
-  const net::UploadBytesElementReader* r1 =
-      (*upload->GetElementReaders())[0]->AsBytesReader();
-  ASSERT_TRUE(r1);
-  EXPECT_EQ(kData, std::string(r1->bytes(), r1->length()));
-
-  const net::UploadFileElementReader* r2 =
-      (*upload->GetElementReaders())[1]->AsFileReader();
-  ASSERT_TRUE(r2);
-  EXPECT_EQ(kFilePath, r2->path().value());
-  EXPECT_EQ(kFileOffset, r2->range_offset());
-  EXPECT_EQ(kFileLength, r2->range_length());
-  EXPECT_EQ(kFileTime, r2->expected_modification_time());
-}
-
-TEST(UploadDataStreamBuilderTest, ResolveBlobAndCreateUploadDataStream) {
+TEST(UploadDataStreamBuilderTest, CreateUploadDataStream) {
   base::MessageLoop message_loop;
   {
-    // Setup 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);
-
-    BlobStorageContext blob_storage_context;
-
-    const std::string blob_id0("id-0");
-    scoped_ptr<BlobDataBuilder> blob_data_builder(
-        new BlobDataBuilder(blob_id0));
-    scoped_ptr<BlobDataHandle> handle1 =
-        blob_storage_context.AddFinishedBlob(blob_data_builder.get());
-
-    const std::string blob_id1("id-1");
-    const std::string kBlobData = "BlobData";
-    blob_data_builder.reset(new BlobDataBuilder(blob_id1));
-    blob_data_builder->AppendData(kBlobData);
-    blob_data_builder->AppendFile(
-        base::FilePath(FILE_PATH_LITERAL("BlobFile.txt")), 0, 20, time1);
-    scoped_ptr<BlobDataHandle> handle2 =
-        blob_storage_context.AddFinishedBlob(blob_data_builder.get());
-
-    const std::string blob_id2("id-2");
-    const std::string kDiskCacheData = "DiskCacheData";
-    scoped_ptr<disk_cache::Backend> disk_cache_backend =
-        CreateInMemoryDiskCache();
-    ASSERT_TRUE(disk_cache_backend);
-    disk_cache::ScopedEntryPtr disk_cache_entry =
-        CreateDiskCacheEntry(disk_cache_backend.get(), "a key", kDiskCacheData);
-    ASSERT_TRUE(disk_cache_entry);
-    blob_data_builder.reset(new BlobDataBuilder(blob_id2));
-    blob_data_builder->AppendDiskCacheEntry(
-        new EmptyDataHandle(), disk_cache_entry.get(),
-        kTestDiskCacheStreamIndex);
-    scoped_ptr<BlobDataHandle> handle3 =
-        blob_storage_context.AddFinishedBlob(blob_data_builder.get());
-
-    // Setup upload data elements for comparison.
-    ResourceRequestBody::Element blob_element1, blob_element2, blob_element3;
-    blob_element1.SetToBytes(kBlobData.c_str(), kBlobData.size());
-    blob_element2.SetToFilePathRange(
-        base::FilePath(FILE_PATH_LITERAL("BlobFile.txt")), 0, 20, time1);
-    blob_element3.SetToDiskCacheEntryRange(0, kDiskCacheData.size());
-
-    ResourceRequestBody::Element upload_element1, upload_element2;
-    upload_element1.SetToBytes("Hello", 5);
-    upload_element2.SetToFilePathRange(
-        base::FilePath(FILE_PATH_LITERAL("foo1.txt")), 0, 20, time2);
-
-    // Test no blob reference.
-    scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
-    request_body->AppendBytes(
-        upload_element1.bytes(),
-        upload_element1.length());
-    request_body->AppendFileRange(
-        upload_element2.path(),
-        upload_element2.offset(),
-        upload_element2.length(),
-        upload_element2.expected_modification_time());
+    scoped_refptr<ResourceRequestBody> request_body = new ResourceRequestBody;
+
+    const std::string kBlob = "blobuuid";
+    const std::string kBlobData = "blobdata";
+    const char kData[] = "123";
+    const base::FilePath::StringType kFilePath = FILE_PATH_LITERAL("abc");
+    const uint64 kFileOffset = 10U;
+    const uint64 kFileLength = 100U;
+    const base::Time kFileTime = base::Time::FromDoubleT(999);
+    const int64 kIdentifier = 12345;
+
+    BlobStorageContext context;
+    BlobDataBuilder builder(kBlob);
+    builder.AppendData(kBlobData);
+    scoped_ptr<BlobDataHandle> handle = context.AddFinishedBlob(&builder);
+
+    request_body->AppendBytes(kData, arraysize(kData) - 1);
+    request_body->AppendFileRange(base::FilePath(kFilePath), kFileOffset,
+                                  kFileLength, kFileTime);
+    request_body->AppendBlob(kBlob);
+    request_body->set_identifier(kIdentifier);
 
     scoped_ptr<net::UploadDataStream> upload(UploadDataStreamBuilder::Build(
-        request_body.get(), &blob_storage_context, NULL,
+        request_body.get(), &context, NULL,
         base::ThreadTaskRunnerHandle::Get().get()));
 
+    EXPECT_EQ(kIdentifier, upload->identifier());
     ASSERT_TRUE(upload->GetElementReaders());
-    ASSERT_EQ(2U, upload->GetElementReaders()->size());
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[0], upload_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[1], upload_element2));
-
-    // Test having only one blob reference that refers to empty blob data.
-    request_body = new ResourceRequestBody();
-    request_body->AppendBlob(blob_id0);
-
-    upload = UploadDataStreamBuilder::Build(
-        request_body.get(), &blob_storage_context, NULL,
-        base::ThreadTaskRunnerHandle::Get().get());
-    ASSERT_TRUE(upload->GetElementReaders());
-    ASSERT_EQ(0U, upload->GetElementReaders()->size());
-
-    // Test having only one blob reference.
-    request_body = new ResourceRequestBody();
-    request_body->AppendBlob(blob_id1);
-
-    upload = UploadDataStreamBuilder::Build(
-        request_body.get(), &blob_storage_context, NULL,
-        base::ThreadTaskRunnerHandle::Get().get());
-    ASSERT_TRUE(upload->GetElementReaders());
-    ASSERT_EQ(2U, upload->GetElementReaders()->size());
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[0], blob_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[1], blob_element2));
-
-    // Test having one blob reference which refers to a disk cache entry.
-    request_body = new ResourceRequestBody();
-    request_body->AppendBlob(blob_id2);
-
-    upload = UploadDataStreamBuilder::Build(
-        request_body.get(), &blob_storage_context, nullptr,
-        base::ThreadTaskRunnerHandle::Get().get());
-    ASSERT_TRUE(upload->GetElementReaders());
-    ASSERT_EQ(1U, upload->GetElementReaders()->size());
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[0], blob_element3));
-
-    // Test having one blob reference at the beginning.
-    request_body = new ResourceRequestBody();
-    request_body->AppendBlob(blob_id1);
-    request_body->AppendBytes(
-        upload_element1.bytes(),
-        upload_element1.length());
-    request_body->AppendFileRange(
-        upload_element2.path(),
-        upload_element2.offset(),
-        upload_element2.length(),
-        upload_element2.expected_modification_time());
-
-    upload = UploadDataStreamBuilder::Build(
-        request_body.get(), &blob_storage_context, NULL,
-        base::ThreadTaskRunnerHandle::Get().get());
-    ASSERT_TRUE(upload->GetElementReaders());
-    ASSERT_EQ(4U, upload->GetElementReaders()->size());
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[0], blob_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[1], blob_element2));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[2], upload_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[3], upload_element2));
-
-    // Test having one blob reference at the end.
-    request_body = new ResourceRequestBody();
-    request_body->AppendBytes(
-        upload_element1.bytes(),
-        upload_element1.length());
-    request_body->AppendFileRange(
-        upload_element2.path(),
-        upload_element2.offset(),
-        upload_element2.length(),
-        upload_element2.expected_modification_time());
-    request_body->AppendBlob(blob_id1);
-
-    upload = UploadDataStreamBuilder::Build(
-        request_body.get(), &blob_storage_context, NULL,
-        base::ThreadTaskRunnerHandle::Get().get());
-    ASSERT_TRUE(upload->GetElementReaders());
-    ASSERT_EQ(4U, upload->GetElementReaders()->size());
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[0], upload_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[1], upload_element2));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[2], blob_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[3], blob_element2));
-
-    // Test having one blob reference in the middle.
-    request_body = new ResourceRequestBody();
-    request_body->AppendBytes(
-        upload_element1.bytes(),
-        upload_element1.length());
-    request_body->AppendBlob(blob_id1);
-    request_body->AppendFileRange(
-        upload_element2.path(),
-        upload_element2.offset(),
-        upload_element2.length(),
-        upload_element2.expected_modification_time());
-
-    upload = UploadDataStreamBuilder::Build(
-        request_body.get(), &blob_storage_context, NULL,
-        base::ThreadTaskRunnerHandle::Get().get());
-    ASSERT_TRUE(upload->GetElementReaders());
-    ASSERT_EQ(4U, upload->GetElementReaders()->size());
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[0], upload_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[1], blob_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[2], blob_element2));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[3], upload_element2));
-
-    // Test having multiple blob references.
-    request_body = new ResourceRequestBody();
-    request_body->AppendBlob(blob_id1);
-    request_body->AppendBytes(
-        upload_element1.bytes(),
-        upload_element1.length());
-    request_body->AppendBlob(blob_id1);
-    request_body->AppendBlob(blob_id1);
-    request_body->AppendFileRange(
-        upload_element2.path(),
-        upload_element2.offset(),
-        upload_element2.length(),
-        upload_element2.expected_modification_time());
-
-    upload = UploadDataStreamBuilder::Build(
-        request_body.get(), &blob_storage_context, NULL,
-        base::ThreadTaskRunnerHandle::Get().get());
-    ASSERT_TRUE(upload->GetElementReaders());
-    ASSERT_EQ(8U, upload->GetElementReaders()->size());
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[0], blob_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[1], blob_element2));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[2], upload_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[3], blob_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[4], blob_element2));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[5], blob_element1));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[6], blob_element2));
-    EXPECT_TRUE(AreElementsEqual(
-        *(*upload->GetElementReaders())[7], upload_element2));
+    ASSERT_EQ(request_body->elements()->size(),
+              upload->GetElementReaders()->size());
+
+    const net::UploadBytesElementReader* r1 =
+        (*upload->GetElementReaders())[0]->AsBytesReader();
+    ASSERT_TRUE(r1);
+    EXPECT_EQ(kData, std::string(r1->bytes(), r1->length()));
+
+    const net::UploadFileElementReader* r2 =
+        (*upload->GetElementReaders())[1]->AsFileReader();
+    ASSERT_TRUE(r2);
+    EXPECT_EQ(kFilePath, r2->path().value());
+    EXPECT_EQ(kFileOffset, r2->range_offset());
+    EXPECT_EQ(kFileLength, r2->range_length());
+    EXPECT_EQ(kFileTime, r2->expected_modification_time());
+
+    const storage::UploadBlobElementReader* r3 =
+        static_cast<storage::UploadBlobElementReader*>(
+            (*upload->GetElementReaders())[2]);
+    ASSERT_TRUE(r3);
+    EXPECT_EQ("blobuuid", r3->uuid());
   }
   // Clean up for ASAN.
   base::RunLoop().RunUntilIdle();
@@ -402,9 +110,6 @@ TEST(UploadDataStreamBuilderTest,
     scoped_ptr<BlobDataHandle> handle =
         blob_storage_context.AddFinishedBlob(blob_data_builder.get());
 
-    ResourceRequestBody::Element blob_element;
-    blob_element.SetToFilePathRange(test_blob_path, 0, kZeroLength, blob_time);
-
     scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
     scoped_ptr<net::UploadDataStream> upload(UploadDataStreamBuilder::Build(
         request_body.get(), &blob_storage_context, NULL,
@@ -421,9 +126,6 @@ TEST(UploadDataStreamBuilderTest,
     ASSERT_TRUE(upload->GetElementReaders());
     const auto& readers = *upload->GetElementReaders();
     ASSERT_EQ(3U, readers.size());
-    EXPECT_TRUE(AreElementsEqual(*readers[0], blob_element));
-    EXPECT_TRUE(AreElementsEqual(*readers[1], blob_element));
-    EXPECT_TRUE(AreElementsEqual(*readers[2], blob_element));
 
     net::TestCompletionCallback init_callback;
     ASSERT_EQ(net::ERR_IO_PENDING, upload->Init(init_callback.callback()));