ServiceWorker: Stop asynchronously creating response accessors to fix crash due to null context

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 <stddef.h>
 
 #include <list>
 #include <queue>
@@ skipping 296 matching lines @@
   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;
   }
 
+  // This should be called after ExpectReader() and ExpectWriter().
+  void Initialize() {
+    scoped_ptr<ServiceWorkerResponseReader> compare_reader(CreateReader());
+    scoped_ptr<ServiceWorkerResponseReader> copy_reader(CreateReader());
+    scoped_ptr<ServiceWorkerResponseWriter> writer(CreateWriter());
+    cache_writer_.reset(new ServiceWorkerCacheWriter(
+        std::move(compare_reader), std::move(copy_reader), std::move(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_;
+  bool write_complete_ = false;
   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;
   }
   scoped_ptr<ServiceWorkerResponseWriter> CreateWriter() {
@@ skipping 30 matching lines @@
 // 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);
+  Initialize();
 
   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);
+  Initialize();
 
   net::Error error = WriteHeaders(kHeaderSize);
   EXPECT_EQ(net::ERR_IO_PENDING, error);
   EXPECT_FALSE(write_complete_);
   writer->CompletePendingWrite();
   EXPECT_TRUE(write_complete_);
   EXPECT_EQ(net::OK, last_error_);
   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);
+  Initialize();
 
   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);
+  Initialize();
 
   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_EQ(net::OK, last_error_);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
 }
 
 TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersFailSync) {
   const size_t kHeaderSize = 16;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfo(kHeaderSize, false, net::ERR_FAILED);
+  Initialize();
 
   net::Error error = WriteHeaders(kHeaderSize);
   EXPECT_EQ(net::ERR_FAILED, error);
   EXPECT_FALSE(write_complete_);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
 TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersFailAsync) {
   size_t kHeaderSize = 16;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfo(kHeaderSize, true, net::ERR_FAILED);
+  Initialize();
 
   net::Error error = WriteHeaders(kHeaderSize);
   EXPECT_EQ(net::ERR_IO_PENDING, error);
   EXPECT_FALSE(write_complete_);
   writer->CompletePendingWrite();
   EXPECT_TRUE(write_complete_);
   EXPECT_EQ(net::ERR_FAILED, last_error_);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
 TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataFailSync) {
   const std::string data = "abcdef";
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfoOk(data.size(), false);
   writer->ExpectWriteData(data.size(), false, net::ERR_FAILED);
+  Initialize();
 
   EXPECT_EQ(net::OK, WriteHeaders(data.size()));
   EXPECT_EQ(net::ERR_FAILED, WriteData(data));
   EXPECT_TRUE(writer->AllExpectedWritesDone());
 }
 
 TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataFailAsync) {
   const std::string data = "abcdef";
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfoOk(data.size(), false);
   writer->ExpectWriteData(data.size(), true, net::ERR_FAILED);
+  Initialize();
 
   EXPECT_EQ(net::OK, WriteHeaders(data.size()));
 
   EXPECT_EQ(net::ERR_IO_PENDING, WriteData(data));
   writer->CompletePendingWrite();
   EXPECT_EQ(net::ERR_FAILED, last_error_);
   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);
+  Initialize();
 
   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);
+  Initialize();
 
   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, CompareHeadersFailSync) {
   size_t response_size = 3;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* reader = ExpectReader();
 
   reader->ExpectReadInfo(response_size, false, net::ERR_FAILED);
+  Initialize();
 
   EXPECT_EQ(net::ERR_FAILED, WriteHeaders(response_size));
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_TRUE(reader->AllExpectedReadsDone());
 }
 
 TEST_F(ServiceWorkerCacheWriterTest, CompareDataFailSync) {
   const std::string data1 = "abcdef";
   size_t response_size = data1.size();
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* reader = ExpectReader();
 
   reader->ExpectReadInfoOk(response_size, false);
   reader->ExpectReadData(data1.c_str(), data1.length(), false, net::ERR_FAILED);
+  Initialize();
 
   net::Error error = WriteHeaders(response_size);
   EXPECT_EQ(net::OK, error);
 
   EXPECT_EQ(net::ERR_FAILED, WriteData(data1));
 
   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);
+  Initialize();
 
   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);
+  Initialize();
 
   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);
   }
+  Initialize();
 
   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_);
@@ skipping 24 matching lines @@
   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);
 
+  Initialize();
+
   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());
@@ skipping 20 matching lines @@
   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);
 
+  Initialize();
+
   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());
@@ skipping 22 matching lines @@
   // 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);
   copy_reader->ExpectReadDataOk(net_data2, false);
 
   writer->ExpectWriteInfoOk(net_size, false);
   writer->ExpectWriteDataOk(data1.size(), false);
   writer->ExpectWriteDataOk(net_data2.size(), false);
 
+  Initialize();
+
   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);
   error = WriteData("");
   EXPECT_EQ(net::OK, error);
 
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_TRUE(compare_reader->AllExpectedReadsDone());
   EXPECT_TRUE(copy_reader->AllExpectedReadsDone());
 }
 
 }  // namespace
 }  // namespace content