Create blobs from Disk Cache entries.

content/browser/cache_storage/cache_storage_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/cache_storage/cache_storage_cache.h"
 
 #include <string>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_path.h"
@@ skipping 14 matching lines @@
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerResponseType.h"
 
 namespace content {
 
 namespace {
 
-typedef base::Callback<void(disk_cache::ScopedEntryPtr, bool)>
-    EntryBoolCallback;
+class CacheStorageCacheExtraData : public storage::BlobDataBuilder::ExtraData {
+ public:
+  explicit CacheStorageCacheExtraData(
+      const scoped_refptr<CacheStorageCache>& cache)
+      : cache_(cache) {}
+
+ private:
+  scoped_refptr<CacheStorageCache> cache_;
+};
+
 typedef base::Callback<void(scoped_ptr<CacheMetadata>)> MetadataCallback;
 
 enum EntryIndex { INDEX_HEADERS = 0, INDEX_RESPONSE_BODY };
 
 // The maximum size of an individual cache. Ultimately cache size is controlled
 // per-origin.
 const int kMaxCacheBytes = 512 * 1024 * 1024;
 
 // Buffer size for cache and blob reading/writing.
 const int kBufferSize = 1024 * 512;
@@ skipping 31 matching lines @@
       return CacheResponse::DEFAULT_TYPE;
     case blink::WebServiceWorkerResponseTypeError:
       return CacheResponse::ERROR_TYPE;
     case blink::WebServiceWorkerResponseTypeOpaque:
       return CacheResponse::OPAQUE_TYPE;
   }
   NOTREACHED();
   return CacheResponse::OPAQUE_TYPE;
 }
 
-// Copy headers out of a cache entry and into a protobuf. The callback is
-// guaranteed to be run.
-void ReadMetadata(disk_cache::Entry* entry, const MetadataCallback& callback);
-void ReadMetadataDidReadMetadata(
-    disk_cache::Entry* entry,
-    const MetadataCallback& callback,
-    const scoped_refptr<net::IOBufferWithSize>& buffer,
-    int rv);
-
 bool VaryMatches(const ServiceWorkerHeaderMap& request,
                  const ServiceWorkerHeaderMap& cached_request,
                  const ServiceWorkerHeaderMap& response) {
   ServiceWorkerHeaderMap::const_iterator vary_iter = response.find("vary");
   if (vary_iter == response.end())
     return true;
 
   std::vector<std::string> vary_keys;
   Tokenize(vary_iter->second, ",", &vary_keys);
   for (std::vector<std::string>::const_iterator it = vary_keys.begin();
@@ skipping 15 matching lines @@
     // If the header exists in one, it exists in both. Verify that the values
     // are equal.
     if (request_iter != request.end() &&
         request_iter->second != cached_request_iter->second)
       return false;
   }
 
   return true;
 }
 
-void ReadMetadata(disk_cache::Entry* entry, const MetadataCallback& callback) {
-  DCHECK(entry);
-
-  scoped_refptr<net::IOBufferWithSize> buffer(
-      new net::IOBufferWithSize(entry->GetDataSize(INDEX_HEADERS)));
-
-  net::CompletionCallback read_header_callback =
-      base::Bind(ReadMetadataDidReadMetadata, entry, callback, buffer);
-
-  int read_rv = entry->ReadData(INDEX_HEADERS, 0, buffer.get(), buffer->size(),
-                                read_header_callback);
-
-  if (read_rv != net::ERR_IO_PENDING)
-    read_header_callback.Run(read_rv);
-}
-
 void ReadMetadataDidReadMetadata(
     disk_cache::Entry* entry,
     const MetadataCallback& callback,
     const scoped_refptr<net::IOBufferWithSize>& buffer,
     int rv) {
   if (rv != buffer->size()) {
     callback.Run(scoped_ptr<CacheMetadata>());
     return;
   }
 
   scoped_ptr<CacheMetadata> metadata(new CacheMetadata());
 
   if (!metadata->ParseFromArray(buffer->data(), buffer->size())) {
     callback.Run(scoped_ptr<CacheMetadata>());
     return;
   }
 
   callback.Run(metadata.Pass());
 }
 
