ServiceWorkerWriteToCacheJob: refactor

content/browser/service_worker/service_worker_cache_writer_unittest.cc

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

[falken, 2015/08/28 05:45:24]

Is this include needed? can it just be <string>?

[Elly Fong-Jones, 2015/08/31 15:03:45]

Done.

+#include <list>
+#include <queue>
+
+#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 {
+
+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
+  void ExpectReadInfo(size_t len, bool async, int result);
+  void ExpectReadInfoOk(size_t len, bool async);
+  void ExpectReadData(const char* data, size_t len, bool async, int result);
+  void ExpectReadDataOk(const std::string& data, bool async);
+
+  void CompletePendingRead();
+  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);

[falken, 2015/08/28 05:45:24]

Some lightweight high-level comments for these classes and maybe functions would
be useful. Reading this the first time I'm a bit confused why the function's
assigning and copying stuff from "expected", usually I'd think a test just
compares stuff from "expected". In other words it looks like the expectations
affect the result, which is surprising.

[Elly Fong-Jones, 2015/08/31 15:03:45]

Done.

+  }
+  pending_info_ = nullptr;
+  pending_buffer_ = nullptr;
+  net::CompletionCallback callback = pending_callback_;
+  pending_callback_.Reset();
+  callback.Run(expected.result);
+}
+
+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;
+
+  // Test helpers
+  void ExpectWriteInfoOk(size_t len, bool async);
+  void ExpectWriteDataOk(size_t len, bool async);
+
+  void CompletePendingWrite();
+  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_->WriteHeaders(buf.get(), CreateWriteCallback());
+  }
+
+  net::Error WriteData(const std::string& data) {
+    scoped_refptr<net::IOBuffer> buf = new net::StringIOBuffer(data);
+    return cache_writer_->WriteData(buf.get(), data.size(),
+                                    CreateWriteCallback());
+  }
+};
+
+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_->BytesWritten());
+}
+
+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_->BytesWritten());
+}
+
+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());
+}
+
+TEST_F(ServiceWorkerCacheWriterTest, CompareHeadersSync) {

[falken, 2015/08/28 05:45:24]

It's a little magical to me how we seemed to switch from Passthrough mode to
Compare mode between the previous test and this test. Is the creation of
ExpectReader() what causes the switch? As I said some comments may be nice for
reading this file.

[Elly Fong-Jones, 2015/08/31 15:03:46]

Done.

+  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_->BytesWritten());
+}
+
+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";

[falken, 2015/08/28 05:45:24]

Should there be cache_data1 or net_data1?

[Elly Fong-Jones, 2015/08/31 15:03:45]

No; they both use data1 as a shared prefix.

+  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);
+}
+
+TEST_F(ServiceWorkerCacheWriterTest, CompareDataOkAsync) {
+  const std::string data1 = "abcdef";
+  size_t response_size = data1.size();
+
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  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(writer->AllExpectedWritesDone());
+  EXPECT_TRUE(reader->AllExpectedReadsDone());
+}
+
+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();
+
+  MockServiceWorkerResponseWriter* writer = ExpectWriter();
+  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(writer->AllExpectedWritesDone());
+  EXPECT_TRUE(reader->AllExpectedReadsDone());
+}
+
+// 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);
+}
+
+// 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);
+}
+
+// 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);
+
+  copy_reader->ExpectReadInfoOk(cached_size, false);
+  copy_reader->ExpectReadDataOk(data1, false);
+  copy_reader->ExpectReadDataOk(cache_data2, 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);
+}
+
+}  // namespace
+}  // namespace content