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

content/browser/service_worker/service_worker_cache_writer.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 <algorithm>
 #include <string>
 
 #include "content/browser/appcache/appcache_response.h"
@@ skipping 97 matching lines @@
         NOTREACHED() << "Unknown state in DoLoop";
         state_ = STATE_DONE;
         break;
     }
   } while (status != net::ERR_IO_PENDING && state_ != STATE_DONE);
   io_pending_ = (status == net::ERR_IO_PENDING);
   return status;
 }
 
 ServiceWorkerCacheWriter::ServiceWorkerCacheWriter(
-    const ResponseReaderCreator& reader_creator,
-    const ResponseWriterCreator& writer_creator)
+    scoped_ptr<ServiceWorkerResponseReader> compare_reader,
+    scoped_ptr<ServiceWorkerResponseReader> copy_reader,
+    scoped_ptr<ServiceWorkerResponseWriter> writer)
     : state_(STATE_START),
       io_pending_(false),
       comparing_(false),
       did_replace_(false),
-      reader_creator_(reader_creator),
-      writer_creator_(writer_creator),
+      compare_reader_(std::move(compare_reader)),
+      copy_reader_(std::move(copy_reader)),
+      writer_(std::move(writer)),
       weak_factory_(this) {}
 
 ServiceWorkerCacheWriter::~ServiceWorkerCacheWriter() {}
 
 net::Error ServiceWorkerCacheWriter::MaybeWriteHeaders(
     HttpResponseInfoIOBuffer* headers,
     const OnWriteCompleteCallback& callback) {
   DCHECK(!io_pending_);
 
   headers_to_write_ = headers;
@@ skipping 53 matching lines @@
            state_ == STATE_WRITE_DATA_FOR_COPY_DONE ||
            state_ == STATE_WRITE_DATA_FOR_PASSTHROUGH_DONE)
         << "Unexpected state: " << state_;
   }
 
   return result >= 0 ? net::OK : static_cast<net::Error>(result);
 }
 
 int ServiceWorkerCacheWriter::DoStart(int result) {
   bytes_written_ = 0;
-  compare_reader_ = reader_creator_.Run();
-  if (compare_reader_.get()) {
+  if (compare_reader_) {
     state_ = STATE_READ_HEADERS_FOR_COMPARE;
     comparing_ = true;
   } else {
     // No existing reader, just write the headers back directly.
     state_ = STATE_WRITE_HEADERS_FOR_PASSTHROUGH;
     comparing_ = false;
   }
   return net::OK;
 }
 
@@ skipping 88 matching lines @@
 
   // bytes_compared_ only gets incremented when a full block is compared, to
   // avoid having to use only parts of the buffered network data.
   bytes_compared_ += result;
   state_ = STATE_DONE;
   return net::OK;
 }
 
 int ServiceWorkerCacheWriter::DoReadHeadersForCopy(int result) {
   DCHECK_GE(result, 0);
+  DCHECK(copy_reader_);
   bytes_copied_ = 0;
-  copy_reader_ = reader_creator_.Run();
   headers_to_read_ = new HttpResponseInfoIOBuffer;
   data_to_copy_ = new net::IOBuffer(kCopyBufferSize);
   state_ = STATE_READ_HEADERS_FOR_COPY_DONE;
   return ReadInfoHelper(copy_reader_, headers_to_read_.get());
 }
 
 int ServiceWorkerCacheWriter::DoReadHeadersForCopyDone(int result) {
   if (result < 0) {
     state_ = STATE_DONE;
     return result;
   }
   state_ = STATE_WRITE_HEADERS_FOR_COPY;
   return net::OK;
 }
 
 // Write the just-read headers back to the cache.
-// Note that this method must create |writer_|, since the only paths to this
-// state never create a writer.
-// Also note that this *discards* the read headers and replaces them with the
-// net headers.
+// Note that this *discards* the read headers and replaces them with the net
+// headers.
 int ServiceWorkerCacheWriter::DoWriteHeadersForCopy(int result) {
   DCHECK_GE(result, 0);
-  DCHECK(!writer_);
-  writer_ = writer_creator_.Run();
+  DCHECK(writer_);
   state_ = STATE_WRITE_HEADERS_FOR_COPY_DONE;
   return WriteInfoHelper(writer_, headers_to_write_.get());
 }
 
 int ServiceWorkerCacheWriter::DoWriteHeadersForCopyDone(int result) {
   if (result < 0) {
     state_ = STATE_DONE;
     return result;
   }
   state_ = STATE_READ_DATA_FOR_COPY;
@@ skipping 36 matching lines @@
     return result;
   }
   bytes_written_ += result;
   bytes_copied_ += result;
   state_ = STATE_READ_DATA_FOR_COPY;
   return result;
 }
 
 int ServiceWorkerCacheWriter::DoWriteHeadersForPassthrough(int result) {
   DCHECK_GE(result, 0);
-  writer_ = writer_creator_.Run();
+  DCHECK(writer_);
   state_ = STATE_WRITE_HEADERS_FOR_PASSTHROUGH_DONE;
   return WriteInfoHelper(writer_, headers_to_write_.get());
 }
 
 int ServiceWorkerCacheWriter::DoWriteHeadersForPassthroughDone(int result) {
   state_ = STATE_DONE;
   return result;
 }
 
 int ServiceWorkerCacheWriter::DoWriteDataForPassthrough(int result) {
@@ skipping 95 matching lines @@
   if (result != net::ERR_IO_PENDING) {
     OnWriteCompleteCallback callback = pending_callback_;
     pending_callback_.Reset();
     net::Error error = result >= 0 ? net::OK : static_cast<net::Error>(result);
     io_pending_ = false;
     callback.Run(error);
   }
 }
 
 }  // namespace content