Change scoped_ptr to std::unique_ptr in //net.

net/ssl/channel_id_service.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 "net/ssl/channel_id_service.h"
 
 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "crypto/ec_private_key.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cert/x509_certificate.h"
@@ skipping 48 matching lines @@
                              request_time,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(5),
                              50);
 }
 
 // On success, returns a ChannelID object and sets |*error| to OK.
 // Otherwise, returns NULL, and |*error| will be set to a net error code.
 // |serial_number| is passed in because base::RandInt cannot be called from an
 // unjoined thread, due to relying on a non-leaked LazyInstance
-scoped_ptr<ChannelIDStore::ChannelID> GenerateChannelID(
+std::unique_ptr<ChannelIDStore::ChannelID> GenerateChannelID(
     const std::string& server_identifier,
     int* error) {
-  scoped_ptr<ChannelIDStore::ChannelID> result;
+  std::unique_ptr<ChannelIDStore::ChannelID> result;
 
   base::TimeTicks start = base::TimeTicks::Now();
   base::Time creation_time = base::Time::Now();
-  scoped_ptr<crypto::ECPrivateKey> key(crypto::ECPrivateKey::Create());
+  std::unique_ptr<crypto::ECPrivateKey> key(crypto::ECPrivateKey::Create());
 
   if (!key) {
     DLOG(ERROR) << "Unable to create channel ID key pair";
     *error = ERR_KEY_GENERATION_FAILED;
     return result;
   }
 
   result.reset(new ChannelIDStore::ChannelID(server_identifier, creation_time,
                                              std::move(key)));
   UMA_HISTOGRAM_CUSTOM_TIMES("DomainBoundCerts.GenerateCertTime",
                              base::TimeTicks::Now() - start,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(5),
                              50);
   *error = OK;
   return result;
 }
 
 }  // namespace
 
 // ChannelIDServiceWorker runs on a worker thread and takes care of the
 // blocking process of performing key generation. Will take care of deleting
 // itself once Start() is called.
 class ChannelIDServiceWorker {
  public:
-  typedef base::Callback<void(
-      const std::string&,
-      int,
-      scoped_ptr<ChannelIDStore::ChannelID>)> WorkerDoneCallback;
+  typedef base::Callback<
+      void(const std::string&, int, std::unique_ptr<ChannelIDStore::ChannelID>)>
+      WorkerDoneCallback;
 
   ChannelIDServiceWorker(const std::string& server_identifier,
                          const WorkerDoneCallback& callback)
       : server_identifier_(server_identifier),
         origin_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         callback_(callback) {}
 
   // Starts the worker on |task_runner|. If the worker fails to start, such as
   // if the task runner is shutting down, then it will take care of deleting
   // itself.
   bool Start(const scoped_refptr<base::TaskRunner>& task_runner) {
     DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
 
     return task_runner->PostTask(
         FROM_HERE,
         base::Bind(&ChannelIDServiceWorker::Run, base::Owned(this)));
   }
 
  private:
   void Run() {
     // Runs on a worker thread.
     int error = ERR_FAILED;
-    scoped_ptr<ChannelIDStore::ChannelID> channel_id =
+    std::unique_ptr<ChannelIDStore::ChannelID> channel_id =
         GenerateChannelID(server_identifier_, &error);
 #if !defined(USE_OPENSSL)
     // Detach the thread from NSPR.
     // Calling NSS functions attaches the thread to NSPR, which stores
     // the NSPR thread ID in thread-specific data.
     // The threads in our thread pool terminate after we have called
     // PR_Cleanup. Unless we detach them from NSPR, net_unittests gets
     // segfaults on shutdown when the threads' thread-specific data
     // destructors run.
     PR_DetachThread();
@@ skipping 20 matching lines @@
   }
 
   ~ChannelIDServiceJob() { DCHECK(requests_.empty()); }
 
   void AddRequest(ChannelIDService::Request* request,
                   bool create_if_missing = false) {
     create_if_missing_ |= create_if_missing;
     requests_.push_back(request);
   }
 
-  void HandleResult(int error, scoped_ptr<crypto::ECPrivateKey> key) {
+  void HandleResult(int error, std::unique_ptr<crypto::ECPrivateKey> key) {
     PostAll(error, std::move(key));
   }
 
   bool CreateIfMissing() const { return create_if_missing_; }
 
   void CancelRequest(ChannelIDService::Request* req) {
     auto it = std::find(requests_.begin(), requests_.end(), req);
     if (it != requests_.end())
       requests_.erase(it);
   }
 
  private:
-  void PostAll(int error, scoped_ptr<crypto::ECPrivateKey> key) {
+  void PostAll(int error, std::unique_ptr<crypto::ECPrivateKey> key) {
     std::vector<ChannelIDService::Request*> requests;
     requests_.swap(requests);
 
     for (std::vector<ChannelIDService::Request*>::iterator i = requests.begin();
          i != requests.end(); i++) {
-      scoped_ptr<crypto::ECPrivateKey> key_copy;
+      std::unique_ptr<crypto::ECPrivateKey> key_copy;
       if (key)
         key_copy.reset(key->Copy());
       (*i)->Post(error, std::move(key_copy));
     }
   }
 
   std::vector<ChannelIDService::Request*> requests_;
   bool create_if_missing_;
 };
 
@@ skipping 14 matching lines @@
     job_->CancelRequest(this);
 
     service_ = NULL;
   }
 }
 
 void ChannelIDService::Request::RequestStarted(
     ChannelIDService* service,
     base::TimeTicks request_start,
     const CompletionCallback& callback,
-    scoped_ptr<crypto::ECPrivateKey>* key,
+    std::unique_ptr<crypto::ECPrivateKey>* key,
     ChannelIDServiceJob* job) {
   DCHECK(service_ == NULL);
   service_ = service;
   request_start_ = request_start;
   callback_ = callback;
   key_ = key;
   job_ = job;
 }
 
