Convert Pass()→std::move() in //content/browser

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 <stddef.h>
-
 #include <string>
+#include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_blob_to_disk_cache.h"
@@ skipping 16 matching lines @@
 
 namespace {
 
 // This class ensures that the cache and the entry have a lifetime as long as
 // the blob that is created to contain them.
 class CacheStorageCacheDataHandle
     : public storage::BlobDataBuilder::DataHandle {
  public:
   CacheStorageCacheDataHandle(const scoped_refptr<CacheStorageCache>& cache,
                               disk_cache::ScopedEntryPtr entry)
-      : cache_(cache), entry_(entry.Pass()) {}
+      : cache_(cache), entry_(std::move(entry)) {}
 
  private:
   ~CacheStorageCacheDataHandle() override {}
 
   scoped_refptr<CacheStorageCache> cache_;
   disk_cache::ScopedEntryPtr entry_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorageCacheDataHandle);
 };
 
@@ skipping 116 matching lines @@
     return;
   }
 
   scoped_ptr<CacheMetadata> metadata(new CacheMetadata());
 
   if (!metadata->ParseFromArray(buffer->data(), buffer->size())) {
     callback.Run(scoped_ptr<CacheMetadata>());
     return;
   }
 
-  callback.Run(metadata.Pass());
+  callback.Run(std::move(metadata));
 }
 
 }  // namespace
 
 // The state needed to iterate all entries in the cache.
 struct CacheStorageCache::OpenAllEntriesContext {
   OpenAllEntriesContext() : enumerated_entry(nullptr) {}
   ~OpenAllEntriesContext() {
     for (size_t i = 0, max = entries.size(); i < max; ++i) {
       if (entries[i])
@@ skipping 59 matching lines @@
 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,
       const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy)
       : origin(origin),
-        request(request.Pass()),
-        response(response.Pass()),
-        blob_data_handle(blob_data_handle.Pass()),
+        request(std::move(request)),
+        response(std::move(response)),
+        blob_data_handle(std::move(blob_data_handle)),
         callback(callback),
         request_context_getter(request_context_getter),
         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;
@@ skipping 41 matching lines @@
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   ResponseCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingResponseCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(request.Pass()), pending_callback));
+                 base::Passed(std::move(request)), pending_callback));
 }
 
 void CacheStorageCache::MatchAll(const ResponsesCallback& callback) {
   if (!LazyInitialize()) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, scoped_ptr<Responses>(),
                  scoped_ptr<BlobDataHandles>());
     return;
   }
 
   ResponsesCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingResponsesCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::MatchAllImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            pending_callback));
 }
 
 void CacheStorageCache::BatchOperation(
     const std::vector<CacheStorageBatchOperation>& operations,
     const ErrorCallback& callback) {
   if (!LazyInitialize()) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   scoped_ptr<ErrorCallback> callback_copy(new ErrorCallback(callback));
   ErrorCallback* callback_ptr = callback_copy.get();
   base::Closure barrier_closure = base::BarrierClosure(
-      operations.size(), base::Bind(&CacheStorageCache::BatchDidAllOperations,
-                                    this, base::Passed(callback_copy.Pass())));
+      operations.size(),
+      base::Bind(&CacheStorageCache::BatchDidAllOperations, this,
+                 base::Passed(std::move(callback_copy))));
   ErrorCallback completion_callback =
       base::Bind(&CacheStorageCache::BatchDidOneOperation, this,
                  barrier_closure, callback_ptr);
 
   for (const auto& operation : operations) {
     switch (operation.operation_type) {
       case CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT:
         Put(operation, completion_callback);
         break;
       case CACHE_STORAGE_CACHE_OPERATION_TYPE_DELETE:
@@ skipping 120 matching lines @@
 }
 
 void CacheStorageCache::OpenAllEntries(const OpenAllEntriesCallback& callback) {
   scoped_ptr<OpenAllEntriesContext> entries_context(new OpenAllEntriesContext);
   entries_context->backend_iterator = backend_->CreateIterator();
   disk_cache::Backend::Iterator& iterator = *entries_context->backend_iterator;
   disk_cache::Entry** enumerated_entry = &entries_context->enumerated_entry;
 
   net::CompletionCallback open_entry_callback = base::Bind(
       &CacheStorageCache::DidOpenNextEntry, weak_ptr_factory_.GetWeakPtr(),
-      base::Passed(entries_context.Pass()), callback);
+      base::Passed(std::move(entries_context)), callback);
 
   int rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void CacheStorageCache::DidOpenNextEntry(
     scoped_ptr<OpenAllEntriesContext> entries_context,
     const OpenAllEntriesCallback& callback,
     int rv) {
   if (rv == net::ERR_FAILED) {
     DCHECK(!entries_context->enumerated_entry);
     // Enumeration is complete, extract the requests from the entries.
-    callback.Run(entries_context.Pass(), CACHE_STORAGE_OK);
+    callback.Run(std::move(entries_context), CACHE_STORAGE_OK);
     return;
   }
 
   if (rv < 0) {
-    callback.Run(entries_context.Pass(), CACHE_STORAGE_ERROR_STORAGE);
+    callback.Run(std::move(entries_context), CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   if (backend_state_ != BACKEND_OPEN) {
-    callback.Run(entries_context.Pass(), CACHE_STORAGE_ERROR_NOT_FOUND);
+    callback.Run(std::move(entries_context), CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
   // Store the entry.
   entries_context->entries.push_back(entries_context->enumerated_entry);
   entries_context->enumerated_entry = nullptr;
 
   // Enumerate the next entry.
   disk_cache::Backend::Iterator& iterator = *entries_context->backend_iterator;
   disk_cache::Entry** enumerated_entry = &entries_context->enumerated_entry;
   net::CompletionCallback open_entry_callback = base::Bind(
       &CacheStorageCache::DidOpenNextEntry, weak_ptr_factory_.GetWeakPtr(),
-      base::Passed(entries_context.Pass()), callback);
+      base::Passed(std::move(entries_context)), callback);
 
   rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void CacheStorageCache::MatchImpl(scoped_ptr<ServiceWorkerFetchRequest> request,
                                   const ResponseCallback& callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   scoped_ptr<disk_cache::Entry*> scoped_entry_ptr(new disk_cache::Entry*());
   disk_cache::Entry** entry_ptr = scoped_entry_ptr.get();
   ServiceWorkerFetchRequest* request_ptr = request.get();
 
-  net::CompletionCallback open_entry_callback =
-      base::Bind(&CacheStorageCache::MatchDidOpenEntry,
-                 weak_ptr_factory_.GetWeakPtr(), base::Passed(request.Pass()),
-                 callback, base::Passed(scoped_entry_ptr.Pass()));
+  net::CompletionCallback open_entry_callback = base::Bind(
+      &CacheStorageCache::MatchDidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
+      base::Passed(std::move(request)), callback,
+      base::Passed(std::move(scoped_entry_ptr)));
 
   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<ServiceWorkerFetchRequest> request,
     const ResponseCallback& callback,
     scoped_ptr<disk_cache::Entry*> entry_ptr,
     int rv) {
   if (rv != net::OK) {
     callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
   disk_cache::ScopedEntryPtr entry(*entry_ptr);
 
   MetadataCallback headers_callback = base::Bind(
       &CacheStorageCache::MatchDidReadMetadata, weak_ptr_factory_.GetWeakPtr(),
-      base::Passed(request.Pass()), callback, base::Passed(entry.Pass()));
+      base::Passed(std::move(request)), callback,
+      base::Passed(std::move(entry)));
 
   ReadMetadata(*entry_ptr, headers_callback);
 }
 
 void CacheStorageCache::MatchDidReadMetadata(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ResponseCallback& callback,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<CacheMetadata> metadata) {
   if (!metadata) {
@@ skipping 16 matching lines @@
 
   if (!VaryMatches(request->headers, cached_request_headers,
                    response->headers)) {
     callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   if (entry->GetDataSize(INDEX_RESPONSE_BODY) == 0) {
-    callback.Run(CACHE_STORAGE_OK, response.Pass(),
+    callback.Run(CACHE_STORAGE_OK, std::move(response),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   if (!blob_storage_context_) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   scoped_ptr<storage::BlobDataHandle> blob_data_handle =
-      PopulateResponseBody(entry.Pass(), response.get());
-  callback.Run(CACHE_STORAGE_OK, response.Pass(), blob_data_handle.Pass());
+      PopulateResponseBody(std::move(entry), response.get());
+  callback.Run(CACHE_STORAGE_OK, std::move(response),
+               std::move(blob_data_handle));
 }
 
 void CacheStorageCache::MatchAllImpl(const ResponsesCallback& callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, scoped_ptr<Responses>(),
                  scoped_ptr<BlobDataHandles>());
     return;
   }
 
   OpenAllEntries(base::Bind(&CacheStorageCache::MatchAllDidOpenAllEntries,
                             weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void CacheStorageCache::MatchAllDidOpenAllEntries(
     const ResponsesCallback& callback,
     scoped_ptr<OpenAllEntriesContext> entries_context,
     CacheStorageError error) {
   if (error != CACHE_STORAGE_OK) {
     callback.Run(error, scoped_ptr<Responses>(), scoped_ptr<BlobDataHandles>());
     return;
   }
 
   scoped_ptr<MatchAllContext> context(new MatchAllContext(callback));
   context->entries_context.swap(entries_context);
   Entries::iterator iter = context->entries_context->entries.begin();
-  MatchAllProcessNextEntry(context.Pass(), iter);
+  MatchAllProcessNextEntry(std::move(context), iter);
 }
 
 void CacheStorageCache::MatchAllProcessNextEntry(
     scoped_ptr<MatchAllContext> context,
     const Entries::iterator& iter) {
   if (iter == context->entries_context->entries.end()) {
     // All done. Return all of the responses.
     context->original_callback.Run(CACHE_STORAGE_OK,
-                                   context->out_responses.Pass(),
-                                   context->out_blob_data_handles.Pass());
+                                   std::move(context->out_responses),
+                                   std::move(context->out_blob_data_handles));
     return;
   }
 
   ReadMetadata(*iter, base::Bind(&CacheStorageCache::MatchAllDidReadMetadata,
                                  weak_ptr_factory_.GetWeakPtr(),
-                                 base::Passed(context.Pass()), iter));
+                                 base::Passed(std::move(context)), iter));
 }
 
 void CacheStorageCache::MatchAllDidReadMetadata(
     scoped_ptr<MatchAllContext> context,
     const Entries::iterator& iter,
     scoped_ptr<CacheMetadata> metadata) {
   // Move ownership of the entry from the context.
   disk_cache::ScopedEntryPtr entry(*iter);
   *iter = nullptr;
 
   if (!metadata) {
     entry->Doom();
-    MatchAllProcessNextEntry(context.Pass(), iter + 1);
+    MatchAllProcessNextEntry(std::move(context), iter + 1);
     return;
   }
 
   ServiceWorkerResponse response;
   PopulateResponseMetadata(*metadata, &response);
 
   if (entry->GetDataSize(INDEX_RESPONSE_BODY) == 0) {
     context->out_responses->push_back(response);
-    MatchAllProcessNextEntry(context.Pass(), iter + 1);
+    MatchAllProcessNextEntry(std::move(context), iter + 1);
     return;
   }
 
   if (!blob_storage_context_) {
     context->original_callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                                    scoped_ptr<Responses>(),
                                    scoped_ptr<BlobDataHandles>());
     return;
   }
 
   scoped_ptr<storage::BlobDataHandle> blob_data_handle =
-      PopulateResponseBody(entry.Pass(), &response);
+      PopulateResponseBody(std::move(entry), &response);
 
   context->out_responses->push_back(response);
   context->out_blob_data_handles->push_back(*blob_data_handle);
-  MatchAllProcessNextEntry(context.Pass(), iter + 1);
+  MatchAllProcessNextEntry(std::move(context), iter + 1);
 }
 
 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,
       operation.request.headers, operation.request.referrer,
@@ skipping 24 matching lines @@
     if (!blob_data_handle) {
       callback.Run(CACHE_STORAGE_ERROR_STORAGE);
       return;
     }
   }
 
   ErrorCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingErrorCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
 
-  scoped_ptr<PutContext> put_context(new PutContext(
-      origin_, request.Pass(), response.Pass(), blob_data_handle.Pass(),
-      pending_callback, request_context_getter_, quota_manager_proxy_));
+  scoped_ptr<PutContext> put_context(
+      new PutContext(origin_, std::move(request), std::move(response),
+                     std::move(blob_data_handle), pending_callback,
+                     request_context_getter_, quota_manager_proxy_));
 
-  scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::PutImpl,
-                                           weak_ptr_factory_.GetWeakPtr(),
-                                           base::Passed(put_context.Pass())));
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorageCache::PutImpl, weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(std::move(put_context))));
 }
 
 void CacheStorageCache::PutImpl(scoped_ptr<PutContext> put_context) {
   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())));
