Convert //remoting to use std::unique_ptr

remoting/host/setup/daemon_controller_delegate_win.cc

 // 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 "remoting/host/setup/daemon_controller_delegate_win.h"
 
 #include <stddef.h>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/windows_version.h"
 #include "remoting/base/scoped_sc_handle_win.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/usage_stats_consent.h"
 #include "remoting/host/win/security_descriptor.h"
 
@@ skipping 34 matching lines @@
   kHostIdConfigPath, kHostOwnerConfigPath, kHostOwnerEmailConfigPath,
   kXmppLoginConfigPath };
 
 // The configuration keys whose values may be read by GetConfig().
 const char* const kUnprivilegedConfigKeys[] = {
   kHostIdConfigPath, kXmppLoginConfigPath };
 
 // Reads and parses the configuration file up to |kMaxConfigFileSize| in
 // size.
 bool ReadConfig(const base::FilePath& filename,
-                scoped_ptr<base::DictionaryValue>* config_out) {
+                std::unique_ptr<base::DictionaryValue>* config_out) {
   std::string file_content;
   if (!base::ReadFileToStringWithMaxSize(filename, &file_content,
                                          kMaxConfigFileSize)) {
     PLOG(ERROR) << "Failed to read '" << filename.value() << "'.";
     return false;
   }
 
   // Parse the JSON configuration, expecting it to contain a dictionary.
-  scoped_ptr<base::Value> value =
+  std::unique_ptr<base::Value> value =
       base::JSONReader::Read(file_content, base::JSON_ALLOW_TRAILING_COMMAS);
 
   base::DictionaryValue* dictionary;
   if (!value || !value->GetAsDictionary(&dictionary)) {
     LOG(ERROR) << "Failed to parse '" << filename.value() << "'.";
     return false;
   }
 
   ignore_result(value.release());
   config_out->reset(dictionary);
@@ skipping 63 matching lines @@
   return true;
 }
 
 // Writes the configuration file up to |kMaxConfigFileSize| in size.
 bool WriteConfig(const std::string& content) {
   if (content.length() > kMaxConfigFileSize) {
       return false;
   }
 
   // Extract the configuration data that the user will verify.
-  scoped_ptr<base::Value> config_value = base::JSONReader::Read(content);
+  std::unique_ptr<base::Value> config_value = base::JSONReader::Read(content);
   if (!config_value.get()) {
     return false;
   }
   base::DictionaryValue* config_dict = nullptr;
   if (!config_value->GetAsDictionary(&config_dict)) {
     return false;
   }
   std::string email;
   if (!config_dict->GetString(kHostOwnerEmailConfigPath, &email) &&
       !config_dict->GetString(kHostOwnerConfigPath, &email) &&
@@ skipping 188 matching lines @@
   SERVICE_STATUS status;
   if (!::QueryServiceStatus(service.Get(), &status)) {
     PLOG(ERROR) << "Failed to query the state of the '"
                 << kWindowsServiceName << "' service";
     return DaemonController::STATE_UNKNOWN;
   }
 
   return ConvertToDaemonState(status.dwCurrentState);
 }
 
-scoped_ptr<base::DictionaryValue> DaemonControllerDelegateWin::GetConfig() {
+std::unique_ptr<base::DictionaryValue>
+DaemonControllerDelegateWin::GetConfig() {
   base::FilePath config_dir = remoting::GetConfigDir();
 
   // Read the unprivileged part of host configuration.
-  scoped_ptr<base::DictionaryValue> config;
+  std::unique_ptr<base::DictionaryValue> config;
   if (!ReadConfig(config_dir.Append(kUnprivilegedConfigFileName), &config))
     return nullptr;
 
   return config;
 }
 
 void DaemonControllerDelegateWin::UpdateConfig(
-    scoped_ptr<base::DictionaryValue> config,
+    std::unique_ptr<base::DictionaryValue> config,
     const DaemonController::CompletionCallback& done) {
   // Check for bad keys.
   for (size_t i = 0; i < arraysize(kReadonlyKeys); ++i) {
     if (config->HasKey(kReadonlyKeys[i])) {
       LOG(ERROR) << "Cannot update config: '" << kReadonlyKeys[i]
                  << "' is read only.";
       InvokeCompletionCallback(done, false);
       return;
     }
   }
   // Get the old config.
   base::FilePath config_dir = remoting::GetConfigDir();
-  scoped_ptr<base::DictionaryValue> config_old;
+  std::unique_ptr<base::DictionaryValue> config_old;
   if (!ReadConfig(config_dir.Append(kConfigFileName), &config_old)) {
     InvokeCompletionCallback(done, false);
     return;
   }
 
   // Merge items from the given config into the old config.
   config_old->MergeDictionary(config.release());
 
   // Write the updated config.
   std::string config_updated_str;
@@ skipping 24 matching lines @@
   // consent to collecting crash dumps.
   if (remoting::GetUsageStatsConsent(&allowed, &set_by_policy)) {
     consent.allowed = allowed;
     consent.set_by_policy = set_by_policy;
   }
 
   return consent;
 }
 
 void DaemonControllerDelegateWin::SetConfigAndStart(
-    scoped_ptr<base::DictionaryValue> config,
+    std::unique_ptr<base::DictionaryValue> config,
     bool consent,
     const DaemonController::CompletionCallback& done) {
   // Record the user's consent.
   if (!remoting::SetUsageStatsConsent(consent)) {
     InvokeCompletionCallback(done, false);
     return;
   }
 
   // Set the configuration.
   std::string config_str;
@@ skipping 11 matching lines @@
     InvokeCompletionCallback(done, false);
     return;
   }
 
   // Start daemon.
   InvokeCompletionCallback(done, StartDaemon());
 }
 
 scoped_refptr<DaemonController> DaemonController::Create() {
   return new DaemonController(
-      make_scoped_ptr(new DaemonControllerDelegateWin()));
+      base::WrapUnique(new DaemonControllerDelegateWin()));
 }
 
 }  // namespace remoting