Make a context struct for ServiceWorkerCache::Put callbacks.

content/browser/service_worker/service_worker_cache.cc

 // Copyright 2014 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.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
@@ skipping 37 matching lines @@
   scoped_refptr<net::IOBufferWithSize> buffer;
   scoped_refptr<storage::BlobData> blob_data;
   int total_bytes_read;
 
   DISALLOW_COPY_AND_ASSIGN(ResponseReadContext);
 };
 
 // Streams data from a blob and writes it to a given disk_cache::Entry.
 class BlobReader : public net::URLRequest::Delegate {
  public:
-  typedef base::Callback<void(disk_cache::ScopedEntryPtr, bool)>
-      EntryBoolCallback;
+  typedef base::Callback<void(bool)> BoolCallback;
 
   BlobReader(disk_cache::ScopedEntryPtr entry)
       : cache_entry_offset_(0),
         buffer_(new net::IOBufferWithSize(kBufferSize)),
         weak_ptr_factory_(this) {
     DCHECK(entry);
     entry_ = entry.Pass();
   }
 
   void StreamBlobToCache(net::URLRequestContext* request_context,
                          scoped_ptr<storage::BlobDataHandle> blob_data_handle,
-                         const EntryBoolCallback& callback) {
+                         const BoolCallback& callback) {
     callback_ = callback;
     blob_request_ = storage::BlobProtocolHandler::CreateBlobRequest(
         blob_data_handle.Pass(), request_context, this);
     blob_request_->Start();
   }
 
   // net::URLRequest::Delegate overrides for reading blobs.
   virtual void OnReceivedRedirect(net::URLRequest* request,
                                   const net::RedirectInfo& redirect_info,
                                   bool* defer_redirect) OVERRIDE {
@@ skipping 13 matching lines @@
                                      bool fatal) OVERRIDE {
     NOTREACHED();
   }
   virtual void OnBeforeNetworkStart(net::URLRequest* request,
                                     bool* defer) OVERRIDE {
     NOTREACHED();
   }
 
   virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE {
     if (!request->status().is_success()) {
-      callback_.Run(entry_.Pass(), false);
+      callback_.Run(false);
       return;
     }
     ReadFromBlob();
   }
 
   virtual void ReadFromBlob() {
     int bytes_read = 0;
     bool done =
         blob_request_->Read(buffer_.get(), buffer_->size(), &bytes_read);
     if (done)
       OnReadCompleted(blob_request_.get(), bytes_read);
   }
 
   virtual void OnReadCompleted(net::URLRequest* request,
                                int bytes_read) OVERRIDE {
     if (!request->status().is_success()) {
-      callback_.Run(entry_.Pass(), false);
+      callback_.Run(false);
       return;
     }
 
     if (bytes_read == 0) {
-      callback_.Run(entry_.Pass(), true);
+      callback_.Run(true);
       return;
     }
 
     net::CompletionCallback cache_write_callback =
         base::Bind(&BlobReader::DidWriteDataToEntry,
                    weak_ptr_factory_.GetWeakPtr(),
                    bytes_read);
 
     int rv = entry_->WriteData(INDEX_RESPONSE_BODY,
                                cache_entry_offset_,
                                buffer_.get(),
                                bytes_read,
                                cache_write_callback,
                                true /* truncate */);
     if (rv != net::ERR_IO_PENDING)
       cache_write_callback.Run(rv);
   }
 
   void DidWriteDataToEntry(int expected_bytes, int rv) {
     if (rv != expected_bytes) {
-      callback_.Run(entry_.Pass(), false);
+      callback_.Run(false);
       return;
     }
 
     cache_entry_offset_ += rv;
     ReadFromBlob();
   }
 
  private:
   int cache_entry_offset_;
   disk_cache::ScopedEntryPtr entry_;
   scoped_ptr<net::URLRequest> blob_request_;
-  EntryBoolCallback callback_;
+  BoolCallback callback_;
   scoped_refptr<net::IOBufferWithSize> buffer_;
   base::WeakPtrFactory<BlobReader> weak_ptr_factory_;
 };
 
