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

chrome/browser/chromeos/policy/device_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/device_cloud_policy_store_chromeos.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 35 matching lines @@
   scoped_refptr<ownership::PublicKey> public_key(
       device_settings_service_->GetPublicKey());
   if (!install_attributes_->IsEnterpriseDevice() ||
       !device_settings_service_->policy_data() || !public_key.get() ||
       !public_key->is_loaded()) {
     status_ = STATUS_BAD_STATE;
     NotifyStoreError();
     return;
   }
 
-  scoped_ptr<DeviceCloudPolicyValidator> validator(CreateValidator(policy));
+  std::unique_ptr<DeviceCloudPolicyValidator> validator(
+      CreateValidator(policy));
   validator->ValidateSignature(public_key->as_string(),
                                GetPolicyVerificationKey(),
                                install_attributes_->GetDomain(),
                                true);
   validator->ValidateAgainstCurrentPolicy(
       device_settings_service_->policy_data(),
       CloudPolicyValidatorBase::TIMESTAMP_REQUIRED,
       CloudPolicyValidatorBase::DM_TOKEN_REQUIRED);
   validator.release()->StartValidation(
       base::Bind(&DeviceCloudPolicyStoreChromeOS::OnPolicyToStoreValidated,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DeviceCloudPolicyStoreChromeOS::Load() {
   device_settings_service_->Load();
 }
 
 void DeviceCloudPolicyStoreChromeOS::InstallInitialPolicy(
     const em::PolicyFetchResponse& policy) {
   // Cancel all pending requests.
   weak_factory_.InvalidateWeakPtrs();
 
   if (!install_attributes_->IsEnterpriseDevice()) {
     status_ = STATUS_BAD_STATE;
     NotifyStoreError();
     return;
   }
 
-  scoped_ptr<DeviceCloudPolicyValidator> validator(CreateValidator(policy));
+  std::unique_ptr<DeviceCloudPolicyValidator> validator(
+      CreateValidator(policy));
   validator->ValidateInitialKey(GetPolicyVerificationKey(),
                                 install_attributes_->GetDomain());
   validator.release()->StartValidation(
       base::Bind(&DeviceCloudPolicyStoreChromeOS::OnPolicyToStoreValidated,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DeviceCloudPolicyStoreChromeOS::OwnershipStatusChanged() {
   // Nothing to do.
 }
 
 void DeviceCloudPolicyStoreChromeOS::DeviceSettingsUpdated() {
   if (!weak_factory_.HasWeakPtrs())
     UpdateFromService();
 }
 
 void DeviceCloudPolicyStoreChromeOS::OnDeviceSettingsServiceShutdown() {
   device_settings_service_ = nullptr;
 }
 
-scoped_ptr<DeviceCloudPolicyValidator>
-    DeviceCloudPolicyStoreChromeOS::CreateValidator(
-        const em::PolicyFetchResponse& policy) {
-  scoped_ptr<DeviceCloudPolicyValidator> validator(
+std::unique_ptr<DeviceCloudPolicyValidator>
+DeviceCloudPolicyStoreChromeOS::CreateValidator(
+    const em::PolicyFetchResponse& policy) {
+  std::unique_ptr<DeviceCloudPolicyValidator> validator(
       DeviceCloudPolicyValidator::Create(
-          scoped_ptr<em::PolicyFetchResponse>(
+          std::unique_ptr<em::PolicyFetchResponse>(
               new em::PolicyFetchResponse(policy)),
           background_task_runner_));
   validator->ValidateDomain(install_attributes_->GetDomain());
   validator->ValidatePolicyType(dm_protocol::kChromeDevicePolicyType);
   validator->ValidatePayload();
   return validator;
 }
 
 void DeviceCloudPolicyStoreChromeOS::OnPolicyToStoreValidated(
     DeviceCloudPolicyValidator* validator) {
@@ skipping 108 matching lines @@
     case chromeos::DeviceSettingsService::STORE_VALIDATION_ERROR:
     case chromeos::DeviceSettingsService::STORE_TEMP_VALIDATION_ERROR:
       status_ = STATUS_LOAD_ERROR;
       break;
   }
 
   NotifyStoreError();
 }
 
 }  // namespace policy