Create blobs from Disk Cache entries.

net/base/upload_disk_cache_entry_element_reader_unittest.cc

Index: net/base/upload_disk_cache_entry_element_reader_unittest.cc
diff --git a/net/base/upload_disk_cache_entry_element_reader_unittest.cc b/net/base/upload_disk_cache_entry_element_reader_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2612cfa19614b7625a44d36722b7bed142c89b13
--- /dev/null
+++ b/net/base/upload_disk_cache_entry_element_reader_unittest.cc
@@ -0,0 +1,331 @@
+// Copyright 2015 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 "net/base/upload_disk_cache_entry_element_reader.h"
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/time/time.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/base/test_completion_callback.h"
+#include "net/disk_cache/disk_cache.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/platform_test.h"
+
+namespace net {
+namespace {
+
+const int kTestDiskCacheStreamIndex = 0;
+
+const char kDataKey[] = "a key";
+
+const char kData[] = "this is data in a disk cache entry";
+const size_t kDataSize = arraysize(kData) - 1;
+
+// A disk_cache::Entry that arbitrarily delays the completion of a read
+// operation to allow testing some races without flake. This is particularly
+// relevant in this unit test, which uses the always-synchronous MEMORY_CACHE.
+class DelayedReadEntry : public disk_cache::Entry {
+ public:
+  explicit DelayedReadEntry(disk_cache::ScopedEntryPtr entry)
+      : entry_(entry.Pass()) {}
+  ~DelayedReadEntry() override { EXPECT_FALSE(HasPendingReadCallbacks()); }
+
+  bool HasPendingReadCallbacks() { return !pending_read_callbacks_.empty(); }
+
+  void RunPendingReadCallbacks() {
+    std::vector<base::Callback<void(void)>> callbacks;
+    pending_read_callbacks_.swap(callbacks);
+    for (const auto& callback : callbacks)
+      callback.Run();
+  }
+
+  // From disk_cache::Entry:
+  void Doom() override { entry_->Doom(); }
+
+  void Close() override { delete this; }  // Note this is required by the API.
+
+  std::string GetKey() const override { return entry_->GetKey(); }
+
+  base::Time GetLastUsed() const override { return entry_->GetLastUsed(); }
+
+  base::Time GetLastModified() const override {
+    return entry_->GetLastModified();
+  }
+
+  int32 GetDataSize(int index) const override {
+    return entry_->GetDataSize(index);
+  }
+
+  int ReadData(int index,
+               int offset,
+               IOBuffer* buf,
+               int buf_len,
+               const CompletionCallback& original_callback) override {
+    TestCompletionCallback callback;
+    int rv = entry_->ReadData(index, offset, buf, buf_len, callback.callback());
+    DCHECK_NE(rv, ERR_IO_PENDING)
+        << "Test expects to use a MEMORY_CACHE instance, which is synchronous.";
+    pending_read_callbacks_.push_back(base::Bind(original_callback, rv));
+    return ERR_IO_PENDING;
+  }
+
+  int WriteData(int index,
+                int offset,
+                IOBuffer* buf,
+                int buf_len,
+                const CompletionCallback& callback,
+                bool truncate) override {
+    return entry_->WriteData(index, offset, buf, buf_len, callback, truncate);
+  }
+
+  int ReadSparseData(int64 offset,
+                     IOBuffer* buf,
+                     int buf_len,
+                     const CompletionCallback& callback) override {
+    return entry_->ReadSparseData(offset, buf, buf_len, callback);
+  }
+
+  int WriteSparseData(int64 offset,
+                      IOBuffer* buf,
+                      int buf_len,
+                      const CompletionCallback& callback) override {
+    return entry_->WriteSparseData(offset, buf, buf_len, callback);
+  }
+
+  int GetAvailableRange(int64 offset,
+                        int len,
+                        int64* start,
+                        const CompletionCallback& callback) override {
+    return entry_->GetAvailableRange(offset, len, start, callback);
+  }
+
+  bool CouldBeSparse() const override { return entry_->CouldBeSparse(); }
+
+  void CancelSparseIO() override { entry_->CancelSparseIO(); }
+
+  int ReadyForSparseIO(const CompletionCallback& callback) override {
+    return ReadyForSparseIO(callback);

[Nico, 2015/06/19 18:07:53]

This ain't right, as a new warning points out:

..\..\net\base\upload_disk_cache_entry_element_reader_unittest.cc(120,69) : 
error: all paths through this function will call itself
[-Werror,-Winfinite-recursion]
  int ReadyForSparseIO(const CompletionCallback& callback) override {
                                                                    ^

Can you fix this, please?

[gavinp, 2015/06/19 20:29:35]

Yes, I'll fix it. It should be:

  return entry_->ReadyForSparseIO(callback);

This code is, I'm happy to tell you, test only and in addition, dead.

+  }
+
+ private:
+  disk_cache::ScopedEntryPtr entry_;
+  std::vector<base::Callback<void(void)>> pending_read_callbacks_;
+};
+
+class UploadDiskCacheEntryElementReaderTest : public PlatformTest {
+ public:
+  UploadDiskCacheEntryElementReaderTest() {}
+
+  ~UploadDiskCacheEntryElementReaderTest() override {}
+
+  void SetUp() override {
+    TestCompletionCallback callback;
+    int rv = disk_cache::CreateCacheBackend(
+        MEMORY_CACHE, CACHE_BACKEND_DEFAULT, base::FilePath(), 0, false,
+        nullptr, nullptr, &cache_, callback.callback());
+    ASSERT_EQ(OK, callback.GetResult(rv));
+
+    disk_cache::Entry* tmp_entry = nullptr;
+    rv = cache_->CreateEntry(kDataKey, &tmp_entry, callback.callback());
+    ASSERT_EQ(OK, callback.GetResult(rv));
+    entry_.reset(tmp_entry);
+
+    scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(kData);
+    rv = entry_->WriteData(kTestDiskCacheStreamIndex, 0, io_buffer.get(),
+                           kDataSize, callback.callback(), false);
+    EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
+  }
+
+  void set_entry(disk_cache::ScopedEntryPtr entry) { entry_.swap(entry); }
+  disk_cache::Entry* entry() { return entry_.get(); }
+  disk_cache::ScopedEntryPtr release_entry() { return entry_.Pass(); }
+
+ private:
+  scoped_ptr<disk_cache::Backend> cache_;
+  disk_cache::ScopedEntryPtr entry_;
+};
+
+TEST_F(UploadDiskCacheEntryElementReaderTest, ReadAll) {
+  UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
+                                           0, kDataSize);
+  EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
+
+  char read_buffer[kDataSize];
+  std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
+
+  scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
+  TestCompletionCallback callback;
+  int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback());
+  EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
+  EXPECT_EQ(0U, reader.BytesRemaining())
+      << "Expected a single read of |kDataSize| to retrieve entire entry.";
+  EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize));
+}
+
+TEST_F(UploadDiskCacheEntryElementReaderTest, ReadPartially) {
+  UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
+                                           0, kDataSize);
+  EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
+
+  const size_t kReadBuffer1Size = kDataSize / 3;
+  char read_buffer1[kReadBuffer1Size];
+  std::fill(read_buffer1, read_buffer1 + arraysize(read_buffer1), '\0');
+
+  scoped_refptr<IOBuffer> io_buffer1 = new WrappedIOBuffer(read_buffer1);
+
+  const size_t kReadBuffer2Size = kDataSize - kReadBuffer1Size;
+  char read_buffer2[kReadBuffer2Size];
+  scoped_refptr<IOBuffer> io_buffer2 = new WrappedIOBuffer(read_buffer2);
+
+  TestCompletionCallback callback;
+  int rv = reader.Read(io_buffer1.get(), kReadBuffer1Size, callback.callback());
+  EXPECT_EQ(static_cast<int>(kReadBuffer1Size), callback.GetResult(rv));
+  EXPECT_EQ(static_cast<uint64_t>(kReadBuffer2Size), reader.BytesRemaining());
+
+  rv = reader.Read(io_buffer2.get(), kReadBuffer2Size, callback.callback());
+  EXPECT_EQ(static_cast<int>(kReadBuffer2Size), callback.GetResult(rv));
+  EXPECT_EQ(0U, reader.BytesRemaining());
+
+  EXPECT_EQ(std::string(kData, kDataSize),
+            std::string(read_buffer1, kReadBuffer1Size) +
+                std::string(read_buffer2, kReadBuffer2Size));
+}
+
+TEST_F(UploadDiskCacheEntryElementReaderTest, ReadTooMuch) {
+  UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
+                                           0, kDataSize);
+  EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
+
+  const size_t kTooLargeSize = kDataSize + kDataSize / 2;
+
+  char read_buffer[kTooLargeSize];
+  std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
+
+  scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
+  TestCompletionCallback callback;
+  int rv = reader.Read(io_buffer.get(), kTooLargeSize, callback.callback());
+  EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
+  EXPECT_EQ(0U, reader.BytesRemaining());
+  EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize));
+}
+
+TEST_F(UploadDiskCacheEntryElementReaderTest, ReadAsync) {
+  DelayedReadEntry* delayed_read_entry = new DelayedReadEntry(release_entry());
+  set_entry(disk_cache::ScopedEntryPtr(delayed_read_entry));
+
+  UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
+                                           0, kDataSize);
+
+  char read_buffer[kDataSize];
+  std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
+
+  scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
+  TestCompletionCallback callback;
+  int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks());
+  EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
+
+  delayed_read_entry->RunPendingReadCallbacks();
+  EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
+  EXPECT_EQ(0U, reader.BytesRemaining())
+      << "Expected a single read of |kDataSize| to retrieve entire entry.";
+  EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize));
+}
+
+TEST_F(UploadDiskCacheEntryElementReaderTest, MultipleInit) {
+  UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
+                                           0, kDataSize);
+  char read_buffer[kDataSize];
+  std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
+
+  scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
+  TestCompletionCallback callback;
+  int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback());
+  EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
+  EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize));
+
+  rv = reader.Init(callback.callback());
+  EXPECT_EQ(OK, callback.GetResult(rv));
+  EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
+  rv = reader.Read(io_buffer.get(), kDataSize, callback.callback());
+  EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
+  EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize));
+}
+
+TEST_F(UploadDiskCacheEntryElementReaderTest, InitDuringAsyncOperation) {
+  DelayedReadEntry* delayed_read_entry = new DelayedReadEntry(release_entry());
+  set_entry(disk_cache::ScopedEntryPtr(delayed_read_entry));
+
+  UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
+                                           0, kDataSize);
+  char read_buffer[kDataSize];
+  std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
+
+  scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
+  TestCompletionCallback read_callback;
+  int rv = reader.Read(io_buffer.get(), kDataSize, read_callback.callback());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks());
+  EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
+
+  TestCompletionCallback init_callback;
+  rv = reader.Init(init_callback.callback());
+  EXPECT_EQ(OK, init_callback.GetResult(rv));
+
+  delayed_read_entry->RunPendingReadCallbacks();
+  EXPECT_FALSE(delayed_read_entry->HasPendingReadCallbacks());
+  EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
+
+  char read_buffer2[kDataSize];
+  std::fill(read_buffer2, read_buffer2 + arraysize(read_buffer2), '\0');
+  scoped_refptr<IOBuffer> io_buffer2 = new WrappedIOBuffer(read_buffer2);
+  TestCompletionCallback read_callback2;
+  rv = reader.Read(io_buffer2.get(), kDataSize, read_callback2.callback());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks());
+  EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
+
+  delayed_read_entry->RunPendingReadCallbacks();
+  EXPECT_FALSE(delayed_read_entry->HasPendingReadCallbacks());
+  read_callback2.WaitForResult();  // Succeeds if this does not deadlock.
+  EXPECT_EQ(std::string(kData, kDataSize),
+            std::string(read_buffer2, kDataSize));
+}
+
+TEST_F(UploadDiskCacheEntryElementReaderTest, Range) {
+  const size_t kOffset = kDataSize / 4;
+  const size_t kLength = kDataSize / 3;
+
+  UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
+                                           kOffset, kLength);
+  EXPECT_EQ(static_cast<uint64_t>(kLength), reader.BytesRemaining());
+
+  char read_buffer[kLength];
+  std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
+
+  scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
+  TestCompletionCallback callback;
+  int rv = reader.Read(io_buffer.get(), kLength, callback.callback());
+  EXPECT_EQ(static_cast<int>(kLength), callback.GetResult(rv));
+  EXPECT_EQ(0U, reader.BytesRemaining());
+  EXPECT_EQ(std::string(kData + kOffset, kLength),
+            std::string(read_buffer, kLength));
+}
+
+}  // namespace
+}  // namespace net