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

chrome/browser/chromeos/policy/user_cloud_policy_store_chromeos.cc

 // Copyright (c) 2012 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/policy/user_cloud_policy_store_chromeos.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 50 matching lines @@
 
 }  // namespace
 
 // Helper class for loading legacy policy caches.
 class LegacyPolicyCacheLoader : public UserPolicyTokenLoader::Delegate,
                                 public UserPolicyDiskCache::Delegate {
  public:
   typedef base::Callback<void(const std::string&,
                               const std::string&,
                               CloudPolicyStore::Status,
-                              scoped_ptr<em::PolicyFetchResponse>)> Callback;
+                              std::unique_ptr<em::PolicyFetchResponse>)>
+      Callback;
 
   LegacyPolicyCacheLoader(
       const base::FilePath& token_cache_file,
       const base::FilePath& policy_cache_file,
       scoped_refptr<base::SequencedTaskRunner> background_task_runner);
   ~LegacyPolicyCacheLoader() override;
 
   // Starts loading, and reports the result to |callback| when done.
   void Load(const Callback& callback);
 
@@ skipping 12 matching lines @@
 
   // Maps a disk cache LoadResult to a CloudPolicyStore::Status.
   static CloudPolicyStore::Status TranslateLoadResult(
       UserPolicyDiskCache::LoadResult result);
 
   scoped_refptr<UserPolicyTokenLoader> token_loader_;
   scoped_refptr<UserPolicyDiskCache> policy_cache_;
 
   std::string dm_token_;
   std::string device_id_;