+// The state needed to pass between ServiceWorkerCache::Put callbacks.
+struct PutContext {
+  PutContext(scoped_ptr<ServiceWorkerFetchRequest> request,
+             scoped_ptr<ServiceWorkerResponse> response,
+             scoped_ptr<storage::BlobDataHandle> blob_data_handle,
+             const ServiceWorkerCache::ErrorCallback& callback,
+             net::URLRequestContext* request_context)
+      : request(request.Pass()),
+        response(response.Pass()),
+        blob_data_handle(blob_data_handle.Pass()),
+        callback(callback),
+        request_context(request_context),
+        cache_entry(NULL) {}
+  ~PutContext() {
+    if (cache_entry)
+      cache_entry->Close();
+  }
+
+  // Input parameters to the Put function.
+  scoped_ptr<ServiceWorkerFetchRequest> request;
+  scoped_ptr<ServiceWorkerResponse> response;
+  scoped_ptr<storage::BlobDataHandle> blob_data_handle;
+  ServiceWorkerCache::ErrorCallback callback;
+
+  net::URLRequestContext* request_context;
+  disk_cache::Entry* cache_entry;

[horo, 2014/09/26 02:15:02]

Why don't you use ScopedEntryPtr?

[jkarlin, 2014/09/26 11:15:02]

Because the asynchronous disk_cache API wants an Entry** for CreateEntry.  I've
added a comment. 

[horo, 2014/09/29 03:13:24]

Ah, I got it.

+
+  DISALLOW_COPY_AND_ASSIGN(PutContext);
+};
+
 // Put callbacks
