Change ownership of the parameters to ServiceWorkerCache:: Put and Match.

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 144 matching lines @@
  private:
   int cache_entry_offset_;
   disk_cache::ScopedEntryPtr entry_;
   scoped_ptr<net::URLRequest> blob_request_;
   EntryBoolCallback callback_;
   scoped_refptr<net::IOBufferWithSize> buffer_;
   base::WeakPtrFactory<BlobReader> weak_ptr_factory_;
 };
 
 // Put callbacks
-void PutDidCreateEntry(ServiceWorkerFetchRequest* request,
-                       ServiceWorkerResponse* response,
+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(ServiceWorkerResponse* response,
+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,
                         int expected_bytes,
                         int rv);
 void PutDidWriteBlobToCache(const ServiceWorkerCache::ErrorCallback& callback,
                             scoped_ptr<BlobReader> blob_reader,
                             disk_cache::ScopedEntryPtr entry,
                             bool success);
 
 // Match callbacks
-void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
+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(
-    ServiceWorkerFetchRequest* request,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerRequestResponseHeaders> headers);
 void MatchDidReadResponseBodyData(
-    ServiceWorkerFetchRequest* request,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<ResponseReadContext> response_context,
     int rv);
-void MatchDoneWithBody(ServiceWorkerFetchRequest* request,
+void MatchDoneWithBody(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<ServiceWorkerResponse> response,
                        scoped_ptr<ResponseReadContext> response_context);
 
 // Delete callbacks
-void DeleteDidOpenEntry(ServiceWorkerFetchRequest* request,
+void DeleteDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                         const ServiceWorkerCache::ErrorCallback& callback,
                         scoped_ptr<disk_cache::Entry*> entryptr,
                         int rv);
 
 // Copy headers out of a cache entry and into a protobuf. The callback is
 // guaranteed to be run.
 void ReadHeaders(disk_cache::Entry* entry, const HeadersCallback& callback);
 void ReadHeadersDidReadHeaderData(
     disk_cache::Entry* entry,
     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(ServiceWorkerFetchRequest* request,
-                       ServiceWorkerResponse* response,
+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) {
   if (rv != net::OK) {
     callback.Run(ServiceWorkerCache::ErrorTypeExists);
     return;
   }
 
@@ skipping 32 matching lines @@
   }
 
   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();
 
   net::CompletionCallback write_headers_callback =
       base::Bind(PutDidWriteHeaders,
-                 response,
+                 base::Passed(response.Pass()),
                  callback,
                  base::Passed(entry.Pass()),
                  base::Passed(blob_data_handle.Pass()),
                  request_context,
                  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(ServiceWorkerResponse* response,
+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,
                         int expected_bytes,
                         int rv) {
   if (rv != expected_bytes) {
     entry->Doom();
     callback.Run(ServiceWorkerCache::ErrorTypeStorage);
     return;
@@ skipping 25 matching lines @@
                             bool success) {
   if (!success) {
     entry->Doom();
     callback.Run(ServiceWorkerCache::ErrorTypeStorage);
     return;
   }
 
   callback.Run(ServiceWorkerCache::ErrorTypeOK);
 }
 
-void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
+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>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   DCHECK(entryptr);
   disk_cache::ScopedEntryPtr entry(*entryptr);
 
   // Copy the entry pointer before passing it in base::Bind.
   disk_cache::Entry* tmp_entry_ptr = entry.get();
 
   HeadersCallback headers_callback = base::Bind(MatchDidReadHeaderData,
-                                                request,
+                                                base::Passed(request.Pass()),
                                                 callback,
                                                 blob_storage,
                                                 base::Passed(entry.Pass()));
 
   ReadHeaders(tmp_entry_ptr, headers_callback);
 }
 
 void MatchDidReadHeaderData(
-    ServiceWorkerFetchRequest* request,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerRequestResponseHeaders> headers) {
   if (!headers) {
     callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
@@ skipping 36 matching lines @@
       new net::IOBufferWithSize(kBufferSize));
 
   scoped_ptr<ResponseReadContext> read_context(
       new ResponseReadContext(response_body_buffer, blob_data));
 
   // Copy the entry pointer before passing it in base::Bind.
   disk_cache::Entry* tmp_entry_ptr = entry.get();
 
   net::CompletionCallback read_callback =
       base::Bind(MatchDidReadResponseBodyData,
-                 request,
+                 base::Passed(request.Pass()),
                  callback,
                  blob_storage,
                  base::Passed(entry.Pass()),
                  base::Passed(response.Pass()),
                  base::Passed(read_context.Pass()));
 
   int read_rv = tmp_entry_ptr->ReadData(INDEX_RESPONSE_BODY,
                                         0,
                                         response_body_buffer.get(),
                                         response_body_buffer->size(),
                                         read_callback);
 
   if (read_rv != net::ERR_IO_PENDING)
     read_callback.Run(read_rv);
 }
 
 void MatchDidReadResponseBodyData(
-    ServiceWorkerFetchRequest* request,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<ResponseReadContext> response_context,
     int rv) {
   if (rv < 0) {
     callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   if (rv == 0) {
-    MatchDoneWithBody(request,
+    MatchDoneWithBody(request.Pass(),
                       callback,
                       blob_storage,
                       response.Pass(),
                       response_context.Pass());
     return;
   }
 
   // TODO(jkarlin): This copying of the the entire cache response into memory is
   // awful. Create a new interface around SimpleCache that provides access the
   // data directly from the file. See bug http://crbug.com/403493.
   response_context->blob_data->AppendData(response_context->buffer->data(), rv);
   response_context->total_bytes_read += rv;
   int total_bytes_read = response_context->total_bytes_read;
 
   // Grab some pointers before passing them in bind.
   net::IOBufferWithSize* buffer = response_context->buffer.get();
   disk_cache::Entry* tmp_entry_ptr = entry.get();
 
   net::CompletionCallback read_callback =
       base::Bind(MatchDidReadResponseBodyData,
-                 request,
+                 base::Passed(request.Pass()),
                  callback,
                  blob_storage,
                  base::Passed(entry.Pass()),
                  base::Passed(response.Pass()),
                  base::Passed(response_context.Pass()));
 
   int read_rv = tmp_entry_ptr->ReadData(INDEX_RESPONSE_BODY,
                                         total_bytes_read,
                                         buffer,
                                         buffer->size(),
                                         read_callback);
 
   if (read_rv != net::ERR_IO_PENDING)
     read_callback.Run(read_rv);
 }
 
-void MatchDoneWithBody(ServiceWorkerFetchRequest* request,
+void MatchDoneWithBody(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<ServiceWorkerResponse> response,
                        scoped_ptr<ResponseReadContext> response_context) {
   if (!blob_storage) {
     callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   scoped_ptr<storage::BlobDataHandle> blob_data_handle(
       blob_storage->AddFinishedBlob(response_context->blob_data.get()));
 
   callback.Run(ServiceWorkerCache::ErrorTypeOK,
                response.Pass(),
                blob_data_handle.Pass());
 }
 
-void DeleteDidOpenEntry(ServiceWorkerFetchRequest* request,
+void DeleteDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                         const ServiceWorkerCache::ErrorCallback& callback,
                         scoped_ptr<disk_cache::Entry*> entryptr,
                         int rv) {
   if (rv != net::OK) {
     callback.Run(ServiceWorkerCache::ErrorTypeNotFound);
     return;
   }
 
   DCHECK(entryptr);
   disk_cache::ScopedEntryPtr entry(*entryptr);
@@ skipping 143 matching lines @@
       kMaxCacheBytes,
       false, /* force */
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE).get(),
       NULL,
       backend,
       create_cache_callback);
   if (rv != net::ERR_IO_PENDING)
     create_cache_callback.Run(rv);
 }
 
-void ServiceWorkerCache::Put(ServiceWorkerFetchRequest* request,
-                             ServiceWorkerResponse* response,
+void ServiceWorkerCache::Put(scoped_ptr<ServiceWorkerFetchRequest> request,
+                             scoped_ptr<ServiceWorkerResponse> response,
                              const ErrorCallback& callback) {
   DCHECK(backend_);
 
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
   disk_cache::Entry** entry_ptr = entry.get();
 
   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;
     }
   }
 
+  ServiceWorkerFetchRequest* request_ptr = request.get();
+
   net::CompletionCallback create_entry_callback =
       base::Bind(PutDidCreateEntry,
-                 request,
-                 response,
+                 base::Passed(request.Pass()),
+                 base::Passed(response.Pass()),
                  callback,
                  base::Passed(entry.Pass()),
                  base::Passed(blob_data_handle.Pass()),
                  request_context_);
 
   int rv = backend_->CreateEntry(
-      request->url.spec(), entry_ptr, create_entry_callback);
+      request_ptr->url.spec(), entry_ptr, create_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     create_entry_callback.Run(rv);
 }
 
-void ServiceWorkerCache::Match(ServiceWorkerFetchRequest* request,
+void ServiceWorkerCache::Match(scoped_ptr<ServiceWorkerFetchRequest> request,
                                const ResponseCallback& callback) {
   DCHECK(backend_);
 
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
   disk_cache::Entry** entry_ptr = entry.get();
 
+  ServiceWorkerFetchRequest* request_ptr = request.get();
+
   net::CompletionCallback open_entry_callback =
       base::Bind(MatchDidOpenEntry,
-                 request,
+                 base::Passed(request.Pass()),
                  callback,
                  blob_storage_context_,
                  base::Passed(entry.Pass()));
 
-  int rv =
-      backend_->OpenEntry(request->url.spec(), entry_ptr, open_entry_callback);
+  int rv = backend_->OpenEntry(
+      request_ptr->url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
-void ServiceWorkerCache::Delete(ServiceWorkerFetchRequest* request,
+void ServiceWorkerCache::Delete(scoped_ptr<ServiceWorkerFetchRequest> request,
                                 const ErrorCallback& callback) {
   DCHECK(backend_);
 
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
   disk_cache::Entry** entry_ptr = entry.get();
 
-  net::CompletionCallback open_entry_callback = base::Bind(
-      DeleteDidOpenEntry, request, callback, base::Passed(entry.Pass()));
+  ServiceWorkerFetchRequest* request_ptr = request.get();
 
-  int rv =
-      backend_->OpenEntry(request->url.spec(), entry_ptr, open_entry_callback);
+  net::CompletionCallback open_entry_callback =
+      base::Bind(DeleteDidOpenEntry,
+                 base::Passed(request.Pass()),
+                 callback,
+                 base::Passed(entry.Pass()));
+
+  int rv = backend_->OpenEntry(
+      request_ptr->url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void ServiceWorkerCache::Keys(const RequestsCallback& callback) {
   DCHECK(backend_);
 
   // 1. Iterate through all of the entries, open them, and add them to a vector.
   // 2. For each open entry:
   //  2.1. Read the headers into a protobuf.
@@ skipping 111 matching lines @@
       req_headers.insert(std::make_pair(header.name(), header.value()));
     }
   } else {
     entry->Doom();
   }
 
   KeysProcessNextEntry(keys_context.Pass(), iter + 1);
 }
 
 }  // namespace content