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

chrome/browser/chromeos/policy/device_cloud_policy_manager_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_manager_chromeos.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/attestation/attestation_policy_observer.h"
 #include "chrome/browser/chromeos/login/enrollment/auto_enrollment_controller.h"
 #include "chrome/browser/chromeos/login/startup_utils.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/enterprise_install_attributes.h"
 #include "chrome/browser/chromeos/policy/heartbeat_scheduler.h"
@@ skipping 74 matching lines @@
 
 // Checks whether forced re-enrollment is enabled.
 bool ForcedReEnrollmentEnabled() {
   return chromeos::AutoEnrollmentController::GetMode() ==
          chromeos::AutoEnrollmentController::MODE_FORCED_RE_ENROLLMENT;
 }
 
 }  // namespace
 
 DeviceCloudPolicyManagerChromeOS::DeviceCloudPolicyManagerChromeOS(
-    scoped_ptr<DeviceCloudPolicyStoreChromeOS> store,
+    std::unique_ptr<DeviceCloudPolicyStoreChromeOS> store,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     ServerBackedStateKeysBroker* state_keys_broker)
     : CloudPolicyManager(
           dm_protocol::kChromeDevicePolicyType,
           std::string(),
           store.get(),
           task_runner,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)),
       device_store_(std::move(store)),
@@ skipping 114 matching lines @@
 
   return machine_id;
 }
 
 // static
 std::string DeviceCloudPolicyManagerChromeOS::GetMachineModel() {
   return GetMachineStatistic(chromeos::system::kHardwareClassKey);
 }
 
 void DeviceCloudPolicyManagerChromeOS::StartConnection(
-    scoped_ptr<CloudPolicyClient> client_to_connect,
+    std::unique_ptr<CloudPolicyClient> client_to_connect,
     EnterpriseInstallAttributes* install_attributes) {
   CHECK(!service());
 
   // Set state keys here so the first policy fetch submits them to the server.
   if (ForcedReEnrollmentEnabled())
     client_to_connect->SetStateKeysToUpload(state_keys_broker_->state_keys());
 
   core()->Connect(std::move(client_to_connect));
   core()->StartRefreshScheduler();
-  core()->StartRemoteCommandsService(
-      scoped_ptr<RemoteCommandsFactory>(new DeviceCommandsFactoryChromeOS()));
+  core()->StartRemoteCommandsService(std::unique_ptr<RemoteCommandsFactory>(
+      new DeviceCommandsFactoryChromeOS()));
   core()->TrackRefreshDelayPref(local_state_,
                                 prefs::kDevicePolicyRefreshRate);
   attestation_policy_observer_.reset(
       new chromeos::attestation::AttestationPolicyObserver(client()));
 
   // Enable device reporting and status monitoring for enterprise enrolled
   // devices. We want to create these objects for enrolled devices, even if
   // monitoring is currently inactive, in case monitoring is turned back on in
   // a future policy fetch - the classes themselves track the current state of
   // the monitoring settings and only perform monitoring if it is active.
@@ skipping 73 matching lines @@
 }
 
 void DeviceCloudPolicyManagerChromeOS::NotifyDisconnected() {
   FOR_EACH_OBSERVER(
       Observer, observers_, OnDeviceCloudPolicyManagerDisconnected());
 }
 
 void DeviceCloudPolicyManagerChromeOS::CreateStatusUploader() {
   status_uploader_.reset(new StatusUploader(
       client(),
-      make_scoped_ptr(new DeviceStatusCollector(
+      base::WrapUnique(new DeviceStatusCollector(
           local_state_, chromeos::system::StatisticsProvider::GetInstance(),
           DeviceStatusCollector::LocationUpdateRequester(),
           DeviceStatusCollector::VolumeInfoFetcher(),
           DeviceStatusCollector::CPUStatisticsFetcher(),
           DeviceStatusCollector::CPUTempFetcher())),
       task_runner_));
 }
 
 }  // namespace policy