ServiceWorkerWriteToCacheJob: refactor

content/browser/service_worker/service_worker_cache_writer_unittest.cc

Index: content/browser/service_worker/service_worker_cache_writer_unittest.cc
diff --git a/content/browser/service_worker/service_worker_cache_writer_unittest.cc b/content/browser/service_worker/service_worker_cache_writer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ab19e510251a5553c3296af8c278190de91519d0
--- /dev/null
+++ b/content/browser/service_worker/service_worker_cache_writer_unittest.cc
@@ -0,0 +1,694 @@
+// 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 "content/browser/service_worker/service_worker_cache_writer.h"
+
+#include <list>
+#include <queue>
+#include <string>
+
+#include "base/stl_util.h"
+#include "content/browser/service_worker/service_worker_disk_cache.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+namespace {
+
+// A test implementation of ServiceWorkerResponseReader.
+//
+// This class exposes the ability to expect reads (see ExpectRead*() below).
+// Each call to ReadInfo() or ReadData() consumes another expected read, in the
+// order those reads were expected, so:
+//    reader->ExpectReadInfoOk(5, false);
+//    reader->ExpectReadDataOk("abcdef", false);
+//    reader->ExpectReadDataOk("ghijkl", false);
+// Expects these calls, in this order:
+//    reader->ReadInfo(...);  // reader writes 5 into
+//                            // |info_buf->response_data_size|
+//    reader->ReadData(...);  // reader writes "abcdef" into |buf|
+//    reader->ReadData(...);  // reader writes "ghijkl" into |buf|
+// If an unexpected call happens, this class DCHECKs.
+// If an expected read is marked "async", it will not complete immediately, but
+// must be completed by the test using CompletePendingRead().
+// These is a convenience method AllExpectedReadsDone() which returns whether
+// there are any expected reads that have not yet happened.
+class MockServiceWorkerResponseReader : public ServiceWorkerResponseReader {
+ public:
+  MockServiceWorkerResponseReader() : ServiceWorkerResponseReader(0, nullptr) {}
+  ~MockServiceWorkerResponseReader() override {}
+
+  // ServiceWorkerResponseReader overrides
+  void ReadInfo(HttpResponseInfoIOBuffer* info_buf,
+                const net::CompletionCallback& callback) override;
+  void ReadData(net::IOBuffer* buf,
+                int buf_len,
+                const net::CompletionCallback& callback) override;
+
+  // Test helpers. ExpectReadInfo() and ExpectReadData() give precise control
+  // over both the data to be written and the result to return.
+  // ExpectReadInfoOk() and ExpectReadDataOk() are convenience functions for
+  // expecting successful reads, which always have their length as their result.
+
+  // Expect a call to ReadInfo() on this reader. For these functions, |len| will
+  // be used as |response_data_size|, not as the length of this particular read.
+  void ExpectReadInfo(size_t len, bool async, int result);
+  void ExpectReadInfoOk(size_t len, bool async);
+
+  // Expect a call to ReadData() on this reader. For these functions, |len| is
+  // the length of the data to be written back; in ExpectReadDataOk(), |len| is
+  // implicitly the length of |data|.
+  void ExpectReadData(const char* data, size_t len, bool async, int result);
+  void ExpectReadDataOk(const std::string& data, bool async);
+
+  // Complete a pending async read. It is an error to call this function without
+  // a pending async read (ie, a previous call to ReadInfo() or ReadData()
+  // having not run its callback yet).
+  void CompletePendingRead();
+
+  // Returns whether all expected reads have occurred.
+  bool AllExpectedReadsDone() { return expected_reads_.size() == 0; }
+
+ private:
+  struct ExpectedRead {
+    ExpectedRead(size_t len, bool async, int result)
+        : data(nullptr), len(len), info(true), async(async), result(result) {}
+    ExpectedRead(const char* data, size_t len, bool async, int result)
+        : data(data), len(len), info(false), async(async), result(result) {}
+    const char* data;
+    size_t len;
+    bool info;
+    bool async;
+    int result;
+  };
+
+  std::queue<ExpectedRead> expected_reads_;
+  scoped_refptr<net::IOBuffer> pending_buffer_;
+  size_t pending_buffer_len_;
+  scoped_refptr<HttpResponseInfoIOBuffer> pending_info_;
+  net::CompletionCallback pending_callback_;
+};
+
+void MockServiceWorkerResponseReader::ReadInfo(
+    HttpResponseInfoIOBuffer* info_buf,
+    const net::CompletionCallback& callback) {
+  DCHECK(!expected_reads_.empty());
+  ExpectedRead expected = expected_reads_.front();
+  EXPECT_TRUE(expected.info);
+  if (expected.async) {
+    pending_info_ = info_buf;
+    pending_callback_ = callback;
+  } else {
+    expected_reads_.pop();
+    info_buf->response_data_size = expected.len;
+    callback.Run(expected.result);
+  }
+}
+
+void MockServiceWorkerResponseReader::ReadData(
+    net::IOBuffer* buf,
+    int buf_len,
+    const net::CompletionCallback& callback) {
+  DCHECK(!expected_reads_.empty());
+  ExpectedRead expected = expected_reads_.front();
+  EXPECT_FALSE(expected.info);
+  if (expected.async) {
+    pending_callback_ = callback;
+    pending_buffer_ = buf;
+    pending_buffer_len_ = static_cast<size_t>(buf_len);
+  } else {
+    expected_reads_.pop();
+    if (expected.len > 0) {
+      size_t to_read = std::min(static_cast<size_t>(buf_len), expected.len);
+      memcpy(buf->data(), expected.data, to_read);
+    }
+    callback.Run(expected.result);
+  }
+}
+
+void MockServiceWorkerResponseReader::ExpectReadInfo(size_t len,
+                                                     bool async,
+                                                     int result) {
+  expected_reads_.push(ExpectedRead(len, async, result));
+}
+
+void MockServiceWorkerResponseReader::ExpectReadInfoOk(size_t len, bool async) {
+  expected_reads_.push(ExpectedRead(len, async, len));
+}
+
+void MockServiceWorkerResponseReader::ExpectReadData(const char* data,
+                                                     size_t len,
+                                                     bool async,
+                                                     int result) {
+  expected_reads_.push(ExpectedRead(data, len, async, result));
+}
+
+void MockServiceWorkerResponseReader::ExpectReadDataOk(const std::string& data,
+                                                       bool async) {
+  expected_reads_.push(
+      ExpectedRead(data.data(), data.size(), async, data.size()));
+}
+
+void MockServiceWorkerResponseReader::CompletePendingRead() {
+  DCHECK(!expected_reads_.empty());
+  ExpectedRead expected = expected_reads_.front();
+  expected_reads_.pop();
+  EXPECT_TRUE(expected.async);
+  if (expected.info) {
+    pending_info_->response_data_size = expected.len;
+  } else {
+    size_t to_read = std::min(pending_buffer_len_, expected.len);
+    if (to_read > 0)
+      memcpy(pending_buffer_->data(), expected.data, to_read);
+  }
+  pending_info_ = nullptr;
+  pending_buffer_ = nullptr;
+  net::CompletionCallback callback = pending_callback_;
+  pending_callback_.Reset();
+  callback.Run(expected.result);
+}
+
+// A test implementation of ServiceWorkerResponseWriter.
+//
+// This class exposes the ability to expect writes (see ExpectWrite*Ok() below).
+// Each write to this class via WriteInfo() or WriteData() consumes another
+// expected write, in the order they were added, so:
+//   writer->ExpectWriteInfoOk(5, false);
+//   writer->ExpectWriteDataOk(6, false);
+//   writer->ExpectWriteDataOk(6, false);
+// Expects these calls, in this order:
+//   writer->WriteInfo(...);  // checks that |buf->response_data_size| == 5
+//   writer->WriteData(...);  // checks that 6 bytes are being written
+//   writer->WriteData(...);  // checks that another 6 bytes are being written
+// If this class receives an unexpected call to WriteInfo() or WriteData(), it
+// DCHECKs.
+// Expected writes marked async do not complete synchronously, but rather return
+// without running their callback and need to be completed with
+// CompletePendingWrite().
+// A convenience method AllExpectedWritesDone() is exposed so tests can ensure
+// that all expected writes have been consumed by matching calls to WriteInfo()
+// or WriteData().
+class MockServiceWorkerResponseWriter : public ServiceWorkerResponseWriter {
+ public:
+  MockServiceWorkerResponseWriter()
+      : ServiceWorkerResponseWriter(0, nullptr),
+        info_written_(0),
+        data_written_(0) {}
+  ~MockServiceWorkerResponseWriter() override {}
+
+  // ServiceWorkerResponseWriter overrides
+  void WriteInfo(HttpResponseInfoIOBuffer* info_buf,
+                 const net::CompletionCallback& callback) override;
+  void WriteData(net::IOBuffer* buf,
+                 int buf_len,
+                 const net::CompletionCallback& callback) override;
+
+  // Enqueue expected writes.
+  void ExpectWriteInfoOk(size_t len, bool async);
+  void ExpectWriteDataOk(size_t len, bool async);
+
+  // Complete a pending asynchronous write. This method DCHECKs unless there is
+  // a pending write (a write for which WriteInfo() or WriteData() has been
+  // called but the callback has not yet been run).
+  void CompletePendingWrite();
+
+  // Returns whether all expected reads have been consumed.
+  bool AllExpectedWritesDone() { return expected_writes_.size() == 0; }
+
+ private:
+  struct ExpectedWrite {
+    ExpectedWrite(bool is_info, size_t length, bool async, int result)
+        : is_info(is_info), length(length), async(async), result(result) {}
+    bool is_info;
+    size_t length;
+    bool async;
+    int result;
+  };
+
+  std::queue<ExpectedWrite> expected_writes_;
+
+  size_t info_written_;
+  size_t data_written_;
+
+  net::CompletionCallback pending_callback_;
+};
+
+void MockServiceWorkerResponseWriter::WriteInfo(
+    HttpResponseInfoIOBuffer* info_buf,
+    const net::CompletionCallback& callback) {
+  DCHECK(!expected_writes_.empty());
+  ExpectedWrite write = expected_writes_.front();
+  EXPECT_TRUE(write.is_info);
+  EXPECT_EQ(write.length, static_cast<size_t>(info_buf->response_data_size));
+  info_written_ += info_buf->response_data_size;
+  if (!write.async) {
+    expected_writes_.pop();
+    callback.Run(write.result);
+  } else {
+    pending_callback_ = callback;
+  }
+}
+
+void MockServiceWorkerResponseWriter::WriteData(
+    net::IOBuffer* buf,
+    int buf_len,
+    const net::CompletionCallback& callback) {
+  DCHECK(!expected_writes_.empty());
+  ExpectedWrite write = expected_writes_.front();
+  EXPECT_FALSE(write.is_info);
+  EXPECT_EQ(write.length, static_cast<size_t>(buf_len));
+  data_written_ += buf_len;
+  if (!write.async) {
+    expected_writes_.pop();
+    callback.Run(write.result);
+  } else {
+    pending_callback_ = callback;
+  }
+}
+
+void MockServiceWorkerResponseWriter::ExpectWriteInfoOk(size_t length,
+                                                        bool async) {
+  ExpectedWrite expected(true, length, async, length);
+  expected_writes_.push(expected);
+}
+
+void MockServiceWorkerResponseWriter::ExpectWriteDataOk(size_t length,
+                                                        bool async) {
+  ExpectedWrite expected(false, length, async, length);
+  expected_writes_.push(expected);
+}
+
+void MockServiceWorkerResponseWriter::CompletePendingWrite() {
+  DCHECK(!expected_writes_.empty());
+  ExpectedWrite write = expected_writes_.front();
+  DCHECK(write.async);
+  expected_writes_.pop();
+  pending_callback_.Run(write.result);
+}
+
+class ServiceWorkerCacheWriterTest : public ::testing::Test {
+ public:
+  ServiceWorkerCacheWriterTest()
+      : readers_deleter_(&readers_), writers_deleter_(&writers_) {}
+
+  void SetUp() override {
+    ::testing::Test::SetUp();
+    cache_writer_.reset(new ServiceWorkerCacheWriter(
+        base::Bind(&ServiceWorkerCacheWriterTest::CreateReader,
+                   base::Unretained(this)),
+        base::Bind(&ServiceWorkerCacheWriterTest::CreateWriter,
+                   base::Unretained(this))));
+    write_complete_ = false;
+  }
+
+  MockServiceWorkerResponseReader* ExpectReader() {
+    scoped_ptr<MockServiceWorkerResponseReader> reader(
+        new MockServiceWorkerResponseReader);
+    MockServiceWorkerResponseReader* borrowed_reader = reader.get();
+    readers_.push_back(reader.release());  // give ownership to |readers_|
+    return borrowed_reader;
+  }
+
+  MockServiceWorkerResponseWriter* ExpectWriter() {
+    scoped_ptr<MockServiceWorkerResponseWriter> writer(
+        new MockServiceWorkerResponseWriter);
+    MockServiceWorkerResponseWriter* borrowed_writer = writer.get();
+    writers_.push_back(writer.release());  // give ownership to |writers_|
+    return borrowed_writer;
+  }
+
+ protected:
+  // TODO(ellyjones): when unique_ptr<> is allowed, make these instead:
+  //   std::list<unique_ptr<...>>
+  // Right now, these cannot use scoped_ptr.
+  // Their elements are deleted by the STLElementDeleters below when this object
+  // goes out of scope.
+  std::list<MockServiceWorkerResponseReader*> readers_;
+  std::list<MockServiceWorkerResponseWriter*> writers_;
+  STLElementDeleter<std::list<MockServiceWorkerResponseReader*>>
+      readers_deleter_;
+  STLElementDeleter<std::list<MockServiceWorkerResponseWriter*>>
+      writers_deleter_;
+  scoped_ptr<ServiceWorkerCacheWriter> cache_writer_;
+  bool write_complete_;
+  net::Error last_error_;
+
+  scoped_ptr<ServiceWorkerResponseReader> CreateReader() {
+    if (readers_.empty())
+      return make_scoped_ptr<ServiceWorkerResponseReader>(nullptr);
+    scoped_ptr<ServiceWorkerResponseReader> reader(readers_.front());
+    readers_.pop_front();
+    return reader.Pass();
+  }
+  scoped_ptr<ServiceWorkerResponseWriter> CreateWriter() {
+    if (writers_.empty())
+      return make_scoped_ptr<ServiceWorkerResponseWriter>(nullptr);
+    scoped_ptr<ServiceWorkerResponseWriter> writer(writers_.front());
+    writers_.pop_front();
+    return writer.Pass();
+  }
+
+  ServiceWorkerCacheWriter::OnWriteCompleteCallback CreateWriteCallback() {
+    return base::Bind(&ServiceWorkerCacheWriterTest::OnWriteComplete,
+                      base::Unretained(this));
+  }
+
+  void OnWriteComplete(net::Error error) {
+    write_complete_ = true;
+    last_error_ = error;
+  }
+
+  net::Error WriteHeaders(size_t len) {
+    scoped_refptr<HttpResponseInfoIOBuffer> buf(new HttpResponseInfoIOBuffer);
+    buf->response_data_size = len;
+    return cache_writer_->MaybeWriteHeaders(buf.get(), CreateWriteCallback());
+  }
+
+  net::Error WriteData(const std::string& data) {
+    scoped_refptr<net::IOBuffer> buf = new net::StringIOBuffer(data);
+    return cache_writer_->MaybeWriteData(buf.get(), data.size(),
+                                         CreateWriteCallback());
+  }
+};
+
+// Passthrough tests:
+// In these tests, the ServiceWorkerCacheWriter under test has no existing
+// reader, since no calls to ExpectReader() have been made; this means that
+// there is no existing cached response and the incoming data is written back to
+// the cache directly.
+
+TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersSync) {
+  const size_t kHeaderSize = 16;
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  writer->ExpectWriteInfoOk(kHeaderSize, false);
+
+  net::Error error = WriteHeaders(kHeaderSize);
+  EXPECT_EQ(net::OK, error);
+  EXPECT_FALSE(write_complete_);
+  EXPECT_TRUE(writer->AllExpectedWritesDone());
+  EXPECT_EQ(0U, cache_writer_->bytes_written());
+}
+
+TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersAsync) {
+  size_t kHeaderSize = 16;
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  writer->ExpectWriteInfoOk(kHeaderSize, true);
+
+  net::Error error = WriteHeaders(kHeaderSize);
+  EXPECT_EQ(net::ERR_IO_PENDING, error);
+  EXPECT_FALSE(write_complete_);
+  writer->CompletePendingWrite();
+  EXPECT_TRUE(write_complete_);
+  EXPECT_TRUE(writer->AllExpectedWritesDone());
+  EXPECT_EQ(0U, cache_writer_->bytes_written());
+}
+
+TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataSync) {
+  const std::string data1 = "abcdef";
+  const std::string data2 = "ghijklmno";
+  size_t response_size = data1.size() + data2.size();
+
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  writer->ExpectWriteInfoOk(response_size, false);
+  writer->ExpectWriteDataOk(data1.size(), false);
+  writer->ExpectWriteDataOk(data2.size(), false);
+
+  net::Error error = WriteHeaders(response_size);
+  EXPECT_EQ(net::OK, error);
+
+  error = WriteData(data1);
+  EXPECT_EQ(net::OK, error);
+
+  error = WriteData(data2);
+  EXPECT_EQ(net::OK, error);
+  EXPECT_TRUE(writer->AllExpectedWritesDone());
+}
+
+TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataAsync) {
+  const std::string data1 = "abcdef";
+  const std::string data2 = "ghijklmno";
+  size_t response_size = data1.size() + data2.size();
+
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  writer->ExpectWriteInfoOk(response_size, false);
+  writer->ExpectWriteDataOk(data1.size(), true);
+  writer->ExpectWriteDataOk(data2.size(), true);
+
+  net::Error error = WriteHeaders(response_size);
+  EXPECT_EQ(net::OK, error);
+
+  error = WriteData(data1);
+  EXPECT_EQ(net::ERR_IO_PENDING, error);
+  writer->CompletePendingWrite();
+  EXPECT_TRUE(write_complete_);
+
+  write_complete_ = false;
+  error = WriteData(data2);
+  EXPECT_EQ(net::ERR_IO_PENDING, error);
+  writer->CompletePendingWrite();
+  EXPECT_TRUE(write_complete_);
+  EXPECT_TRUE(writer->AllExpectedWritesDone());
+}
+
+// Comparison tests:
+// For the Compare* tests below, the ServiceWorkerCacheWriter under test has a
+// reader for an existing cached response, so it will compare the response being
+// written to it against the existing cached response.
+
+TEST_F(ServiceWorkerCacheWriterTest, CompareHeadersSync) {
+  size_t response_size = 3;
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  MockServiceWorkerResponseReader* reader = ExpectReader();
+
+  reader->ExpectReadInfoOk(response_size, false);
+
+  net::Error error = WriteHeaders(response_size);
+  EXPECT_EQ(net::OK, error);
+  EXPECT_TRUE(writer->AllExpectedWritesDone());
+  EXPECT_TRUE(reader->AllExpectedReadsDone());
+}
+
+TEST_F(ServiceWorkerCacheWriterTest, CompareDataOkSync) {
+  const std::string data1 = "abcdef";
+  size_t response_size = data1.size();
+
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  MockServiceWorkerResponseReader* reader = ExpectReader();
+
+  reader->ExpectReadInfoOk(response_size, false);
+  reader->ExpectReadDataOk(data1, false);
+
+  net::Error error = WriteHeaders(response_size);
+  EXPECT_EQ(net::OK, error);
+
+  error = WriteData(data1);
+  EXPECT_EQ(net::OK, error);
+
+  EXPECT_TRUE(writer->AllExpectedWritesDone());
+  EXPECT_TRUE(reader->AllExpectedReadsDone());
+  EXPECT_EQ(0U, cache_writer_->bytes_written());
+}
+
+TEST_F(ServiceWorkerCacheWriterTest, CompareShortCacheReads) {
+  const size_t kHeaderSize = 16;
+  const std::string& data1 = "abcdef";
+  const std::string& cache_data2 = "ghi";
+  const std::string& cache_data3 = "j";
+  const std::string& cache_data4 = "kl";
+  const std::string& net_data2 = "ghijkl";
+  const std::string& data5 = "mnopqrst";
+
+  MockServiceWorkerResponseReader* reader = ExpectReader();
+  reader->ExpectReadInfo(kHeaderSize, false, kHeaderSize);
+  reader->ExpectReadDataOk(data1, false);
+  reader->ExpectReadDataOk(cache_data2, false);
+  reader->ExpectReadDataOk(cache_data3, false);
+  reader->ExpectReadDataOk(cache_data4, false);
+  reader->ExpectReadDataOk(data5, false);
+
+  net::Error error = WriteHeaders(kHeaderSize);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(data1);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(net_data2);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(data5);
+  EXPECT_EQ(net::OK, error);
+  EXPECT_TRUE(reader->AllExpectedReadsDone());
+  EXPECT_EQ(0U, cache_writer_->bytes_written());
+}
+
+TEST_F(ServiceWorkerCacheWriterTest, CompareDataOkAsync) {
+  const std::string data1 = "abcdef";
+  size_t response_size = data1.size();
+
+  MockServiceWorkerResponseReader* reader = ExpectReader();
+
+  reader->ExpectReadInfoOk(response_size, true);
+  reader->ExpectReadDataOk(data1, true);
+
+  net::Error error = WriteHeaders(response_size);
+  EXPECT_EQ(net::ERR_IO_PENDING, error);
+  reader->CompletePendingRead();
+
+  error = WriteData(data1);
+  EXPECT_EQ(net::ERR_IO_PENDING, error);
+  reader->CompletePendingRead();
+
+  EXPECT_TRUE(reader->AllExpectedReadsDone());
+  EXPECT_EQ(0U, cache_writer_->bytes_written());
+}
+
+TEST_F(ServiceWorkerCacheWriterTest, CompareDataManyOkAsync) {
+  const std::string expected_data[] = {
+      "abcdef", "ghijkl", "mnopqr", "stuvwxyz",
+  };
+  size_t response_size = 0;
+  for (size_t i = 0; i < arraysize(expected_data); ++i)
+    response_size += expected_data[i].size();
+
+  MockServiceWorkerResponseReader* reader = ExpectReader();
+
+  reader->ExpectReadInfoOk(response_size, true);
+  for (size_t i = 0; i < arraysize(expected_data); ++i) {
+    reader->ExpectReadDataOk(expected_data[i], true);
+  }
+
+  net::Error error = WriteHeaders(response_size);
+  EXPECT_EQ(net::ERR_IO_PENDING, error);
+  reader->CompletePendingRead();
+
+  for (size_t i = 0; i < arraysize(expected_data); ++i) {
+    error = WriteData(expected_data[i]);
+    EXPECT_EQ(net::ERR_IO_PENDING, error);
+    reader->CompletePendingRead();
+    EXPECT_EQ(net::OK, last_error_);
+  }
+
+  EXPECT_TRUE(reader->AllExpectedReadsDone());
+  EXPECT_EQ(0U, cache_writer_->bytes_written());
+}
+
+// This test writes headers and three data blocks data1, data2, data3; data2
+// differs in the cached version. The writer should be asked to rewrite the
+// headers and body with the new value, and the copy reader should be asked to
+// read the header and data1.
+TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopySync) {
+  std::string data1 = "abcdef";
+  std::string cache_data2 = "ghijkl";
+  std::string net_data2 = "mnopqr";
+  std::string data3 = "stuvwxyz";
+  size_t cache_response_size = data1.size() + cache_data2.size() + data3.size();
+  size_t net_response_size = data1.size() + net_data2.size() + data3.size();
+
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  MockServiceWorkerResponseReader* compare_reader = ExpectReader();
+  MockServiceWorkerResponseReader* copy_reader = ExpectReader();
+
+  compare_reader->ExpectReadInfoOk(cache_response_size, false);
+  compare_reader->ExpectReadDataOk(data1, false);
+  compare_reader->ExpectReadDataOk(cache_data2, false);
+
+  copy_reader->ExpectReadInfoOk(cache_response_size, false);
+  copy_reader->ExpectReadDataOk(data1, false);
+
+  writer->ExpectWriteInfoOk(net_response_size, false);
+  writer->ExpectWriteDataOk(data1.size(), false);
+  writer->ExpectWriteDataOk(net_data2.size(), false);
+  writer->ExpectWriteDataOk(data3.size(), false);
+
+  net::Error error = WriteHeaders(net_response_size);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(data1);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(net_data2);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(data3);
+  EXPECT_EQ(net::OK, error);
+
+  EXPECT_TRUE(writer->AllExpectedWritesDone());
+  EXPECT_TRUE(compare_reader->AllExpectedReadsDone());
+  EXPECT_TRUE(copy_reader->AllExpectedReadsDone());
+}
+
+// Tests behavior when the cached data is shorter than the network data.
+TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopyShort) {
+  std::string data1 = "abcdef";
+  std::string cache_data2 = "mnop";
+  std::string net_data2 = "mnopqr";
+  std::string data3 = "stuvwxyz";
+  size_t cache_response_size = data1.size() + cache_data2.size() + data3.size();
+  size_t net_response_size = data1.size() + net_data2.size() + data3.size();
+
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  MockServiceWorkerResponseReader* compare_reader = ExpectReader();
+  MockServiceWorkerResponseReader* copy_reader = ExpectReader();
+
+  compare_reader->ExpectReadInfoOk(cache_response_size, false);
+  compare_reader->ExpectReadDataOk(data1, false);
+  compare_reader->ExpectReadDataOk(cache_data2, false);
+  compare_reader->ExpectReadDataOk("", false);  // EOF read
+
+  copy_reader->ExpectReadInfoOk(cache_response_size, false);
+  copy_reader->ExpectReadDataOk(data1, false);
+
+  writer->ExpectWriteInfoOk(net_response_size, false);
+  writer->ExpectWriteDataOk(data1.size(), false);
+  writer->ExpectWriteDataOk(net_data2.size(), false);
+  writer->ExpectWriteDataOk(data3.size(), false);
+
+  net::Error error = WriteHeaders(net_response_size);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(data1);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(net_data2);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(data3);
+  EXPECT_EQ(net::OK, error);
+
+  EXPECT_TRUE(writer->AllExpectedWritesDone());
+  EXPECT_TRUE(compare_reader->AllExpectedReadsDone());
+  EXPECT_TRUE(copy_reader->AllExpectedReadsDone());
+}
+
+// Tests behavior when the cached data is longer than the network data.
+TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopyLong) {
+  std::string data1 = "abcdef";
+  std::string cache_data2 = "mnop";
+  std::string net_data2 = "mnop";
+  std::string cache_data3 = "qr";
+  size_t cached_size = data1.size() + cache_data2.size() + cache_data3.size();
+  size_t net_size = data1.size() + net_data2.size();
+
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  MockServiceWorkerResponseReader* compare_reader = ExpectReader();
+  MockServiceWorkerResponseReader* copy_reader = ExpectReader();
+
+  compare_reader->ExpectReadInfoOk(cached_size, false);
+  compare_reader->ExpectReadDataOk(data1, false);
+  compare_reader->ExpectReadDataOk(cache_data2, false);
+
+  // The comparison should fail at the end of |cache_data2|, when the cache
+  // writer realizes the two responses are different sizes, and then the network
+  // data should be written back starting with |net_data2|.
+  copy_reader->ExpectReadInfoOk(cached_size, false);
+  copy_reader->ExpectReadDataOk(data1, false);
+
+  writer->ExpectWriteInfoOk(net_size, false);
+  writer->ExpectWriteDataOk(data1.size(), false);
+  writer->ExpectWriteDataOk(net_data2.size(), false);
+
+  net::Error error = WriteHeaders(net_size);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(data1);
+  EXPECT_EQ(net::OK, error);
+  error = WriteData(net_data2);
+  EXPECT_EQ(net::OK, error);
+
+  EXPECT_TRUE(writer->AllExpectedWritesDone());
+  EXPECT_TRUE(compare_reader->AllExpectedReadsDone());
+  EXPECT_TRUE(copy_reader->AllExpectedReadsDone());
+}
+
+}  // namespace
+}  // namespace content