+// Copy headers out of a cache entry and into a protobuf. The callback is
+// guaranteed to be run.
+void ReadMetadata(disk_cache::Entry* entry, const MetadataCallback& callback) {
+  DCHECK(entry);
+
+  scoped_refptr<net::IOBufferWithSize> buffer(
+      new net::IOBufferWithSize(entry->GetDataSize(INDEX_HEADERS)));
+
+  net::CompletionCallback read_header_callback =
+      base::Bind(ReadMetadataDidReadMetadata, entry, callback, buffer);
+
+  int read_rv = entry->ReadData(INDEX_HEADERS, 0, buffer.get(), buffer->size(),
+                                read_header_callback);
+
+  if (read_rv != net::ERR_IO_PENDING)
+    read_header_callback.Run(read_rv);
+}
+
 }  // namespace
 
 // Streams data from a blob and writes it to a given disk_cache::Entry.
 class CacheStorageCache::BlobReader : public net::URLRequest::Delegate {
  public:
   typedef base::Callback<void(disk_cache::ScopedEntryPtr, bool)>
       EntryAndBoolCallback;
 
   BlobReader()
       : cache_entry_offset_(0),
@@ skipping 119 matching lines @@
 
   // Used for enumerating cache entries.
   scoped_ptr<disk_cache::Backend::Iterator> backend_iterator;
   disk_cache::Entry* enumerated_entry;
 
   DISALLOW_COPY_AND_ASSIGN(KeysContext);
 };
 
 struct CacheStorageCache::MatchContext {
   MatchContext(scoped_ptr<ServiceWorkerFetchRequest> request,
-               const CacheStorageCache::ResponseCallback& callback,
-               base::WeakPtr<storage::BlobStorageContext> blob_storage_context)
-      : request(request.Pass()),
-        original_callback(callback),
-        blob_storage_context(blob_storage_context),
-        entry(nullptr),
-        total_bytes_read(0) {}
+               const CacheStorageCache::ResponseCallback& callback)
+      : request(request.Pass()), original_callback(callback) {}
 
-  ~MatchContext() {
-    if (entry)
-      entry->Close();
-  }
-
-  // Input
   scoped_ptr<ServiceWorkerFetchRequest> request;
   CacheStorageCache::ResponseCallback original_callback;
-  base::WeakPtr<storage::BlobStorageContext> blob_storage_context;
-  disk_cache::Entry* entry;
-
-  // Output
-  scoped_ptr<ServiceWorkerResponse> response;
-  scoped_ptr<storage::BlobDataBuilder> blob_data;
-
-  // For reading the cache entry data into a blob.
-  scoped_refptr<net::IOBufferWithSize> response_body_buffer;
-  size_t total_bytes_read;
+  disk_cache::ScopedEntryPtr entry;
 
   DISALLOW_COPY_AND_ASSIGN(MatchContext);
 };
 
 // The state needed to pass between CacheStorageCache::Put callbacks.
 struct CacheStorageCache::PutContext {
   PutContext(
       const GURL& origin,
       scoped_ptr<ServiceWorkerFetchRequest> request,
       scoped_ptr<ServiceWorkerResponse> response,
       scoped_ptr<storage::BlobDataHandle> blob_data_handle,
       const CacheStorageCache::ErrorCallback& callback,
       net::URLRequestContext* request_context,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy)
       : origin(origin),
         request(request.Pass()),
         response(response.Pass()),
         blob_data_handle(blob_data_handle.Pass()),
         callback(callback),
         request_context(request_context),
-        quota_manager_proxy(quota_manager_proxy),
-        cache_entry(NULL) {}
-  ~PutContext() {
-    if (cache_entry)
-      cache_entry->Close();
-  }
+        quota_manager_proxy(quota_manager_proxy) {}
 
   // Input parameters to the Put function.
   GURL origin;
   scoped_ptr<ServiceWorkerFetchRequest> request;
   scoped_ptr<ServiceWorkerResponse> response;
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
   CacheStorageCache::ErrorCallback callback;
   net::URLRequestContext* request_context;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy;
-
-  // This isn't a scoped_ptr because the disk_cache needs an Entry** as input to
-  // CreateEntry.
-  disk_cache::Entry* cache_entry;
+  disk_cache::ScopedEntryPtr cache_entry;
 
   DISALLOW_COPY_AND_ASSIGN(PutContext);
 };
 
 // static
 scoped_refptr<CacheStorageCache> CacheStorageCache::CreateMemoryCache(
     const GURL& origin,
     net::URLRequestContext* request_context,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
@@ skipping 192 matching lines @@
                                   const ResponseCallback& callback) {
   DCHECK(backend_state_ != BACKEND_UNINITIALIZED);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   scoped_ptr<MatchContext> match_context(
-      new MatchContext(request.Pass(), callback, blob_storage_context_));
+      new MatchContext(request.Pass(), callback));
 
