Have ServiceWorkerCache::Put return a Response when completed.

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 148 matching lines @@
   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,
+             const ServiceWorkerCache::ResponseCallback& 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;
+  ServiceWorkerCache::ResponseCallback callback;
 
   net::URLRequestContext* request_context;
 
   // This isn't a scoped_ptr because the disk_cache needs an Entry** as input to
   // CreateEntry.
   disk_cache::Entry* cache_entry;
 
+  // The BlobDataHandle for the output ServiceWorkerResponse.
+  scoped_ptr<storage::BlobDataHandle> out_blob_data_handle;
+
   DISALLOW_COPY_AND_ASSIGN(PutContext);
 };
 
 // Put callbacks
 void PutDidCreateEntry(scoped_ptr<PutContext> put_context, int rv);
 void PutDidWriteHeaders(scoped_ptr<PutContext> put_context,
                         int expected_bytes,
                         int rv);
 void PutDidWriteBlobToCache(scoped_ptr<PutContext> put_context,
                             scoped_ptr<BlobReader> blob_reader,
@@ skipping 41 matching lines @@
     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<PutContext> put_context, int rv) {
   if (rv != net::OK) {
-    put_context->callback.Run(ServiceWorkerCache::ErrorTypeExists);
+    put_context->callback.Run(ServiceWorkerCache::ErrorTypeExists,
+                              scoped_ptr<ServiceWorkerResponse>(),
+                              scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   DCHECK(put_context->cache_entry);
 
   ServiceWorkerRequestResponseHeaders headers;
   headers.set_method(put_context->request->method);
 
   headers.set_status_code(put_context->response->status_code);
   headers.set_status_text(put_context->response->status_text);
@@ skipping 12 matching lines @@
        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())) {
-    put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage);
+    put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage,
+                              scoped_ptr<ServiceWorkerResponse>(),
+                              scoped_ptr<storage::BlobDataHandle>());
     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 = put_context->cache_entry;
 
   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<PutContext> put_context,
                         int expected_bytes,
                         int rv) {
   if (rv != expected_bytes) {
     put_context->cache_entry->Doom();
-    put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage);
+    put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage,
+                              scoped_ptr<ServiceWorkerResponse>(),
+                              scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   // The metadata is written, now for the response content. The data is streamed
   // from the blob into the cache entry.
 
   if (put_context->response->blob_uuid.empty()) {
-    put_context->callback.Run(ServiceWorkerCache::ErrorTypeOK);
+    put_context->callback.Run(ServiceWorkerCache::ErrorTypeOK,
+                              put_context->response.Pass(),
+                              scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   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();
 
   // 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(scoped_ptr<PutContext> put_context,
                             scoped_ptr<BlobReader> blob_reader,
                             bool success) {
   if (!success) {
     put_context->cache_entry->Doom();
-    put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage);
+    put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage,
+                              scoped_ptr<ServiceWorkerResponse>(),
+                              scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  put_context->callback.Run(ServiceWorkerCache::ErrorTypeOK);
+  put_context->callback.Run(ServiceWorkerCache::ErrorTypeOK,
+                            put_context->response.Pass(),
+                            put_context->out_blob_data_handle.Pass());
 }
 
 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 336 matching lines @@
 
 ServiceWorkerCache::~ServiceWorkerCache() {
 }
 
 base::WeakPtr<ServiceWorkerCache> ServiceWorkerCache::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void ServiceWorkerCache::Put(scoped_ptr<ServiceWorkerFetchRequest> request,
                              scoped_ptr<ServiceWorkerResponse> response,
-                             const ErrorCallback& callback) {
+                             const ResponseCallback& callback) {
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
+
   if (!response->blob_uuid.empty()) {
     if (!blob_storage_context_) {
-      callback.Run(ErrorTypeStorage);
+      callback.Run(ErrorTypeStorage,
+                   scoped_ptr<ServiceWorkerResponse>(),
+                   scoped_ptr<storage::BlobDataHandle>());
       return;
     }
     blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(response->blob_uuid);
     if (!blob_data_handle) {
-      callback.Run(ErrorTypeStorage);
+      callback.Run(ErrorTypeStorage,
+                   scoped_ptr<ServiceWorkerResponse>(),
+                   scoped_ptr<storage::BlobDataHandle>());
       return;
     }
   }
 
   base::Closure continuation = base::Bind(&ServiceWorkerCache::PutImpl,
                                           weak_ptr_factory_.GetWeakPtr(),
                                           base::Passed(request.Pass()),
                                           base::Passed(response.Pass()),
                                           base::Passed(blob_data_handle.Pass()),
                                           callback);
@@ skipping 122 matching lines @@
       request_context_(request_context),
       blob_storage_context_(blob_context),
       initialized_(false),
       weak_ptr_factory_(this) {
 }
 
 void ServiceWorkerCache::PutImpl(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle,
-    const ErrorCallback& callback) {
+    const ResponseCallback& callback) {
   if (!backend_) {
-    callback.Run(ErrorTypeStorage);
+    callback.Run(ErrorTypeStorage,
+                 scoped_ptr<ServiceWorkerResponse>(),
+                 scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   scoped_ptr<PutContext> put_context(new PutContext(request.Pass(),
                                                     response.Pass(),
                                                     blob_data_handle.Pass(),
                                                     callback,
                                                     request_context_));
 
+  if (put_context->blob_data_handle) {
+    // Grab another handle to the blob for the callback response.
+    put_context->out_blob_data_handle =
+        blob_storage_context_->GetBlobDataFromUUID(
+            put_context->response->blob_uuid);
+  }
+
   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(put_context.Pass()));
 
   int rv = backend_->CreateEntry(
       request_ptr->url.spec(), entry_ptr, create_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
@@ skipping 137 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