IndexedDB: Fixed support for empty blobs.

content/browser/loader/upload_data_stream_builder_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 "content/browser/loader/upload_data_stream_builder.h"
 
 #include <algorithm>
+#include <string>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "content/common/resource_request_body.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#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_file_element_reader.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
+using base::File;
 using storage::BlobDataBuilder;
 using storage::BlobDataHandle;
 using storage::BlobStorageContext;
 
 namespace content {
 namespace {
 
 bool AreElementsEqual(const net::UploadElementReader& reader,
                       const ResourceRequestBody::Element& element) {
   switch(element.type()) {
@@ skipping 269 matching lines @@
         *(*upload->GetElementReaders())[5], blob_element1));
     EXPECT_TRUE(AreElementsEqual(
         *(*upload->GetElementReaders())[6], blob_element2));
     EXPECT_TRUE(AreElementsEqual(
         *(*upload->GetElementReaders())[7], upload_element2));
   }
   // Clean up for ASAN.
   base::RunLoop().RunUntilIdle();
 }
 
+TEST(UploadDataStreamBuilderTest,
+     WriteUploadDataStreamWithEmptyFileBackedBlob) {
+  base::MessageLoop message_loop;
+  {
+    base::Time blob_time;
+    base::FilePath test_blob_path;
+    ASSERT_TRUE(base::CreateTemporaryFile(&test_blob_path));
+
+    const std::string kBlobFileData = "";

[michaeln, 2015/03/09 21:15:18]

dont think we need this

[cmumford, 2015/03/09 22:05:11]

Yeah, it was handy when writing the test to make the file either empty (or not).
Removed dead code as suggested.

+    const uint64_t kBlobLength = kBlobFileData.size();

[michaeln, 2015/03/09 21:15:18]

since its always zero, kZeroLength would be more clear

[cmumford, 2015/03/09 22:05:10]

Done.

+    if (!kBlobFileData.empty()) {

[michaeln, 2015/03/09 21:15:18]

its always empty so we don't need the if

[cmumford, 2015/03/09 22:05:10]

Done.

+      File f(test_blob_path, File::FLAG_OPEN | File::FLAG_WRITE);
+      ASSERT_EQ(static_cast<int>(kBlobLength),
+                f.WriteAtCurrentPos(kBlobFileData.c_str(), kBlobLength));
+      base::File::Info info;
+      ASSERT_TRUE(f.GetInfo(&info));
+      blob_time = info.last_modified;
+    } else {
+      base::Time::FromString("Tue, 15 Nov 1994, 12:45:26 GMT", &blob_time);
+      ASSERT_TRUE(base::TouchFile(test_blob_path, blob_time, blob_time));
+    }
+
+    BlobStorageContext blob_storage_context;
+
+    // First an empty blob
+    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());
+
+    // Then a blob created from an empty file added several times.
+    const std::string blob_id1("id-1");
+    blob_data_builder.reset(new BlobDataBuilder(blob_id1));
+    blob_data_builder->AppendFile(test_blob_path, 0, kBlobLength, blob_time);
+    scoped_ptr<BlobDataHandle> handle2 =
+        blob_storage_context.AddFinishedBlob(blob_data_builder.get());
+
+    ResourceRequestBody::Element blob_element;
+    blob_element.SetToFilePathRange(test_blob_path, 0, kBlobLength, blob_time);
+
+    scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
+    scoped_ptr<net::UploadDataStream> upload(UploadDataStreamBuilder::Build(
+        request_body.get(), &blob_storage_context, NULL,
+        base::MessageLoopProxy::current().get()));
+
+    request_body = new ResourceRequestBody();
+    request_body->AppendBlob(blob_id1);
+    request_body->AppendBlob(blob_id1);
+    request_body->AppendBlob(blob_id1);
+
+    upload = UploadDataStreamBuilder::Build(
+        request_body.get(), &blob_storage_context, NULL,
+        base::MessageLoopProxy::current().get());
+    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()));
+    EXPECT_EQ(net::OK, init_callback.WaitForResult());
+
+    const size_t kExpectedStreamLength = 3U * kBlobLength;
+    EXPECT_EQ(kExpectedStreamLength, upload->size());
+
+    scoped_ptr<char[]> buffer(new char[kExpectedStreamLength]);
+    scoped_refptr<net::IOBuffer> write_buff =
+        new net::WrappedIOBuffer(buffer.get());
+    net::TestCompletionCallback read_callback;
+    int result = upload->Read(write_buff.get(), kExpectedStreamLength,

[michaeln, 2015/03/09 21:15:18]

Ah, I see what tripped the dcheck in the stream reader. kExpectedStreamLength is
0. The production code probably shouldn't change to accomodate this test, this
test should alloc a small non-zero-length buffer.

[cmumford, 2015/03/09 22:05:10]

Done.

+                              read_callback.callback());
+    EXPECT_EQ(static_cast<int>(kExpectedStreamLength),
+              read_callback.GetResult(result));
+
+    base::DeleteFile(test_blob_path, false);
+  }
+  // Clean up for ASAN.
+  base::RunLoop().RunUntilIdle();
+}
 }  // namespace content