+  DeleteImpl(std::move(request_copy),
+             base::Bind(&CacheStorageCache::PutDidDelete,
+                        weak_ptr_factory_.GetWeakPtr(),
+                        base::Passed(std::move(put_context))));
 }
 
 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;
   }
 
   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(scoped_entry_ptr.Pass()), base::Passed(put_context.Pass()));
+      base::Passed(std::move(scoped_entry_ptr)),
+      base::Passed(std::move(put_context)));
 
   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<disk_cache::Entry*> entry_ptr,
@@ skipping 34 matching lines @@
     header_map->set_value(it->second);
   }
 
   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()));
+      new net::StringIOBuffer(std::move(serialized)));
 
   // Get a temporary copy of the entry pointer before passing it in base::Bind.
   disk_cache::Entry* temp_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());
+      base::Passed(std::move(put_context)), buffer->size());
 
   rv = temp_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 CacheStorageCache::PutDidWriteHeaders(scoped_ptr<PutContext> put_context,
@@ skipping 15 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.Pass());
+  disk_cache::ScopedEntryPtr entry(std::move(put_context->cache_entry));
   put_context->cache_entry = NULL;
 
   CacheStorageBlobToDiskCache* blob_to_cache =
       new CacheStorageBlobToDiskCache();
   BlobToDiskCacheIDMap::KeyType blob_to_cache_key =
       active_blob_to_disk_cache_writers_.Add(blob_to_cache);
 
   // Grab some pointers before passing put_context in Bind.
   scoped_refptr<net::URLRequestContextGetter> request_context_getter =
       put_context->request_context_getter;
   scoped_ptr<storage::BlobDataHandle> blob_data_handle =
