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

chrome/browser/chromeos/policy/device_cloud_policy_initializer.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/policy/device_cloud_policy_initializer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
 #include "chrome/browser/chromeos/policy/enrollment_config.h"
 #include "chrome/browser/chromeos/policy/enrollment_handler_chromeos.h"
 #include "chrome/browser/chromeos/policy/enrollment_status_chromeos.h"
 #include "chrome/browser/chromeos/policy/enterprise_install_attributes.h"
@@ skipping 179 matching lines @@
   TryToCreateClient();
 }
 
 void DeviceCloudPolicyInitializer::OnStoreError(CloudPolicyStore* store) {
   // Do nothing.
 }
 
 void DeviceCloudPolicyInitializer::EnrollmentCompleted(
     const EnrollmentCallback& enrollment_callback,
     EnrollmentStatus status) {
-  scoped_ptr<CloudPolicyClient> client = enrollment_handler_->ReleaseClient();
+  std::unique_ptr<CloudPolicyClient> client =
+      enrollment_handler_->ReleaseClient();
   enrollment_handler_.reset();
 
   if (status.status() == EnrollmentStatus::STATUS_SUCCESS) {
     StartConnection(std::move(client));
   } else {
     // Some attempts to create a client may be blocked because the enrollment
     // was in progress. We give it a try again.
     TryToCreateClient();
   }
 
   if (!enrollment_callback.is_null())
     enrollment_callback.Run(status);
 }
 
-scoped_ptr<CloudPolicyClient> DeviceCloudPolicyInitializer::CreateClient(
+std::unique_ptr<CloudPolicyClient> DeviceCloudPolicyInitializer::CreateClient(
     DeviceManagementService* device_management_service) {
   scoped_refptr<net::URLRequestContextGetter> request_context =
       new SystemPolicyRequestContext(
           g_browser_process->system_request_context(), GetUserAgent());
 
-  return make_scoped_ptr(
-      new CloudPolicyClient(DeviceCloudPolicyManagerChromeOS::GetMachineID(),
-                            DeviceCloudPolicyManagerChromeOS::GetMachineModel(),
-                            kPolicyVerificationKeyHash,
-                            device_management_service,
-                            request_context));
+  return base::WrapUnique(new CloudPolicyClient(
+      DeviceCloudPolicyManagerChromeOS::GetMachineID(),
+      DeviceCloudPolicyManagerChromeOS::GetMachineModel(),
+      kPolicyVerificationKeyHash, device_management_service, request_context));
 }
 
 void DeviceCloudPolicyInitializer::TryToCreateClient() {
   if (!device_store_->is_initialized() ||
       !device_store_->has_policy() ||
       state_keys_broker_->pending() ||
       enrollment_handler_) {
     return;
   }
 
   DeviceManagementService* service = nullptr;
   if (GetManagementMode(*device_store_->policy()) ==
       MANAGEMENT_MODE_CONSUMER_MANAGED) {
     service = consumer_service_;
   } else if (GetManagementMode(*device_store_->policy()) ==
              MANAGEMENT_MODE_ENTERPRISE_MANAGED) {
     service = enterprise_service_;
   }
 
   if (service)
     StartConnection(CreateClient(service));
 }
 
 void DeviceCloudPolicyInitializer::StartConnection(
-    scoped_ptr<CloudPolicyClient> client) {
+    std::unique_ptr<CloudPolicyClient> client) {
   if (!manager_->core()->service())
     manager_->StartConnection(std::move(client), install_attributes_);
 }
 
 }  // namespace policy