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

chrome/browser/chromeos/platform_keys/platform_keys_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_PLATFORM_KEYS_SERVICE_H_
 #define CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_PLATFORM_KEYS_SERVICE_H_
 
+#include <memory>
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/chromeos/platform_keys/key_permissions.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys.h"
 #include "components/keyed_service/core/keyed_service.h"
 
 class PrefService;
 
 namespace base {
 class ListValue;
 class Value;
@@ skipping 59 matching lines @@
   explicit PlatformKeysService(bool profile_is_managed,
                                PrefService* profile_prefs,
                                policy::PolicyService* profile_policies,
                                content::BrowserContext* browser_context,
                                extensions::StateStore* state_store);
 
   ~PlatformKeysService() override;
 
   // Sets the delegate which will be used for interactive
   // SelectClientCertificates calls.
-  void SetSelectDelegate(scoped_ptr<SelectDelegate> delegate);
+  void SetSelectDelegate(std::unique_ptr<SelectDelegate> delegate);
 
   // If the generation was successful, |public_key_spki_der| will contain the
   // DER encoding of the SubjectPublicKeyInfo of the generated key and
   // |error_message| will be empty. If it failed, |public_key_spki_der| will be
   // empty and |error_message| contain an error message.
   using GenerateKeyCallback =
       base::Callback<void(const std::string& public_key_spki_der,
                           const std::string& error_message)>;
 
   // Generates an RSA key pair with |modulus_length_bits| and registers the key
@@ skipping 45 matching lines @@
                        const std::string& data,
                        const std::string& public_key,
                        const std::string& extension_id,
                        const SignCallback& callback);
 
   // 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.
   using SelectCertificatesCallback =
-      base::Callback<void(scoped_ptr<net::CertificateList> matches,
+      base::Callback<void(std::unique_ptr<net::CertificateList> matches,
                           const std::string& error_message)>;
 
   // Returns a list of certificates matching |request|.
   // 1) all certificates that match the request (like being rooted in one of the
   // give CAs) are determined.
   // 2) if |client_certificates| is not null, drops all certificates that are
   // not elements of |client_certificates|,
   // 3) if |interactive| is true, the currently set SelectDelegate is used to
   // select a single certificate from these matches
   // which will the extension will also be granted access to.
   // 4) only certificates, that the extension has unlimited sign permission for,
   // will be returned.
   // |callback| will be invoked with these certificates or an error message.
   // Will only call back during the lifetime of this object. |web_contents| must
   // not be null.
   void 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);
 
  private:
   class GenerateRSAKeyTask;
   class SelectTask;
   class SignTask;
   class Task;
 
   // Starts |task| eventually. To ensure that at most one |Task| is running at a
   // time, it queues |task| for later execution if necessary.
-  void StartOrQueueTask(scoped_ptr<Task> task);
+  void StartOrQueueTask(std::unique_ptr<Task> task);
 
   // Must be called after |task| is done. |task| will be invalid after this
   // call. This must not be called for any but the task that ran last. If any
   // other tasks are queued (see StartOrQueueTask()), it will start the next
   // one.
   void TaskFinished(Task* task);
 
   // Callback used by |GenerateRSAKey|.
   // If the key generation was successful, registers the generated public key
   // for the given extension. If any error occurs during key generation or
   // registration, calls |callback| with an error. Otherwise, on success, calls
   // |callback| with the public key.
   void GeneratedKey(const std::string& extension_id,
                     const GenerateKeyCallback& callback,
                     const std::string& public_key_spki_der,
                     const std::string& error_message);
 
   // Callback used by |GeneratedKey|.
   // |public_key_spki_der| will contain the X.509 Subject Public Key Info  of
   // the generated key in DER encoding. |task| points to the finished |Task|
   // object.
   void RegisteredGeneratedKey(const GenerateKeyCallback& callback,
                               const std::string& public_key_spki_der,
                               Task* task);
 
   content::BrowserContext* browser_context_;
   KeyPermissions key_permissions_;
-  scoped_ptr<SelectDelegate> select_delegate_;
+  std::unique_ptr<SelectDelegate> select_delegate_;
   std::queue<linked_ptr<Task>> tasks_;
   base::WeakPtrFactory<PlatformKeysService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformKeysService);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_PLATFORM_KEYS_PLATFORM_KEYS_SERVICE_H_