-  disk_cache::Entry** entry_ptr = &match_context->entry;
+  scoped_ptr<disk_cache::Entry*> scoped_entry_ptr(new disk_cache::Entry*());
+  disk_cache::Entry** entry_ptr = scoped_entry_ptr.get();
   ServiceWorkerFetchRequest* request_ptr = match_context->request.get();
 
   net::CompletionCallback open_entry_callback = base::Bind(
       &CacheStorageCache::MatchDidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
+      base::Passed(scoped_entry_ptr.Pass()),
       base::Passed(match_context.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 CacheStorageCache::MatchDidOpenEntry(
+    scoped_ptr<disk_cache::Entry*> entry_ptr,
     scoped_ptr<MatchContext> match_context,
     int rv) {
   if (rv != net::OK) {
     match_context->original_callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
                                          scoped_ptr<ServiceWorkerResponse>(),
                                          scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  // Copy the entry pointer before passing it in base::Bind.
-  disk_cache::Entry* tmp_entry_ptr = match_context->entry;
-  DCHECK(tmp_entry_ptr);
-
+  match_context->entry.reset(*entry_ptr);
   MetadataCallback headers_callback = base::Bind(
       &CacheStorageCache::MatchDidReadMetadata, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(match_context.Pass()));
 
-  ReadMetadata(tmp_entry_ptr, headers_callback);
+  ReadMetadata(*entry_ptr, headers_callback);
 }
 
 void CacheStorageCache::MatchDidReadMetadata(
     scoped_ptr<MatchContext> match_context,
     scoped_ptr<CacheMetadata> metadata) {
   if (!metadata) {
     match_context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                                          scoped_ptr<ServiceWorkerResponse>(),
                                          scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  match_context->response.reset(new ServiceWorkerResponse(
+  scoped_ptr<ServiceWorkerResponse> response(new ServiceWorkerResponse(
       match_context->request->url, metadata->response().status_code(),
       metadata->response().status_text(),
       ProtoResponseTypeToWebResponseType(metadata->response().response_type()),
       ServiceWorkerHeaderMap(), "", 0, GURL()));
 
-  ServiceWorkerResponse* response = match_context->response.get();
-
   if (metadata->response().has_url())
     response->url = GURL(metadata->response().url());
 
   for (int i = 0; i < metadata->response().headers_size(); ++i) {
     const CacheHeaderMap header = metadata->response().headers(i);
-    DCHECK(header.name().find('\0') == std::string::npos);
-    DCHECK(header.value().find('\0') == std::string::npos);
+    DCHECK_EQ(std::string::npos, header.name().find('\0'));
+    DCHECK_EQ(std::string::npos, header.value().find('\0'));
     response->headers.insert(std::make_pair(header.name(), header.value()));
   }
 
   ServiceWorkerHeaderMap cached_request_headers;
   for (int i = 0; i < metadata->request().headers_size(); ++i) {
     const CacheHeaderMap header = metadata->request().headers(i);
-    DCHECK(header.name().find('\0') == std::string::npos);
-    DCHECK(header.value().find('\0') == std::string::npos);
+    DCHECK_EQ(std::string::npos, header.name().find('\0'));
+    DCHECK_EQ(std::string::npos, header.value().find('\0'));
     cached_request_headers[header.name()] = header.value();
   }
 
   if (!VaryMatches(match_context->request->headers, cached_request_headers,
                    response->headers)) {
     match_context->original_callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
                                          scoped_ptr<ServiceWorkerResponse>(),
                                          scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   if (match_context->entry->GetDataSize(INDEX_RESPONSE_BODY) == 0) {
-    match_context->original_callback.Run(CACHE_STORAGE_OK,
-                                         match_context->response.Pass(),
+    match_context->original_callback.Run(CACHE_STORAGE_OK, response.Pass(),
                                          scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  // Stream the response body into a blob.
-  if (!match_context->blob_storage_context) {
+  if (!blob_storage_context_) {
     match_context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                                          scoped_ptr<ServiceWorkerResponse>(),
                                          scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
+  // Create a blob with the response body data.
+  response->blob_size = match_context->entry->GetDataSize(INDEX_RESPONSE_BODY);
   response->blob_uuid = base::GenerateGUID();
-
-  match_context->blob_data.reset(
+  scoped_ptr<storage::BlobDataBuilder> blob_data(
       new storage::BlobDataBuilder(response->blob_uuid));
-  match_context->response_body_buffer = new net::IOBufferWithSize(kBufferSize);
-
-  disk_cache::Entry* tmp_entry_ptr = match_context->entry;
-  net::IOBufferWithSize* response_body_buffer =
-      match_context->response_body_buffer.get();
-
-  net::CompletionCallback read_callback = base::Bind(
-      &CacheStorageCache::MatchDidReadResponseBodyData,
-      weak_ptr_factory_.GetWeakPtr(), base::Passed(match_context.Pass()));
-
-  int read_rv =
-      tmp_entry_ptr->ReadData(INDEX_RESPONSE_BODY, 0, response_body_buffer,
-                              response_body_buffer->size(), read_callback);
-
-  if (read_rv != net::ERR_IO_PENDING)
-    read_callback.Run(read_rv);
-}
-
-void CacheStorageCache::MatchDidReadResponseBodyData(
-    scoped_ptr<MatchContext> match_context,
-    int rv) {
-  if (rv < 0) {
-    match_context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
-                                         scoped_ptr<ServiceWorkerResponse>(),
-                                         scoped_ptr<storage::BlobDataHandle>());
-    return;
-  }
-
-  if (rv == 0) {
-    match_context->response->blob_uuid = match_context->blob_data->uuid();
-    match_context->response->blob_size = match_context->total_bytes_read;
-    MatchDoneWithBody(match_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.
-  match_context->blob_data->AppendData(
-      match_context->response_body_buffer->data(), rv);
-  match_context->total_bytes_read += rv;
-  int total_bytes_read = match_context->total_bytes_read;
-
-  // Grab some pointers before passing match_context in bind.
-  net::IOBufferWithSize* buffer = match_context->response_body_buffer.get();
-  disk_cache::Entry* tmp_entry_ptr = match_context->entry;
-
-  net::CompletionCallback read_callback = base::Bind(
-      &CacheStorageCache::MatchDidReadResponseBodyData,
-      weak_ptr_factory_.GetWeakPtr(), base::Passed(match_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 CacheStorageCache::MatchDoneWithBody(
-    scoped_ptr<MatchContext> match_context) {
-  if (!match_context->blob_storage_context) {
-    match_context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
-                                         scoped_ptr<ServiceWorkerResponse>(),
-                                         scoped_ptr<storage::BlobDataHandle>());
-    return;
-  }
-
+  blob_data->AppendDiskCacheEntry(
+      match_context->entry.Pass(), INDEX_RESPONSE_BODY,
+      make_scoped_ptr(new CacheStorageCacheExtraData(this)));
   scoped_ptr<storage::BlobDataHandle> blob_data_handle(
-      match_context->blob_storage_context->AddFinishedBlob(
-          match_context->blob_data.get()));
-
-  match_context->original_callback.Run(CACHE_STORAGE_OK,
-                                       match_context->response.Pass(),
+      blob_storage_context_->AddFinishedBlob(blob_data.get()));
+  match_context->original_callback.Run(CACHE_STORAGE_OK, response.Pass(),
                                        blob_data_handle.Pass());
 }
 
 void CacheStorageCache::Put(const CacheStorageBatchOperation& operation,
                             const ErrorCallback& callback) {
   DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
   DCHECK_EQ(CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT, operation.operation_type);
 
   scoped_ptr<ServiceWorkerFetchRequest> request(new ServiceWorkerFetchRequest(
       operation.request.url, operation.request.method,
@@ skipping 30 matching lines @@
   scoped_ptr<PutContext> put_context(new PutContext(
       origin_, request.Pass(), response.Pass(), blob_data_handle.Pass(),
       pending_callback, request_context_, quota_manager_proxy_));
 
   scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::PutImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            base::Passed(put_context.Pass())));
 }
 
 void CacheStorageCache::PutImpl(scoped_ptr<PutContext> put_context) {
-  DCHECK(backend_state_ != BACKEND_UNINITIALIZED);
+  DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   scoped_ptr<ServiceWorkerFetchRequest> request_copy(
       new ServiceWorkerFetchRequest(*put_context->request));
 
   DeleteImpl(request_copy.Pass(), base::Bind(&CacheStorageCache::PutDidDelete,
                                              weak_ptr_factory_.GetWeakPtr(),
                                              base::Passed(put_context.Pass())));
 }
 
 void CacheStorageCache::PutDidDelete(scoped_ptr<PutContext> put_context,
                                      CacheStorageError delete_error) {
   if (backend_state_ != BACKEND_OPEN) {
     put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
-  disk_cache::Entry** entry_ptr = &put_context->cache_entry;
+  scoped_ptr<disk_cache::Entry*> scoped_entry_ptr(new disk_cache::Entry*());
+  disk_cache::Entry** entry_ptr = scoped_entry_ptr.get();
   ServiceWorkerFetchRequest* request_ptr = put_context->request.get();
   disk_cache::Backend* backend_ptr = backend_.get();
 
   net::CompletionCallback create_entry_callback = base::Bind(
       &CacheStorageCache::PutDidCreateEntry, weak_ptr_factory_.GetWeakPtr(),
-      base::Passed(put_context.Pass()));
+      base::Passed(scoped_entry_ptr.Pass()), base::Passed(put_context.Pass()));
 
   int create_rv = backend_ptr->CreateEntry(request_ptr->url.spec(), entry_ptr,
                                            create_entry_callback);
 
   if (create_rv != net::ERR_IO_PENDING)
     create_entry_callback.Run(create_rv);
 }
 
-void CacheStorageCache::PutDidCreateEntry(scoped_ptr<PutContext> put_context,
-                                          int rv) {
+void CacheStorageCache::PutDidCreateEntry(
+    scoped_ptr<disk_cache::Entry*> entry_ptr,
+    scoped_ptr<PutContext> put_context,
+    int rv) {
   if (rv != net::OK) {
     put_context->callback.Run(CACHE_STORAGE_ERROR_EXISTS);
     return;
   }
-
-  DCHECK(put_context->cache_entry);
+  put_context->cache_entry.reset(*entry_ptr);
 
   CacheMetadata metadata;
   CacheRequest* request_metadata = metadata.mutable_request();
   request_metadata->set_method(put_context->request->method);
   for (ServiceWorkerHeaderMap::const_iterator it =
            put_context->request->headers.begin();
        it != put_context->request->headers.end(); ++it) {
     DCHECK(it->first.find('\0') == std::string::npos);
     DCHECK(it->second.find('\0') == std::string::npos);
     CacheHeaderMap* header_map = request_metadata->add_headers();
@@ skipping 20 matching lines @@
   scoped_ptr<std::string> serialized(new std::string());
   if (!metadata.SerializeToString(serialized.get())) {
     put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     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;
+  disk_cache::Entry* tmp_entry_ptr = put_context->cache_entry.get();
 
   net::CompletionCallback write_headers_callback = base::Bind(
       &CacheStorageCache::PutDidWriteHeaders, weak_ptr_factory_.GetWeakPtr(),
       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)
@@ skipping 19 matching lines @@
           storage::kStorageTypeTemporary,
           put_context->cache_entry->GetDataSize(INDEX_HEADERS));
     }
 
     put_context->callback.Run(CACHE_STORAGE_OK);
     return;
   }
 
   DCHECK(put_context->blob_data_handle);
 
-  disk_cache::ScopedEntryPtr entry(put_context->cache_entry);
-  put_context->cache_entry = NULL;
+  disk_cache::ScopedEntryPtr entry(put_context->cache_entry.Pass());
   scoped_ptr<BlobReader> reader(new BlobReader());
   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(
       entry.Pass(), request_context, blob_data_handle.Pass(),
       base::Bind(&CacheStorageCache::PutDidWriteBlobToCache,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(put_context.Pass()),
                  base::Passed(reader.Pass())));
 }
 
 void CacheStorageCache::PutDidWriteBlobToCache(
     scoped_ptr<PutContext> put_context,
     scoped_ptr<BlobReader> blob_reader,
     disk_cache::ScopedEntryPtr entry,
     bool success) {
   DCHECK(entry);
-  put_context->cache_entry = entry.release();
+  put_context->cache_entry = entry.Pass();
 
   if (!success) {
     put_context->cache_entry->Doom();
     put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   if (put_context->quota_manager_proxy.get()) {
     put_context->quota_manager_proxy->NotifyStorageModified(
         storage::QuotaClient::kServiceWorkerCache, put_context->origin,
@@ skipping 301 matching lines @@
     CacheStorageError error,
     scoped_ptr<Requests> requests) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run(error, requests.Pass());
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 }  // namespace content