Convert JsonWriter::Write to taking a const ref for the in-param

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 "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 168 matching lines @@
   // Extract the unprivileged fields from the configuration.
   base::DictionaryValue unprivileged_config_dict;
   for (int i = 0; i < arraysize(kUnprivilegedConfigKeys); ++i) {
     const char* key = kUnprivilegedConfigKeys[i];
     base::string16 value;
     if (config_dict->GetString(key, &value)) {
       unprivileged_config_dict.SetString(key, value);
     }
   }
   std::string unprivileged_config_str;
-  base::JSONWriter::Write(&unprivileged_config_dict, &unprivileged_config_str);
+  base::JSONWriter::Write(unprivileged_config_dict, &unprivileged_config_str);
 
   // Write the full configuration file to a temporary location.
   base::FilePath full_config_file_path =
       remoting::GetConfigDir().Append(kConfigFileName);
   if (!WriteConfigFileToTemp(full_config_file_path,
                              kConfigFileSecurityDescriptor,
                              content)) {
     return false;
   }
 
@@ skipping 206 matching lines @@
   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;
-  base::JSONWriter::Write(config_old.get(), &config_updated_str);
+  base::JSONWriter::Write(*config_old, &config_updated_str);
   bool result = WriteConfig(config_updated_str);
 
   InvokeCompletionCallback(done, result);
 }
 
 void DaemonControllerDelegateWin::Stop(
     const DaemonController::CompletionCallback& done) {
   bool result = StopDaemon();
 
   InvokeCompletionCallback(done, result);
@@ skipping 24 matching lines @@
     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;
-  base::JSONWriter::Write(config.release(), &config_str);
+  base::JSONWriter::Write(*config, &config_str);
 
   // Determine the config directory path and create it if necessary.
   base::FilePath config_dir = remoting::GetConfigDir();
   if (!base::CreateDirectory(config_dir)) {
     PLOG(ERROR) << "Failed to create the config directory.";
     InvokeCompletionCallback(done, false);
     return;
   }
 
   if (!WriteConfig(config_str)) {
     InvokeCompletionCallback(done, false);
     return;
   }
 
   // Start daemon.
   InvokeCompletionCallback(done, StartDaemon());
 }
 
 scoped_refptr<DaemonController> DaemonController::Create() {
   scoped_ptr<DaemonController::Delegate> delegate(
       new DaemonControllerDelegateWin());
   return new DaemonController(delegate.Pass());
 }
 
 }  // namespace remoting