Change scoped_ptr to std::unique_ptr 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/memory/ptr_util.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"
 #include "net/url_request/url_request_context.h"
 
 // TODO(eroman): Add support for POST parameters.
 // TODO(eroman): Add controls for bypassing the cache.
 // TODO(eroman): Add a maximum number of in-flight jobs/requests.
@@ skipping 115 matching lines @@
     const RequestParams& other) const {
   return std::tie(url, http_method, max_response_bytes, timeout) <
          std::tie(other.url, other.http_method, other.max_response_bytes,
                   other.timeout);
 }
 
 // CertNetFetcherImpl::Job tracks an outstanding URLRequest as well as all of
 // the pending requests for it.
 class CertNetFetcherImpl::Job : public URLRequest::Delegate {
  public:
-  Job(scoped_ptr<RequestParams> request_params, CertNetFetcherImpl* parent);
+  Job(std::unique_ptr<RequestParams> request_params,
+      CertNetFetcherImpl* parent);
   ~Job() override;
 
   // Cancels the job and all requests attached to it. No callbacks will be
   // invoked following cancellation.
   void Cancel();
 
   const RequestParams& request_params() const { return *request_params_; }
 
   // Create a request and attaches it to the job. When the job completes it will
   // notify the request of completion through OnJobCompleted. Note that the Job
   // does NOT own the request.
-  scoped_ptr<Request> CreateRequest(const FetchCallback& callback);
+  std::unique_ptr<Request> CreateRequest(const FetchCallback& callback);
 
   // Removes |request| from the job.
   void DetachRequest(RequestImpl* request);
 
   // Creates and starts a URLRequest for the job. After the request has
   // completed, OnJobCompleted() will be invoked and all the registered requests
   // notified of completion.
   void StartURLRequest(URLRequestContext* context);
 
  private:
@@ skipping 27 matching lines @@
   // Called when the Job has completed. The job may finish in response to a
   // timeout, an invalid URL, or the URLRequest completing. By the time this
   // method is called, the response variables have been assigned
   // (result_net_error_ and response_body_).
   void OnJobCompleted();
 
   // The requests attached to this job.
   RequestList requests_;
 
   // The input parameters for starting a URLRequest.
-  scoped_ptr<RequestParams> request_params_;
+  std::unique_ptr<RequestParams> request_params_;
 
   // The URLRequest response information.
   std::vector<uint8_t> response_body_;
   Error result_net_error_;
 
-  scoped_ptr<URLRequest> url_request_;
+  std::unique_ptr<URLRequest> url_request_;
   scoped_refptr<IOBuffer> read_buffer_;
 
   // Used to timeout the job when the URLRequest takes too long. This timer is
   // also used for notifying a failure to start the URLRequest.
   base::OneShotTimer timer_;
 
   // Non-owned pointer to the CertNetFetcherImpl that created this job.
   CertNetFetcherImpl* parent_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 CertNetFetcherImpl::RequestImpl::~RequestImpl() {
   if (job_)
     job_->DetachRequest(this);
 }
 
-CertNetFetcherImpl::Job::Job(scoped_ptr<RequestParams> request_params,
+CertNetFetcherImpl::Job::Job(std::unique_ptr<RequestParams> request_params,
                              CertNetFetcherImpl* parent)
     : request_params_(std::move(request_params)),
       result_net_error_(ERR_IO_PENDING),
       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(
+std::unique_ptr<CertNetFetcher::Request> CertNetFetcherImpl::Job::CreateRequest(
     const FetchCallback& callback) {
-  scoped_ptr<RequestImpl> request(new RequestImpl(this, callback));
+  std::unique_ptr<RequestImpl> request(new RequestImpl(this, callback));
   requests_.Append(request.get());
   return std::move(request);
 }
 
 void CertNetFetcherImpl::Job::DetachRequest(RequestImpl* request) {
-  scoped_ptr<Job> delete_this;
+  std::unique_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))
     delete_this = parent_->RemoveJob(this);
 }
 
 void CertNetFetcherImpl::Job::StartURLRequest(URLRequestContext* context) {
@@ skipping 125 matching lines @@
 void CertNetFetcherImpl::Job::OnJobCompleted() {
   // Stop the timer and clear the URLRequest.
   Stop();
 
   // Invoking the callbacks is subtle as state may be mutated while iterating
   // through the callbacks:
   //
   //   * The parent CertNetFetcherImpl may be deleted
   //   * Requests in this job may be cancelled
 
-  scoped_ptr<Job> delete_this = parent_->RemoveJob(this);
+  std::unique_ptr<Job> delete_this = parent_->RemoveJob(this);
   parent_->SetCurrentlyCompletingJob(this);
 
   while (!requests_.empty()) {
     base::LinkNode<RequestImpl>* request = requests_.head();
     request->RemoveFromList();
     request->value()->OnJobCompleted(this, result_net_error_, response_body_);
   }
 
   if (parent_)
     parent_->ClearCurrentlyCompletingJob(this);
 }
 
 CertNetFetcherImpl::CertNetFetcherImpl(URLRequestContext* context)
     : currently_completing_job_(nullptr), context_(context) {
 }
 
 CertNetFetcherImpl::~CertNetFetcherImpl() {
   STLDeleteElements(&jobs_);
 
   // The CertNetFetcherImpl was destroyed in a FetchCallback. Detach all
   // remaining requests from the job so no further callbacks are called.
   if (currently_completing_job_)
     currently_completing_job_->Cancel();
 }
 
-scoped_ptr<CertNetFetcher::Request> CertNetFetcherImpl::FetchCaIssuers(
+std::unique_ptr<CertNetFetcher::Request> CertNetFetcherImpl::FetchCaIssuers(
     const GURL& url,
     int timeout_milliseconds,
     int max_response_bytes,
     const FetchCallback& callback) {
-  scoped_ptr<RequestParams> request_params(new RequestParams);
+  std::unique_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(std::move(request_params), callback);
 }
 
-scoped_ptr<CertNetFetcher::Request> CertNetFetcherImpl::FetchCrl(
+std::unique_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);
+  std::unique_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(std::move(request_params), callback);
 }
 
-scoped_ptr<CertNetFetcher::Request> CertNetFetcherImpl::FetchOcsp(
+std::unique_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);
+  std::unique_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(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,
+std::unique_ptr<CertNetFetcher::Request> CertNetFetcherImpl::Fetch(
+    std::unique_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(std::move(request_params), this);
     jobs_.insert(job);
@@ skipping 16 matching lines @@
 
   // The JobSet is kept in sorted order so items can be found using binary
   // search.
   JobSet::iterator it = std::lower_bound(jobs_.begin(), jobs_.end(), params,
                                          JobToRequestParamsComparator());
   if (it != jobs_.end() && !(params < (*it)->request_params()))
     return *it;
   return nullptr;
 }
 
-scoped_ptr<CertNetFetcherImpl::Job> CertNetFetcherImpl::RemoveJob(Job* job) {
+std::unique_ptr<CertNetFetcherImpl::Job> CertNetFetcherImpl::RemoveJob(
+    Job* job) {
   DCHECK(thread_checker_.CalledOnValidThread());
   bool erased_job = jobs_.erase(job) == 1;
   CHECK(erased_job);
-  return make_scoped_ptr(job);
+  return base::WrapUnique(job);
 }
 
 void CertNetFetcherImpl::SetCurrentlyCompletingJob(Job* job) {
   DCHECK(!currently_completing_job_);
   DCHECK(job);
   currently_completing_job_ = job;
 }
 
 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