Convert Pass()→std::move() in //net

net/cert_net/cert_net_fetcher_impl.cc

 // Copyright 2015 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 "net/cert_net/cert_net_fetcher_impl.h"
 
 #include <tuple>
+#include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/containers/linked_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/stl_util.h"
 #include "base/timer/timer.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/redirect_info.h"
@@ skipping 206 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 CertNetFetcherImpl::RequestImpl::~RequestImpl() {
   if (job_)
     job_->DetachRequest(this);
 }
 
 CertNetFetcherImpl::Job::Job(scoped_ptr<RequestParams> request_params,
                              CertNetFetcherImpl* parent)
-    : request_params_(request_params.Pass()),
+    : request_params_(std::move(request_params)),
       result_net_error_(ERR_IO_PENDING),
-      parent_(parent) {
-}
+      parent_(parent) {}
 
 CertNetFetcherImpl::Job::~Job() {
   Cancel();
 }
 
 void CertNetFetcherImpl::Job::Cancel() {
   parent_ = nullptr;
 
   // Notify each request of cancellation and remove it from the list.
   for (base::LinkNode<RequestImpl>* current = requests_.head();
        current != requests_.end();) {
     base::LinkNode<RequestImpl>* next = current->next();
     current->value()->OnJobCancelled(this);
     current->RemoveFromList();
     current = next;
   }
 
   DCHECK(requests_.empty());
 
   Stop();
 }
 
 scoped_ptr<CertNetFetcher::Request> CertNetFetcherImpl::Job::CreateRequest(
     const FetchCallback& callback) {
   scoped_ptr<RequestImpl> request(new RequestImpl(this, callback));
   requests_.Append(request.get());
-  return request.Pass();
+  return std::move(request);
 }
 
 void CertNetFetcherImpl::Job::DetachRequest(RequestImpl* request) {
   scoped_ptr<Job> delete_this;
 
   request->RemoveFromList();
 
   // If there are no longer any requests attached to the job then
   // cancel and delete it.
   if (requests_.empty() && !parent_->IsCurrentlyCompletingJob(this))
@@ skipping 168 matching lines @@
     int max_response_bytes,
     const FetchCallback& callback) {
   scoped_ptr<RequestParams> request_params(new RequestParams);
 
   request_params->url = url;
   request_params->http_method = HTTP_METHOD_GET;
   request_params->timeout = GetTimeout(timeout_milliseconds);
   request_params->max_response_bytes =
       GetMaxResponseBytes(max_response_bytes, kMaxResponseSizeInBytesForAia);
 
-  return Fetch(request_params.Pass(), callback);
+  return Fetch(std::move(request_params), callback);
 }
 
 scoped_ptr<CertNetFetcher::Request> CertNetFetcherImpl::FetchCrl(
     const GURL& url,
     int timeout_milliseconds,
     int max_response_bytes,
     const FetchCallback& callback) {
   scoped_ptr<RequestParams> request_params(new RequestParams);
 
   request_params->url = url;
   request_params->http_method = HTTP_METHOD_GET;
   request_params->timeout = GetTimeout(timeout_milliseconds);
   request_params->max_response_bytes =
       GetMaxResponseBytes(max_response_bytes, kMaxResponseSizeInBytesForCrl);
 
-  return Fetch(request_params.Pass(), callback);
+  return Fetch(std::move(request_params), callback);
 }
 
 scoped_ptr<CertNetFetcher::Request> CertNetFetcherImpl::FetchOcsp(
     const GURL& url,
     int timeout_milliseconds,
     int max_response_bytes,
     const FetchCallback& callback) {
   scoped_ptr<RequestParams> request_params(new RequestParams);
 
   request_params->url = url;
   request_params->http_method = HTTP_METHOD_GET;
   request_params->timeout = GetTimeout(timeout_milliseconds);
   request_params->max_response_bytes =
       GetMaxResponseBytes(max_response_bytes, kMaxResponseSizeInBytesForAia);
 
-  return Fetch(request_params.Pass(), callback);
+  return Fetch(std::move(request_params), callback);
 }
 
 bool CertNetFetcherImpl::JobComparator::operator()(const Job* job1,
                                                    const Job* job2) const {
   return job1->request_params() < job2->request_params();
 }
 
 scoped_ptr<CertNetFetcher::Request> CertNetFetcherImpl::Fetch(
     scoped_ptr<RequestParams> request_params,
     const FetchCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If there is an in-progress job that matches the request parameters use it.
   // Otherwise start a new job.
   Job* job = FindJob(*request_params);
 
   if (!job) {
-    job = new Job(request_params.Pass(), this);
+    job = new Job(std::move(request_params), this);
     jobs_.insert(job);
     job->StartURLRequest(context_);
   }
 
   return job->CreateRequest(callback);
 }
 
 struct CertNetFetcherImpl::JobToRequestParamsComparator {
   bool operator()(const Job* job,
                   const CertNetFetcherImpl::RequestParams& value) const {
@@ skipping 30 matching lines @@
 void CertNetFetcherImpl::ClearCurrentlyCompletingJob(Job* job) {
   DCHECK_EQ(currently_completing_job_, job);
   currently_completing_job_ = nullptr;
 }
 
 bool CertNetFetcherImpl::IsCurrentlyCompletingJob(Job* job) {
   return job == currently_completing_job_;
 }
 
 }  // namespace net