-      put_context->blob_data_handle.Pass();
+      std::move(put_context->blob_data_handle);
 
   blob_to_cache->StreamBlobToCache(
-      entry.Pass(), INDEX_RESPONSE_BODY, request_context_getter,
-      blob_data_handle.Pass(),
+      std::move(entry), INDEX_RESPONSE_BODY, request_context_getter,
+      std::move(blob_data_handle),
       base::Bind(&CacheStorageCache::PutDidWriteBlobToCache,
                  weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(put_context.Pass()), blob_to_cache_key));
+                 base::Passed(std::move(put_context)), blob_to_cache_key));
 }
 
 void CacheStorageCache::PutDidWriteBlobToCache(
     scoped_ptr<PutContext> put_context,
     BlobToDiskCacheIDMap::KeyType blob_to_cache_key,
     disk_cache::ScopedEntryPtr entry,
     bool success) {
   DCHECK(entry);
-  put_context->cache_entry = entry.Pass();
+  put_context->cache_entry = std::move(entry);
 
   active_blob_to_disk_cache_writers_.Remove(blob_to_cache_key);
 
   if (!success) {
     put_context->cache_entry->Doom();
     put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   if (put_context->quota_manager_proxy.get()) {
@@ skipping 16 matching lines @@
   scoped_ptr<ServiceWorkerFetchRequest> request(new ServiceWorkerFetchRequest(
       operation.request.url, operation.request.method,
       operation.request.headers, operation.request.referrer,
       operation.request.is_reload));
 
   ErrorCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingErrorCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::DeleteImpl, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(request.Pass()), pending_callback));
+                 base::Passed(std::move(request)), pending_callback));
 }
 
 void CacheStorageCache::DeleteImpl(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ErrorCallback& callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
   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(
       &CacheStorageCache::DeleteDidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
-      origin_, base::Passed(request.Pass()), callback,
-      base::Passed(entry.Pass()), quota_manager_proxy_);
+      origin_, base::Passed(std::move(request)), callback,
+      base::Passed(std::move(entry)), quota_manager_proxy_);
 
   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::DeleteDidOpenEntry(
     const GURL& origin,
     scoped_ptr<ServiceWorkerFetchRequest> request,
@@ skipping 47 matching lines @@
     scoped_ptr<OpenAllEntriesContext> entries_context,
     CacheStorageError error) {
   if (error != CACHE_STORAGE_OK) {
     callback.Run(error, scoped_ptr<Requests>());
     return;
   }
 
   scoped_ptr<KeysContext> keys_context(new KeysContext(callback));
   keys_context->entries_context.swap(entries_context);
   Entries::iterator iter = keys_context->entries_context->entries.begin();
-  KeysProcessNextEntry(keys_context.Pass(), iter);
+  KeysProcessNextEntry(std::move(keys_context), iter);
 }
 
 void CacheStorageCache::KeysProcessNextEntry(
     scoped_ptr<KeysContext> keys_context,
     const Entries::iterator& iter) {
   if (iter == keys_context->entries_context->entries.end()) {
     // All done. Return all of the keys.
     keys_context->original_callback.Run(CACHE_STORAGE_OK,
-                                        keys_context->out_keys.Pass());
+                                        std::move(keys_context->out_keys));
     return;
   }
 
   ReadMetadata(*iter, base::Bind(&CacheStorageCache::KeysDidReadMetadata,
                                  weak_ptr_factory_.GetWeakPtr(),
-                                 base::Passed(keys_context.Pass()), iter));
+                                 base::Passed(std::move(keys_context)), iter));
 }
 
 void CacheStorageCache::KeysDidReadMetadata(
     scoped_ptr<KeysContext> keys_context,
     const Entries::iterator& iter,
     scoped_ptr<CacheMetadata> metadata) {
   disk_cache::Entry* entry = *iter;
 
   if (metadata) {
     keys_context->out_keys->push_back(ServiceWorkerFetchRequest(
         GURL(entry->GetKey()), metadata->request().method(),
         ServiceWorkerHeaderMap(), Referrer(), false));
 
     ServiceWorkerHeaderMap& req_headers =
         keys_context->out_keys->back().headers;
 
     for (int i = 0; i < metadata->request().headers_size(); ++i) {
       const CacheHeaderMap header = metadata->request().headers(i);
       DCHECK_EQ(std::string::npos, header.name().find('\0'));
       DCHECK_EQ(std::string::npos, header.value().find('\0'));
       req_headers.insert(std::make_pair(header.name(), header.value()));
     }
   } else {
     entry->Doom();
   }
 
-  KeysProcessNextEntry(keys_context.Pass(), iter + 1);
+  KeysProcessNextEntry(std::move(keys_context), iter + 1);
 }
 
 void CacheStorageCache::CloseImpl(const base::Closure& callback) {
   DCHECK_NE(BACKEND_CLOSED, backend_state_);
 
   backend_state_ = BACKEND_CLOSED;
   backend_.reset();
   callback.Run();
 }
 
 void CacheStorageCache::CreateBackend(const ErrorCallback& callback) {
   DCHECK(!backend_);
 
   // Use APP_CACHE as opposed to DISK_CACHE to prevent cache eviction.
   net::CacheType cache_type = memory_only_ ? net::MEMORY_CACHE : net::APP_CACHE;
 
   scoped_ptr<ScopedBackendPtr> backend_ptr(new ScopedBackendPtr());
 
   // Temporary pointer so that backend_ptr can be Pass()'d in Bind below.
   ScopedBackendPtr* backend = backend_ptr.get();
 
   net::CompletionCallback create_cache_callback =
       base::Bind(&CacheStorageCache::CreateBackendDidCreate,
                  weak_ptr_factory_.GetWeakPtr(), callback,
-                 base::Passed(backend_ptr.Pass()));
+                 base::Passed(std::move(backend_ptr)));
 
   // TODO(jkarlin): Use the cache task runner that ServiceWorkerCacheCore
   // has for disk caches.
   int rv = disk_cache::CreateCacheBackend(
       cache_type, net::CACHE_BACKEND_SIMPLE, path_, 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 CacheStorageCache::CreateBackendDidCreate(
     const CacheStorageCache::ErrorCallback& callback,
     scoped_ptr<ScopedBackendPtr> backend_ptr,
     int rv) {
   if (rv != net::OK) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
-  backend_ = backend_ptr->Pass();
+  backend_ = std::move(*backend_ptr);
   callback.Run(CACHE_STORAGE_OK);
 }
 
 void CacheStorageCache::InitBackend() {
   DCHECK_EQ(BACKEND_UNINITIALIZED, backend_state_);
 
   if (initializing_)
     return;
 
   DCHECK(!scheduler_->ScheduledOperations());
@@ skipping 35 matching lines @@
     scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorageCache::PendingResponseCallback(
     const ResponseCallback& callback,
     CacheStorageError error,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
-  callback.Run(error, response.Pass(), blob_data_handle.Pass());
+  callback.Run(error, std::move(response), std::move(blob_data_handle));
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorageCache::PendingResponsesCallback(
     const ResponsesCallback& callback,
     CacheStorageError error,
     scoped_ptr<Responses> responses,
     scoped_ptr<BlobDataHandles> blob_data_handles) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
-  callback.Run(error, responses.Pass(), blob_data_handles.Pass());
+  callback.Run(error, std::move(responses), std::move(blob_data_handles));
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorageCache::PendingRequestsCallback(
     const RequestsCallback& callback,
     CacheStorageError error,
     scoped_ptr<Requests> requests) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
-  callback.Run(error, requests.Pass());
+  callback.Run(error, std::move(requests));
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorageCache::PopulateResponseMetadata(
     const CacheMetadata& metadata,
     ServiceWorkerResponse* response) {
   *response = ServiceWorkerResponse(
       GURL(metadata.response().url()), metadata.response().status_code(),
       metadata.response().status_text(),
@@ skipping 14 matching lines @@
     ServiceWorkerResponse* response) {
   DCHECK(blob_storage_context_);
 
   // Create a blob with the response body data.
   response->blob_size = entry->GetDataSize(INDEX_RESPONSE_BODY);
   response->blob_uuid = base::GenerateGUID();
   storage::BlobDataBuilder blob_data(response->blob_uuid);
 
   disk_cache::Entry* temp_entry = entry.get();
   blob_data.AppendDiskCacheEntry(
-      new CacheStorageCacheDataHandle(this, entry.Pass()), temp_entry,
+      new CacheStorageCacheDataHandle(this, std::move(entry)), temp_entry,
       INDEX_RESPONSE_BODY);
   return blob_storage_context_->AddFinishedBlob(&blob_data);
 }
 
 }  // namespace content