-void PutDidCreateEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
-                       scoped_ptr<ServiceWorkerResponse> response,
-                       const ServiceWorkerCache::ErrorCallback& callback,
-                       scoped_ptr<disk_cache::Entry*> entryptr,
-                       scoped_ptr<storage::BlobDataHandle> blob_data_handle,
-                       net::URLRequestContext* request_context,
-                       int rv);
-void PutDidWriteHeaders(scoped_ptr<ServiceWorkerResponse> response,
-                        const ServiceWorkerCache::ErrorCallback& callback,
-                        disk_cache::ScopedEntryPtr entry,
-                        scoped_ptr<storage::BlobDataHandle> blob_data_handle,
-                        net::URLRequestContext* request_context,
+void PutDidCreateEntry(scoped_ptr<PutContext> put_context, int rv);
+void PutDidWriteHeaders(scoped_ptr<PutContext> put_context,
                         int expected_bytes,
                         int rv);
-void PutDidWriteBlobToCache(const ServiceWorkerCache::ErrorCallback& callback,
+void PutDidWriteBlobToCache(scoped_ptr<PutContext> put_context,
                             scoped_ptr<BlobReader> blob_reader,
-                            disk_cache::ScopedEntryPtr entry,
                             bool success);
 
 // Match callbacks
 void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        int rv);
 void MatchDidReadHeaderData(
     scoped_ptr<ServiceWorkerFetchRequest> request,
@@ skipping 29 matching lines @@
     const HeadersCallback& callback,
     const scoped_refptr<net::IOBufferWithSize>& buffer,
     int rv);
 
 // CreateBackend callbacks
 void CreateBackendDidCreate(const ServiceWorkerCache::ErrorCallback& callback,
                             scoped_ptr<ScopedBackendPtr> backend_ptr,
                             base::WeakPtr<ServiceWorkerCache> cache,
                             int rv);
 
-void PutDidCreateEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
-                       scoped_ptr<ServiceWorkerResponse> response,
-                       const ServiceWorkerCache::ErrorCallback& callback,
-                       scoped_ptr<disk_cache::Entry*> entryptr,
-                       scoped_ptr<storage::BlobDataHandle> blob_data_handle,
-                       net::URLRequestContext* request_context,
-                       int rv) {
+void PutDidCreateEntry(scoped_ptr<PutContext> put_context, int rv) {
   if (rv != net::OK) {
-    callback.Run(ServiceWorkerCache::ErrorTypeExists);
+    put_context->callback.Run(ServiceWorkerCache::ErrorTypeExists);
     return;
   }
 
-  DCHECK(entryptr);
-  disk_cache::ScopedEntryPtr entry(*entryptr);
+  DCHECK(put_context->cache_entry);
 
   ServiceWorkerRequestResponseHeaders headers;
-  headers.set_method(request->method);
+  headers.set_method(put_context->request->method);
 
-  headers.set_status_code(response->status_code);
-  headers.set_status_text(response->status_text);
-  for (ServiceWorkerHeaderMap::const_iterator it = request->headers.begin();
-       it != request->headers.end();
+  headers.set_status_code(put_context->response->status_code);
+  headers.set_status_text(put_context->response->status_text);
+  for (ServiceWorkerHeaderMap::const_iterator it =
+           put_context->request->headers.begin();
+       it != put_context->request->headers.end();
        ++it) {
     ServiceWorkerRequestResponseHeaders::HeaderMap* header_map =
         headers.add_request_headers();
     header_map->set_name(it->first);
     header_map->set_value(it->second);
   }
 
-  for (ServiceWorkerHeaderMap::const_iterator it = response->headers.begin();
-       it != response->headers.end();
+  for (ServiceWorkerHeaderMap::const_iterator it =
+           put_context->response->headers.begin();
+       it != put_context->response->headers.end();
        ++it) {
     ServiceWorkerRequestResponseHeaders::HeaderMap* header_map =
         headers.add_response_headers();
     header_map->set_name(it->first);
     header_map->set_value(it->second);
   }
 
   scoped_ptr<std::string> serialized(new std::string());
   if (!headers.SerializeToString(serialized.get())) {
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage);
+    put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage);
     return;
   }
 
   scoped_refptr<net::StringIOBuffer> buffer(
       new net::StringIOBuffer(serialized.Pass()));
 
   // Get a temporary copy of the entry pointer before passing it in base::Bind.
-  disk_cache::Entry* tmp_entry_ptr = entry.get();
+  disk_cache::Entry* tmp_entry_ptr = put_context->cache_entry;
 
-  net::CompletionCallback write_headers_callback =
-      base::Bind(PutDidWriteHeaders,
-                 base::Passed(response.Pass()),
-                 callback,
-                 base::Passed(entry.Pass()),
-                 base::Passed(blob_data_handle.Pass()),
-                 request_context,
-                 buffer->size());
+  net::CompletionCallback write_headers_callback = base::Bind(
+      PutDidWriteHeaders, base::Passed(put_context.Pass()), buffer->size());
 
   rv = tmp_entry_ptr->WriteData(INDEX_HEADERS,
                                 0 /* offset */,
                                 buffer.get(),
                                 buffer->size(),
                                 write_headers_callback,
                                 true /* truncate */);
 
   if (rv != net::ERR_IO_PENDING)
     write_headers_callback.Run(rv);
 }
 
-void PutDidWriteHeaders(scoped_ptr<ServiceWorkerResponse> response,
-                        const ServiceWorkerCache::ErrorCallback& callback,
-                        disk_cache::ScopedEntryPtr entry,
-                        scoped_ptr<storage::BlobDataHandle> blob_data_handle,
-                        net::URLRequestContext* request_context,
+void PutDidWriteHeaders(scoped_ptr<PutContext> put_context,
                         int expected_bytes,
                         int rv) {
   if (rv != expected_bytes) {
-    entry->Doom();
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage);
+    put_context->cache_entry->Doom();
+    put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage);
     return;
   }
 
   // The metadata is written, now for the response content. The data is streamed
   // from the blob into the cache entry.
 
-  if (response->blob_uuid.empty()) {
-    callback.Run(ServiceWorkerCache::ErrorTypeOK);
+  if (put_context->response->blob_uuid.empty()) {
+    put_context->callback.Run(ServiceWorkerCache::ErrorTypeOK);
     return;
   }
 
-  DCHECK(blob_data_handle);
+  DCHECK(put_context->blob_data_handle);
 
+  disk_cache::ScopedEntryPtr entry(put_context->cache_entry);
+  put_context->cache_entry = NULL;
   scoped_ptr<BlobReader> reader(new BlobReader(entry.Pass()));
+
   BlobReader* reader_ptr = reader.get();
 
-  reader_ptr->StreamBlobToCache(
-      request_context,
-      blob_data_handle.Pass(),
-      base::Bind(
-          PutDidWriteBlobToCache, callback, base::Passed(reader.Pass())));
+  // Grab some pointers before passing put_context in Bind.
+  net::URLRequestContext* request_context = put_context->request_context;
+  scoped_ptr<storage::BlobDataHandle> blob_data_handle =
+      put_context->blob_data_handle.Pass();
+
+  reader_ptr->StreamBlobToCache(request_context,
+                                blob_data_handle.Pass(),
+                                base::Bind(PutDidWriteBlobToCache,
+                                           base::Passed(put_context.Pass()),
+                                           base::Passed(reader.Pass())));
 }
 
-void PutDidWriteBlobToCache(const ServiceWorkerCache::ErrorCallback& callback,
+void PutDidWriteBlobToCache(scoped_ptr<PutContext> put_context,
                             scoped_ptr<BlobReader> blob_reader,
-                            disk_cache::ScopedEntryPtr entry,
                             bool success) {
   if (!success) {
-    entry->Doom();
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage);
+    put_context->cache_entry->Doom();
+    put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage);
     return;
   }
 
-  callback.Run(ServiceWorkerCache::ErrorTypeOK);
+  put_context->callback.Run(ServiceWorkerCache::ErrorTypeOK);
 }
 
 void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        int rv) {
   if (rv != net::OK) {
     callback.Run(ServiceWorkerCache::ErrorTypeNotFound,
                  scoped_ptr<ServiceWorkerResponse>(),
@@ skipping 306 matching lines @@
 
   // The vector of open entries in the backend.
   Entries entries;
 
   // The output of the Keys function.
   scoped_ptr<ServiceWorkerCache::Requests> out_keys;
 
   // Used for enumerating cache entries.
   scoped_ptr<disk_cache::Backend::Iterator> backend_iterator;
   disk_cache::Entry* enumerated_entry;
+
+  DISALLOW_COPY_AND_ASSIGN(KeysContext);
 };
 
 // static
 scoped_refptr<ServiceWorkerCache> ServiceWorkerCache::CreateMemoryCache(
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
   return make_scoped_refptr(
       new ServiceWorkerCache(base::FilePath(), request_context, blob_context));
 }
 
@@ skipping 10 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerCache> ServiceWorkerCache::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void ServiceWorkerCache::Put(scoped_ptr<ServiceWorkerFetchRequest> request,
                              scoped_ptr<ServiceWorkerResponse> response,
                              const ErrorCallback& callback) {
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
-
   if (!response->blob_uuid.empty()) {
     if (!blob_storage_context_) {
       callback.Run(ErrorTypeStorage);
       return;
     }
     blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(response->blob_uuid);
     if (!blob_data_handle) {
       callback.Run(ErrorTypeStorage);
       return;
@@ skipping 137 matching lines @@
 void ServiceWorkerCache::PutImpl(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle,
     const ErrorCallback& callback) {
   if (!backend_) {
     callback.Run(ErrorTypeStorage);
     return;
   }
 
-  scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
+  scoped_ptr<PutContext> put_context(new PutContext(request.Pass(),
+                                                    response.Pass(),
+                                                    blob_data_handle.Pass(),
+                                                    callback,
+                                                    request_context_));
 
-  disk_cache::Entry** entry_ptr = entry.get();
-
-  ServiceWorkerFetchRequest* request_ptr = request.get();
+  disk_cache::Entry** entry_ptr = &put_context->cache_entry;
+  ServiceWorkerFetchRequest* request_ptr = put_context->request.get();
 
   net::CompletionCallback create_entry_callback =
-      base::Bind(PutDidCreateEntry,
-                 base::Passed(request.Pass()),
-                 base::Passed(response.Pass()),
-                 callback,
-                 base::Passed(entry.Pass()),
-                 base::Passed(blob_data_handle.Pass()),
-                 request_context_);
+      base::Bind(PutDidCreateEntry, base::Passed(put_context.Pass()));
 
   int rv = backend_->CreateEntry(
       request_ptr->url.spec(), entry_ptr, create_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     create_entry_callback.Run(rv);
 }
 
 // static
 void ServiceWorkerCache::KeysDidOpenNextEntry(
@@ skipping 132 matching lines @@
   initialized_ = true;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
        ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
 }  // namespace content