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

chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.cc

 // Copyright 2015 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 <map>
 #include <vector>
 
 #include "ash/test/ash_test_base.h"
 #include "base/json/json_writer.h"
 #include "base/run_loop.h"
@@ skipping 31 matching lines @@
     RemoteCommandJob::UniqueIDType unique_id,
     base::TimeDelta age_of_command,
     const std::string upload_url) {
   em::RemoteCommand command_proto;
   command_proto.set_type(
       enterprise_management::RemoteCommand_Type_DEVICE_SCREENSHOT);
   command_proto.set_unique_id(unique_id);
   command_proto.set_age_of_command(age_of_command.InMilliseconds());
   std::string payload;
   base::DictionaryValue root_dict;
-  root_dict.Set(kUploadUrlFieldName, new base::StringValue(upload_url));
-  base::JSONWriter::Write(&root_dict, &payload);
+  root_dict.SetString(kUploadUrlFieldName, upload_url);
+  base::JSONWriter::Write(root_dict, &payload);
   command_proto.set_payload(payload);
   return command_proto;
 }
 
 class MockUploadJob : public policy::UploadJob {
  public:
   // If |error_code| is a null pointer OnSuccess() will be invoked when the
   // Start() method is called, otherwise OnFailure() will be invoked with the
   // respective |error_code|.
   MockUploadJob(const GURL& upload_url,
@@ skipping 167 matching lines @@
   EXPECT_EQ(unique_id, job->unique_id());
   EXPECT_EQ(RemoteCommandJob::NOT_STARTED, job->status());
 }
 
 std::string DeviceCommandScreenshotTest::CreatePayloadFromResultCode(
     DeviceCommandScreenshotJob::ResultCode result_code) {
   std::string payload;
   base::DictionaryValue root_dict;
   if (result_code != DeviceCommandScreenshotJob::SUCCESS)
     root_dict.Set(kResultFieldName, new base::FundamentalValue(result_code));
-  base::JSONWriter::Write(&root_dict, &payload);
+  base::JSONWriter::Write(root_dict, &payload);
   return payload;
 }
 
 void DeviceCommandScreenshotTest::VerifyResults(
     RemoteCommandJob* job,
     RemoteCommandJob::Status expected_status,
     std::string expected_payload) {
   EXPECT_EQ(expected_status, job->status());
   if (job->status() == RemoteCommandJob::SUCCEEDED) {
     scoped_ptr<std::string> payload = job->GetResultPayload();
@@ skipping 31 matching lines @@
       base::Bind(&DeviceCommandScreenshotTest::VerifyResults,
                  base::Unretained(this), base::Unretained(job.get()),
                  RemoteCommandJob::FAILED,
                  CreatePayloadFromResultCode(
                      DeviceCommandScreenshotJob::FAILURE_AUTHENTICATION)));
   EXPECT_TRUE(success);
   run_loop_.Run();
 }
 
 }  // namespace policy