-void ChannelIDService::Request::Post(int error,
-                                     scoped_ptr<crypto::ECPrivateKey> key) {
+void ChannelIDService::Request::Post(
+    int error,
+    std::unique_ptr<crypto::ECPrivateKey> key) {
   switch (error) {
     case OK: {
       base::TimeDelta request_time = base::TimeTicks::Now() - request_start_;
       UMA_HISTOGRAM_CUSTOM_TIMES("DomainBoundCerts.GetCertTimeAsync",
                                  request_time,
                                  base::TimeDelta::FromMilliseconds(1),
                                  base::TimeDelta::FromMinutes(5), 50);
       RecordGetChannelIDTime(request_time);
       RecordGetChannelIDResult(ASYNC_SUCCESS);
       break;
@@ skipping 42 matching lines @@
   std::string domain =
       registry_controlled_domains::GetDomainAndRegistry(
           host, registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
   if (domain.empty())
     return host;
   return domain;
 }
 
 int ChannelIDService::GetOrCreateChannelID(
     const std::string& host,
-    scoped_ptr<crypto::ECPrivateKey>* key,
+    std::unique_ptr<crypto::ECPrivateKey>* key,
     const CompletionCallback& callback,
     Request* out_req) {
   DVLOG(1) << __FUNCTION__ << " " << host;
   DCHECK(CalledOnValidThread());
   base::TimeTicks request_start = base::TimeTicks::Now();
 
   if (callback.is_null() || !key || host.empty()) {
     RecordGetChannelIDResult(INVALID_ARGUMENT);
     return ERR_INVALID_ARGUMENT;
   }
@@ skipping 34 matching lines @@
 
     job->AddRequest(out_req);
     out_req->RequestStarted(this, request_start, callback, key, job);
     return ERR_IO_PENDING;
   }
 
   return err;
 }
 
 int ChannelIDService::GetChannelID(const std::string& host,
-                                   scoped_ptr<crypto::ECPrivateKey>* key,
+                                   std::unique_ptr<crypto::ECPrivateKey>* key,
                                    const CompletionCallback& callback,
                                    Request* out_req) {
   DVLOG(1) << __FUNCTION__ << " " << host;
   DCHECK(CalledOnValidThread());
   base::TimeTicks request_start = base::TimeTicks::Now();
 
   if (callback.is_null() || !key || host.empty()) {
     RecordGetChannelIDResult(INVALID_ARGUMENT);
     return ERR_INVALID_ARGUMENT;
   }
@@ skipping 13 matching lines @@
     return ERR_IO_PENDING;
   }
 
   int err = LookupChannelID(request_start, domain, key, create_if_missing,
                             callback, out_req);
   return err;
 }
 
 void ChannelIDService::GotChannelID(int err,
                                     const std::string& server_identifier,
-                                    scoped_ptr<crypto::ECPrivateKey> key) {
+                                    std::unique_ptr<crypto::ECPrivateKey> key) {
   DCHECK(CalledOnValidThread());
 
   std::map<std::string, ChannelIDServiceJob*>::iterator j;
   j = inflight_.find(server_identifier);
   if (j == inflight_.end()) {
     NOTREACHED();
     return;
   }
 
   if (err == OK) {
@@ skipping 24 matching lines @@
   }
 }
 
 ChannelIDStore* ChannelIDService::GetChannelIDStore() {
   return channel_id_store_.get();
 }
 
 void ChannelIDService::GeneratedChannelID(
     const std::string& server_identifier,
     int error,
-    scoped_ptr<ChannelIDStore::ChannelID> channel_id) {
+    std::unique_ptr<ChannelIDStore::ChannelID> channel_id) {
   DCHECK(CalledOnValidThread());
 
-  scoped_ptr<crypto::ECPrivateKey> key;
+  std::unique_ptr<crypto::ECPrivateKey> key;
   if (error == OK) {
     key.reset(channel_id->key()->Copy());
     channel_id_store_->SetChannelID(std::move(channel_id));
   }
   HandleResult(error, server_identifier, std::move(key));
 }
 
 void ChannelIDService::HandleResult(int error,
                                     const std::string& server_identifier,
-                                    scoped_ptr<crypto::ECPrivateKey> key) {
+                                    std::unique_ptr<crypto::ECPrivateKey> key) {
   DCHECK(CalledOnValidThread());
 
   std::map<std::string, ChannelIDServiceJob*>::iterator j;
   j = inflight_.find(server_identifier);
   if (j == inflight_.end()) {
     NOTREACHED();
     return;
   }
   ChannelIDServiceJob* job = j->second;
   inflight_.erase(j);
 
   job->HandleResult(error, std::move(key));
   delete job;
 }
 
 bool ChannelIDService::JoinToInFlightRequest(
     const base::TimeTicks& request_start,
     const std::string& domain,
-    scoped_ptr<crypto::ECPrivateKey>* key,
+    std::unique_ptr<crypto::ECPrivateKey>* key,
     bool create_if_missing,
     const CompletionCallback& callback,
     Request* out_req) {
   ChannelIDServiceJob* job = NULL;
   std::map<std::string, ChannelIDServiceJob*>::const_iterator j =
       inflight_.find(domain);
   if (j != inflight_.end()) {
     // A request for the same domain is in flight already. We'll attach our
     // callback, but we'll also mark it as requiring a channel ID if one's
     // mising.
     job = j->second;
     inflight_joins_++;
 
     job->AddRequest(out_req, create_if_missing);
     out_req->RequestStarted(this, request_start, callback, key, job);
     return true;
   }
   return false;
 }
 
-int ChannelIDService::LookupChannelID(const base::TimeTicks& request_start,
-                                      const std::string& domain,
-                                      scoped_ptr<crypto::ECPrivateKey>* key,
-                                      bool create_if_missing,
-                                      const CompletionCallback& callback,
-                                      Request* out_req) {
+int ChannelIDService::LookupChannelID(
+    const base::TimeTicks& request_start,
+    const std::string& domain,
+    std::unique_ptr<crypto::ECPrivateKey>* key,
+    bool create_if_missing,
+    const CompletionCallback& callback,
+    Request* out_req) {
   // Check if a channel ID key already exists for this domain.
   int err = channel_id_store_->GetChannelID(
       domain, key, base::Bind(&ChannelIDService::GotChannelID,
                               weak_ptr_factory_.GetWeakPtr()));
 
   if (err == OK) {
     // Sync lookup found a valid channel ID.
     DVLOG(1) << "Channel ID store had valid key for " << domain;
     key_store_hits_++;
     RecordGetChannelIDResult(SYNC_SUCCESS);
@@ skipping 14 matching lines @@
   }
 
   return err;
 }
 
 int ChannelIDService::channel_id_count() {
   return channel_id_store_->GetChannelIDCount();
 }
 
 }  // namespace net