Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/platform_keys/platform_keys_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 "chrome/browser/chromeos/platform_keys/platform_keys_service.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/state_store.h"
 #include "net/cert/x509_certificate.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
@@ skipping 102 matching lines @@
     DoStep();
   }
 
   // Gets the permissions for the extension with id |extension_id|.
   void GetExtensionPermissions() {
     key_permissions_->GetPermissionsForExtension(
         extension_id_, base::Bind(&GenerateRSAKeyTask::GotPermissions,
                                   base::Unretained(this)));
   }
 
-  void GotPermissions(scoped_ptr<KeyPermissions::PermissionsForExtension>
+  void GotPermissions(std::unique_ptr<KeyPermissions::PermissionsForExtension>
                           extension_permissions) {
     extension_permissions_ = std::move(extension_permissions);
     DoStep();
   }
 
   Step next_step_ = Step::GENERATE_KEY;
 
   const std::string token_id_;
   const unsigned int modulus_length_;
   std::string public_key_spki_der_;
   const std::string extension_id_;
   GenerateKeyCallback callback_;
-  scoped_ptr<KeyPermissions::PermissionsForExtension> extension_permissions_;
+  std::unique_ptr<KeyPermissions::PermissionsForExtension>
+      extension_permissions_;
   KeyPermissions* const key_permissions_;
   PlatformKeysService* const service_;
   content::BrowserContext* const browser_context_;
   base::WeakPtrFactory<GenerateRSAKeyTask> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GenerateRSAKeyTask);
 };
 
 class PlatformKeysService::SignTask : public Task {
  public:
@@ skipping 65 matching lines @@
         return;
     }
   }
 
   void GetExtensionPermissions() {
     key_permissions_->GetPermissionsForExtension(
         extension_id_,
         base::Bind(&SignTask::GotPermissions, base::Unretained(this)));
   }
 
-  void GotPermissions(scoped_ptr<KeyPermissions::PermissionsForExtension>
+  void GotPermissions(std::unique_ptr<KeyPermissions::PermissionsForExtension>
                           extension_permissions) {
     extension_permissions_ = std::move(extension_permissions);
     DoStep();
   }
 
   // Updates the permissions for |public_key_|, starts the actual signing
   // operation and afterwards passes the signature (or error) to |callback_|.
   void Sign() {
     extension_permissions_->SetKeyUsedForSigning(public_key_);
 
@@ skipping 21 matching lines @@
   const std::string data_;
   const std::string public_key_;
 
   // If true, |data_| will not be hashed before signing. Only PKCS#1 v1.5
   // padding will be applied before signing.
   // If false, |hash_algorithm_| is set to a value != NONE.
   const bool sign_direct_pkcs_padded_;
   const platform_keys::HashAlgorithm hash_algorithm_;
   const std::string extension_id_;
   const SignCallback callback_;
-  scoped_ptr<KeyPermissions::PermissionsForExtension> extension_permissions_;
+  std::unique_ptr<KeyPermissions::PermissionsForExtension>
+      extension_permissions_;
   KeyPermissions* const key_permissions_;
   PlatformKeysService* const service_;
   base::WeakPtrFactory<SignTask> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SignTask);
 };
 
 class PlatformKeysService::SelectTask : public Task {
  public:
   enum class Step {
     GET_EXTENSION_PERMISSIONS,
     GET_MATCHING_CERTS,
     INTERSECT_WITH_INPUT_CERTS,
     SELECT_CERTS,
     UPDATE_PERMISSION,
     FILTER_BY_PERMISSIONS,
     DONE,
   };
 
   // This task determines all known client certs matching |request| and that are
   // elements of |input_client_certificates|, if given. If |interactive| is
   // true, calls |service->select_delegate_->Select()| to select a cert from all
   // matches. The extension with |extension_id| will be granted unlimited sign
   // permission for the selected cert. Finally, either the selection or, if
   // |interactive| is false, matching certs that the extension has permission
   // for are passed to |callback|.
   SelectTask(const platform_keys::ClientCertificateRequest& request,
-             scoped_ptr<net::CertificateList> input_client_certificates,
+             std::unique_ptr<net::CertificateList> input_client_certificates,
              bool interactive,
              const std::string& extension_id,
              const SelectCertificatesCallback& callback,
              content::WebContents* web_contents,
              KeyPermissions* key_permissions,
              PlatformKeysService* service)
       : request_(request),
         input_client_certificates_(std::move(input_client_certificates)),
         interactive_(interactive),
         extension_id_(extension_id),
@@ skipping 47 matching lines @@
         return;
     }
   }
 
   void GetExtensionPermissions() {
     key_permissions_->GetPermissionsForExtension(
         extension_id_,
         base::Bind(&SelectTask::GotPermissions, base::Unretained(this)));
   }
 
