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

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
deleted file mode 100644
index 7321acc9cd5b54bc544cc984c4b0cc4a734988b9..0000000000000000000000000000000000000000
--- a/net/base/upload_disk_cache_entry_element_reader_unittest.cc
+++ /dev/null
@@ -1,331 +0,0 @@
-// 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 entry_->ReadyForSparseIO(callback);
-  }
-
- 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