// 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