Convert //remoting to use std::unique_ptr

remoting/host/setup/daemon_controller_delegate_mac.mm

 // Copyright 2013 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 <CoreFoundation/CoreFoundation.h>
-
 #include "remoting/host/setup/daemon_controller_delegate_mac.h"
 
+#include <CoreFoundation/CoreFoundation.h>
 #include <launch.h>
 #include <stdio.h>
 #include <sys/types.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/launchd.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_launch_data.h"
+#include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "remoting/host/constants_mac.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/usage_stats_consent.h"
 
 namespace remoting {
 
 DaemonControllerDelegateMac::DaemonControllerDelegateMac() {
 }
 
 DaemonControllerDelegateMac::~DaemonControllerDelegateMac() {
   DeregisterForPreferencePaneNotifications();
 }
 
 DaemonController::State DaemonControllerDelegateMac::GetState() {
   pid_t job_pid = base::mac::PIDForJob(kServiceName);
   if (job_pid < 0) {
     return DaemonController::STATE_UNKNOWN;
   } else if (job_pid == 0) {
     // Service is stopped, or a start attempt failed.
     return DaemonController::STATE_STOPPED;
   } else {
     return DaemonController::STATE_STARTED;
   }
 }
 
-scoped_ptr<base::DictionaryValue> DaemonControllerDelegateMac::GetConfig() {
+std::unique_ptr<base::DictionaryValue>
+DaemonControllerDelegateMac::GetConfig() {
   base::FilePath config_path(kHostConfigFilePath);
-  scoped_ptr<base::DictionaryValue> host_config(
+  std::unique_ptr<base::DictionaryValue> host_config(
       HostConfigFromJsonFile(config_path));
   if (!host_config)
     return nullptr;
 
-  scoped_ptr<base::DictionaryValue> config(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> config(new base::DictionaryValue);
   std::string value;
   if (host_config->GetString(kHostIdConfigPath, &value))
     config->SetString(kHostIdConfigPath, value);
   if (host_config->GetString(kXmppLoginConfigPath, &value))
     config->SetString(kXmppLoginConfigPath, value);
   return config;
 }
 
 void DaemonControllerDelegateMac::SetConfigAndStart(
-    scoped_ptr<base::DictionaryValue> config,
+    std::unique_ptr<base::DictionaryValue> config,
     bool consent,
     const DaemonController::CompletionCallback& done) {
   config->SetBoolean(kUsageStatsConsentConfigPath, consent);
   ShowPreferencePane(HostConfigToJson(*config), done);
 }
 
 void DaemonControllerDelegateMac::UpdateConfig(
-    scoped_ptr<base::DictionaryValue> config,
+    std::unique_ptr<base::DictionaryValue> config,
     const DaemonController::CompletionCallback& done) {
   base::FilePath config_file_path(kHostConfigFilePath);
-  scoped_ptr<base::DictionaryValue> host_config(
+  std::unique_ptr<base::DictionaryValue> host_config(
       HostConfigFromJsonFile(config_file_path));
   if (!host_config) {
     done.Run(DaemonController::RESULT_FAILED);
     return;
   }
 
   host_config->MergeDictionary(config.get());
   ShowPreferencePane(HostConfigToJson(*host_config), done);
 }
 
 void DaemonControllerDelegateMac::Stop(
     const DaemonController::CompletionCallback& done) {
   ShowPreferencePane("", done);
 }
 
 DaemonController::UsageStatsConsent
 DaemonControllerDelegateMac::GetUsageStatsConsent() {
   DaemonController::UsageStatsConsent consent;
   consent.supported = true;
   consent.allowed = false;
   // set_by_policy is not yet supported.
   consent.set_by_policy = false;
 
   base::FilePath config_file_path(kHostConfigFilePath);
-  scoped_ptr<base::DictionaryValue> host_config(
+  std::unique_ptr<base::DictionaryValue> host_config(
       HostConfigFromJsonFile(config_file_path));
   if (host_config) {
     host_config->GetBoolean(kUsageStatsConsentConfigPath, &consent.allowed);
   }
 
   return consent;
 }
 
 void DaemonControllerDelegateMac::ShowPreferencePane(
     const std::string& config_data,
@@ skipping 128 matching lines @@
   if (!self) {
     LOG(WARNING) << "Ignoring notification with nullptr observer: " << name;
     return;
   }
 
   self->PreferencePaneCallbackDelegate(name);
 }
 
 scoped_refptr<DaemonController> DaemonController::Create() {
   return new DaemonController(
-      make_scoped_ptr(new DaemonControllerDelegateMac()));
+      base::WrapUnique(new DaemonControllerDelegateMac()));
 }
 
 }  // namespace remoting