-  void GotPermissions(scoped_ptr<KeyPermissions::PermissionsForExtension>
+  void GotPermissions(std::unique_ptr<KeyPermissions::PermissionsForExtension>
                           extension_permissions) {
     extension_permissions_ = std::move(extension_permissions);
     DoStep();
   }
 
   // Retrieves all certificates matching |request_|. Will call back to
   // |GotMatchingCerts()|.
   void GetMatchingCerts() {
     platform_keys::subtle::SelectClientCertificates(
         request_.certificate_authorities,
         base::Bind(&SelectTask::GotMatchingCerts, weak_factory_.GetWeakPtr()),
         service_->browser_context_);
   }
 
   // If the certificate request could be processed successfully, |matches| will
   // contain the list of matching certificates (maybe empty) and |error_message|
   // will be empty. If an error occurred, |matches| will be null and
   // |error_message| contain an error message.
   // Note that the order of |matches|, based on the expiration/issuance date, is
   // relevant and must be preserved in any processing of the list.
-  void GotMatchingCerts(scoped_ptr<net::CertificateList> matches,
+  void GotMatchingCerts(std::unique_ptr<net::CertificateList> matches,
                         const std::string& error_message) {
     if (!error_message.empty()) {
       next_step_ = Step::DONE;
       callback_.Run(nullptr /* no certificates */, error_message);
       DoStep();
       return;
     }
 
     for (scoped_refptr<net::X509Certificate>& certificate : *matches) {
       const std::string public_key_spki_der(
@@ skipping 32 matching lines @@
   void IntersectWithInputCerts() {
     if (!input_client_certificates_) {
       DoStep();
       return;
     }
     platform_keys::IntersectCertificates(
         matches_, *input_client_certificates_,
         base::Bind(&SelectTask::GotIntersection, weak_factory_.GetWeakPtr()));
   }
 
-  void GotIntersection(scoped_ptr<net::CertificateList> intersection) {
+  void GotIntersection(std::unique_ptr<net::CertificateList> intersection) {
     matches_.swap(*intersection);
     DoStep();
   }
 
   // Calls |service_->select_delegate_->Select()| to select a cert from
   // |matches_|, which will be stored in |selected_cert_|.
   // Will call back to |GotSelection()|.
   void SelectCerts() {
     CHECK(interactive_);
     if (matches_.empty()) {
@@ skipping 25 matching lines @@
     const std::string public_key_spki_der(
         platform_keys::GetSubjectPublicKeyInfo(selected_cert_));
     extension_permissions_->SetUserGrantedPermission(public_key_spki_der);
     DoStep();
   }
 
   // Filters from all matches (if not interactive) or from the selection (if
   // interactive), the certificates that the extension has unlimited sign
   // permission for. Passes the filtered certs to |callback_|.
   void FilterSelectionByPermission() {
-    scoped_ptr<net::CertificateList> selection(new net::CertificateList);
+    std::unique_ptr<net::CertificateList> selection(new net::CertificateList);
     if (interactive_) {
       if (selected_cert_)
         selection->push_back(selected_cert_);
     } else {
       selection->assign(matches_.begin(), matches_.end());
     }
 
-    scoped_ptr<net::CertificateList> filtered_certs(new net::CertificateList);
+    std::unique_ptr<net::CertificateList> filtered_certs(
+        new net::CertificateList);
     for (scoped_refptr<net::X509Certificate> selected_cert : *selection) {
       const std::string public_key_spki_der(
           platform_keys::GetSubjectPublicKeyInfo(selected_cert));
 
       if (!extension_permissions_->CanUseKeyForSigning(public_key_spki_der))
         continue;
 
       filtered_certs->push_back(selected_cert);
     }
     // Note: In the interactive case this should have filtered exactly the
     // one selected cert. Checking the permissions again is not striclty
     // necessary but this ensures that the permissions were updated correctly.
     CHECK(!selected_cert_ || (filtered_certs->size() == 1 &&
                               filtered_certs->front() == selected_cert_));
     callback_.Run(std::move(filtered_certs), std::string() /* no error */);
     DoStep();
   }
 
   Step next_step_ = Step::GET_EXTENSION_PERMISSIONS;
 
   net::CertificateList matches_;
   scoped_refptr<net::X509Certificate> selected_cert_;
   platform_keys::ClientCertificateRequest request_;
-  scoped_ptr<net::CertificateList> input_client_certificates_;
+  std::unique_ptr<net::CertificateList> input_client_certificates_;
   const bool interactive_;
   const std::string extension_id_;
   const SelectCertificatesCallback callback_;
   content::WebContents* const web_contents_;
-  scoped_ptr<KeyPermissions::PermissionsForExtension> extension_permissions_;
+  std::unique_ptr<KeyPermissions::PermissionsForExtension>
+      extension_permissions_;
   KeyPermissions* const key_permissions_;
   PlatformKeysService* const service_;
   base::WeakPtrFactory<SelectTask> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SelectTask);
 };
 
 PlatformKeysService::SelectDelegate::SelectDelegate() {
 }
 
@@ skipping 13 matching lines @@
                        state_store),
       weak_factory_(this) {
   DCHECK(browser_context);
   DCHECK(state_store);
 }
 
 PlatformKeysService::~PlatformKeysService() {
 }
 
 void PlatformKeysService::SetSelectDelegate(
-    scoped_ptr<SelectDelegate> delegate) {
+    std::unique_ptr<SelectDelegate> delegate) {
   select_delegate_ = std::move(delegate);
 }
 
 void PlatformKeysService::GenerateRSAKey(const std::string& token_id,
                                          unsigned int modulus_length,
                                          const std::string& extension_id,
                                          const GenerateKeyCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  StartOrQueueTask(make_scoped_ptr(
+  StartOrQueueTask(base::WrapUnique(
       new GenerateRSAKeyTask(token_id, modulus_length, extension_id, callback,
                              &key_permissions_, this, browser_context_)));
 }
 
 void PlatformKeysService::SignRSAPKCS1Digest(
     const std::string& token_id,
     const std::string& data,
     const std::string& public_key,
     platform_keys::HashAlgorithm hash_algorithm,
     const std::string& extension_id,
     const SignCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  StartOrQueueTask(make_scoped_ptr(new SignTask(
+  StartOrQueueTask(base::WrapUnique(new SignTask(
       token_id, data, public_key, false /* digest before signing */,
       hash_algorithm, extension_id, callback, &key_permissions_, this)));
 }
 
 void PlatformKeysService::SignRSAPKCS1Raw(const std::string& token_id,
                                           const std::string& data,
                                           const std::string& public_key,
                                           const std::string& extension_id,
                                           const SignCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  StartOrQueueTask(make_scoped_ptr(new SignTask(
+  StartOrQueueTask(base::WrapUnique(new SignTask(
       token_id, data, public_key, true /* sign directly without hashing */,
       platform_keys::HASH_ALGORITHM_NONE, extension_id, callback,
       &key_permissions_, this)));
 }
 
 void PlatformKeysService::SelectClientCertificates(
     const platform_keys::ClientCertificateRequest& request,
-    scoped_ptr<net::CertificateList> client_certificates,
+    std::unique_ptr<net::CertificateList> client_certificates,
     bool interactive,
     const std::string& extension_id,
     const SelectCertificatesCallback& callback,
     content::WebContents* web_contents) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  StartOrQueueTask(make_scoped_ptr(new SelectTask(
+  StartOrQueueTask(base::WrapUnique(new SelectTask(
       request, std::move(client_certificates), interactive, extension_id,
       callback, web_contents, &key_permissions_, this)));
 }
 
-void PlatformKeysService::StartOrQueueTask(scoped_ptr<Task> task) {
+void PlatformKeysService::StartOrQueueTask(std::unique_ptr<Task> task) {
   tasks_.push(make_linked_ptr(task.release()));
   if (tasks_.size() == 1)
     tasks_.front()->Start();
 }
 
 void PlatformKeysService::TaskFinished(Task* task) {
   DCHECK(!tasks_.empty());
   DCHECK(task == tasks_.front().get());
   // Remove all finished tasks from the queue (should be at most one).
   while (!tasks_.empty() && tasks_.front()->IsDone())
     tasks_.pop();
 
   // Now either the queue is empty or the next task is not finished yet and it
   // can be started.
   if (!tasks_.empty())
     tasks_.front()->Start();
 }
 
 }  // namespace chromeos