-  scoped_ptr<em::PolicyFetchResponse> policy_;
+  std::unique_ptr<em::PolicyFetchResponse> policy_;
   CloudPolicyStore::Status status_;
 
   Callback callback_;
 
   base::WeakPtrFactory<LegacyPolicyCacheLoader> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(LegacyPolicyCacheLoader);
 };
 
 LegacyPolicyCacheLoader::LegacyPolicyCacheLoader(
@@ skipping 80 matching lines @@
       legacy_caches_loaded_(false),
       policy_key_loaded_(false),
       weak_factory_(this) {}
 
 UserCloudPolicyStoreChromeOS::~UserCloudPolicyStoreChromeOS() {}
 
 void UserCloudPolicyStoreChromeOS::Store(
     const em::PolicyFetchResponse& policy) {
   // Cancel all pending requests.
   weak_factory_.InvalidateWeakPtrs();
-  scoped_ptr<em::PolicyFetchResponse> response(
+  std::unique_ptr<em::PolicyFetchResponse> response(
       new em::PolicyFetchResponse(policy));
   EnsurePolicyKeyLoaded(
       base::Bind(&UserCloudPolicyStoreChromeOS::ValidatePolicyForStore,
                  weak_factory_.GetWeakPtr(),
                  base::Passed(&response)));
 }
 
 void UserCloudPolicyStoreChromeOS::Load() {
   // Cancel all pending requests.
   weak_factory_.InvalidateWeakPtrs();
@@ skipping 16 matching lines @@
       session_manager_client_->BlockingRetrievePolicyForUser(
           cryptohome::Identification(account_id_));
   if (policy_blob.empty()) {
     // The session manager doesn't have policy, or the call failed.
     // Just notify that the load is done, and don't bother with the legacy
     // caches in this case.
     NotifyStoreLoaded();
     return;
   }
 
-  scoped_ptr<em::PolicyFetchResponse> policy(new em::PolicyFetchResponse());
+  std::unique_ptr<em::PolicyFetchResponse> policy(
+      new em::PolicyFetchResponse());
   if (!policy->ParseFromString(policy_blob)) {
     status_ = STATUS_PARSE_ERROR;
     NotifyStoreError();
     return;
   }
 
   std::string sanitized_username =
       cryptohome_client_->BlockingGetSanitizedUsername(
           cryptohome::Identification(account_id_));
   if (sanitized_username.empty()) {
     status_ = STATUS_LOAD_ERROR;
     NotifyStoreError();
     return;
   }
 
   policy_key_path_ = user_policy_key_dir_.Append(
       base::StringPrintf(kPolicyKeyFile, sanitized_username.c_str()));
   LoadPolicyKey(policy_key_path_, &policy_key_);
   policy_key_loaded_ = true;
 
-  scoped_ptr<UserCloudPolicyValidator> validator =
+  std::unique_ptr<UserCloudPolicyValidator> validator =
       CreateValidatorForLoad(std::move(policy));
   validator->RunValidation();
   OnRetrievedPolicyValidated(validator.get());
 }
 
 void UserCloudPolicyStoreChromeOS::ValidatePolicyForStore(
-    scoped_ptr<em::PolicyFetchResponse> policy) {
+    std::unique_ptr<em::PolicyFetchResponse> policy) {
   // Create and configure a validator.
-  scoped_ptr<UserCloudPolicyValidator> validator = CreateValidator(
+  std::unique_ptr<UserCloudPolicyValidator> validator = CreateValidator(
       std::move(policy), CloudPolicyValidatorBase::TIMESTAMP_REQUIRED);
   validator->ValidateUsername(account_id_.GetUserEmail(), true);
   if (policy_key_.empty()) {
     validator->ValidateInitialKey(GetPolicyVerificationKey(),
                                   ExtractDomain(account_id_.GetUserEmail()));
   } else {
     const bool allow_rotation = true;
     validator->ValidateSignature(policy_key_, GetPolicyVerificationKey(),
                                  ExtractDomain(account_id_.GetUserEmail()),
                                  allow_rotation);
@@ skipping 61 matching lines @@
       // the world about the policy update.
       policy_.reset();
       NotifyStoreLoaded();
     }
     return;
   }
 
   // Policy is supplied by session_manager. Disregard legacy data from now on.
   legacy_loader_.reset();
 
-  scoped_ptr<em::PolicyFetchResponse> policy(new em::PolicyFetchResponse());
+  std::unique_ptr<em::PolicyFetchResponse> policy(
+      new em::PolicyFetchResponse());
   if (!policy->ParseFromString(policy_blob)) {
     status_ = STATUS_PARSE_ERROR;
     NotifyStoreError();
     return;
   }
 
   // Load |policy_key_| to verify the loaded policy.
   EnsurePolicyKeyLoaded(
       base::Bind(&UserCloudPolicyStoreChromeOS::ValidateRetrievedPolicy,
                  weak_factory_.GetWeakPtr(),
                  base::Passed(&policy)));
 }
 
 void UserCloudPolicyStoreChromeOS::ValidateRetrievedPolicy(
-    scoped_ptr<em::PolicyFetchResponse> policy) {
+    std::unique_ptr<em::PolicyFetchResponse> policy) {
   // Create and configure a validator for the loaded policy.
-  scoped_ptr<UserCloudPolicyValidator> validator =
+  std::unique_ptr<UserCloudPolicyValidator> validator =
       CreateValidatorForLoad(std::move(policy));
   // Start validation. The Validator will delete itself once validation is
   // complete.
   validator.release()->StartValidation(
       base::Bind(&UserCloudPolicyStoreChromeOS::OnRetrievedPolicyValidated,
                  weak_factory_.GetWeakPtr()));
 }
 
 void UserCloudPolicyStoreChromeOS::OnRetrievedPolicyValidated(
     UserCloudPolicyValidator* validator) {
@@ skipping 23 matching lines @@
                    legacy_cache_dir_));
     legacy_cache_dir_.clear();
   }
   NotifyStoreLoaded();
 }
 
 void UserCloudPolicyStoreChromeOS::OnLegacyLoadFinished(
     const std::string& dm_token,
     const std::string& device_id,
     Status status,
-    scoped_ptr<em::PolicyFetchResponse> policy) {
+    std::unique_ptr<em::PolicyFetchResponse> policy) {
   status_ = status;
   if (policy.get()) {
     // Create and configure a validator for the loaded legacy policy. Note that
     // the signature on this policy is not verified.
-    scoped_ptr<UserCloudPolicyValidator> validator = CreateValidator(
+    std::unique_ptr<UserCloudPolicyValidator> validator = CreateValidator(
         std::move(policy), CloudPolicyValidatorBase::TIMESTAMP_REQUIRED);
     validator->ValidateUsername(account_id_.GetUserEmail(), true);
     validator.release()->StartValidation(
         base::Bind(&UserCloudPolicyStoreChromeOS::OnLegacyPolicyValidated,
                    weak_factory_.GetWeakPtr(),
                    dm_token,
                    device_id));
   } else {
     InstallLegacyTokens(dm_token, device_id);
   }
@@ skipping 117 matching lines @@
   if (call_status == chromeos::DBUS_METHOD_CALL_SUCCESS &&
       !sanitized_username.empty()) {
     policy_key_path_ = user_policy_key_dir_.Append(
         base::StringPrintf(kPolicyKeyFile, sanitized_username.c_str()));
   } else {
     SampleValidationFailure(VALIDATION_FAILURE_DBUS);
   }
   ReloadPolicyKey(callback);
 }
 
-scoped_ptr<UserCloudPolicyValidator>
+std::unique_ptr<UserCloudPolicyValidator>
 UserCloudPolicyStoreChromeOS::CreateValidatorForLoad(
-    scoped_ptr<em::PolicyFetchResponse> policy) {
-  scoped_ptr<UserCloudPolicyValidator> validator = CreateValidator(
+    std::unique_ptr<em::PolicyFetchResponse> policy) {
+  std::unique_ptr<UserCloudPolicyValidator> validator = CreateValidator(
       std::move(policy), CloudPolicyValidatorBase::TIMESTAMP_NOT_BEFORE);
   validator->ValidateUsername(account_id_.GetUserEmail(), true);
   const bool allow_rotation = false;
   const std::string empty_key = std::string();
   // The policy loaded from session manager need not be validated using the
   // verification key since it is secure, and since there may be legacy policy
   // data that was stored without a verification key. Hence passing an empty
   // value for the verification key.
   validator->ValidateSignature(policy_key_, empty_key,
                                ExtractDomain(account_id_.GetUserEmail()),
                                allow_rotation);
   return validator;
 }
 }  // namespace policy