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

content/browser/service_worker/service_worker_url_request_job.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_url_request_job.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <limits>
 #include <map>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
@@ skipping 445 matching lines @@
         info->GetPageTransition(), ui::PAGE_TRANSITION_RELOAD);
     request->referrer =
         Referrer(GURL(request_->referrer()), info->GetReferrerPolicy());
   } else {
     CHECK(
         request_->referrer_policy() ==
         net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE);
     request->referrer =
         Referrer(GURL(request_->referrer()), blink::WebReferrerPolicyDefault);
   }
-  return request.Pass();
+  return request;
 }
 
 bool ServiceWorkerURLRequestJob::CreateRequestBodyBlob(std::string* blob_uuid,
                                                        uint64_t* blob_size) {
   if (!body_.get() || !blob_storage_context_)
     return false;
 
   // To ensure the blobs stick around until the end of the reading.
   std::vector<scoped_ptr<storage::BlobDataHandle>> handles;
   std::vector<scoped_ptr<storage::BlobDataSnapshot>> snapshots;
   // TODO(dmurph): Allow blobs to be added below, so that the context can
   // efficiently re-use blob items for the new blob.
   std::vector<const ResourceRequestBody::Element*> resolved_elements;
   for (const ResourceRequestBody::Element& element : (*body_->elements())) {
     if (element.type() != ResourceRequestBody::Element::TYPE_BLOB) {
       resolved_elements.push_back(&element);
       continue;
     }
     scoped_ptr<storage::BlobDataHandle> handle =
         blob_storage_context_->GetBlobDataFromUUID(element.blob_uuid());
     scoped_ptr<storage::BlobDataSnapshot> snapshot = handle->CreateSnapshot();
     if (snapshot->items().empty())
       continue;
     const auto& items = snapshot->items();
     for (const auto& item : items) {
       DCHECK_NE(storage::DataElement::TYPE_BLOB, item->type());
       resolved_elements.push_back(item->data_element_ptr());
     }
-    handles.push_back(handle.Pass());
-    snapshots.push_back(snapshot.Pass());
+    handles.push_back(std::move(handle));
+    snapshots.push_back(std::move(snapshot));
   }
 
   const std::string uuid(base::GenerateGUID());
   uint64_t total_size = 0;
 
   storage::BlobDataBuilder blob_builder(uuid);
   for (size_t i = 0; i < resolved_elements.size(); ++i) {
     const ResourceRequestBody::Element& element = *resolved_elements[i];
     if (total_size != std::numeric_limits<uint64_t>::max() &&
         element.length() != std::numeric_limits<uint64_t>::max())
@@ skipping 158 matching lines @@
     SetResponseBodyType(BLOB);
     scoped_ptr<storage::BlobDataHandle> blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(response.blob_uuid);
     if (!blob_data_handle) {
       // The renderer gave us a bad blob UUID.
       RecordResult(ServiceWorkerMetrics::REQUEST_JOB_ERROR_BAD_BLOB);
       DeliverErrorResponse();
       return;
     }
     blob_request_ = storage::BlobProtocolHandler::CreateBlobRequest(
-        blob_data_handle.Pass(), request()->context(), this);
+        std::move(blob_data_handle), request()->context(), this);
     blob_request_->Start();
   }
 
   response_url_ = response.url;
   service_worker_response_type_ = response.response_type;
   CreateResponseHeader(
       response.status_code, response.status_text, response.headers);
   load_timing_info_.receive_headers_end = base::TimeTicks::Now();
   if (!blob_request_) {
     RecordResult(ServiceWorkerMetrics::REQUEST_JOB_HEADERS_ONLY_RESPONSE);
@@ skipping 124 matching lines @@
         base::TimeTicks() /* service_worker_ready_time */);
     return;
   }
   delegate_->OnStartCompleted(true /* was_fetched_via_service_worker */,
                               fall_back_required_, response_url_,
                               service_worker_response_type_, worker_start_time_,
                               worker_ready_time_);
 }
 
 }  // namespace content