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

content/browser/tracing/tracing_ui.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 "content/browser/tracing/tracing_ui.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 22 matching lines @@
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
 
 namespace content {
 namespace {
 
 void OnGotCategories(const WebUIDataSource::GotDataCallback& callback,
                      const std::set<std::string>& categorySet) {
-  scoped_ptr<base::ListValue> category_list(new base::ListValue());
+  base::ListValue category_list;
   for (std::set<std::string>::const_iterator it = categorySet.begin();
        it != categorySet.end(); it++) {
-    category_list->AppendString(*it);
+    category_list.AppendString(*it);
   }
 
   base::RefCountedString* res = new base::RefCountedString();
-  base::JSONWriter::Write(category_list.get(), &res->data());
+  base::JSONWriter::Write(category_list, &res->data());
   callback.Run(res);
 }
 
 bool GetTracingOptions(const std::string& data64,
                        base::trace_event::CategoryFilter* category_filter,
                        base::trace_event::TraceOptions* tracing_options) {
   std::string data;
   if (!base::Base64Decode(data64, &data)) {
     LOG(ERROR) << "Options were not base64 encoded.";
     return false;
@@ skipping 65 matching lines @@
 void OnTraceBufferUsageResult(const WebUIDataSource::GotDataCallback& callback,
                               float percent_full,
                               size_t approximate_event_count) {
   std::string str = base::DoubleToString(percent_full);
   callback.Run(base::RefCountedString::TakeString(&str));
 }
 
 void OnTraceBufferStatusResult(const WebUIDataSource::GotDataCallback& callback,
                                float percent_full,
                                size_t approximate_event_count) {
-  scoped_ptr<base::DictionaryValue> status(new base::DictionaryValue());
-  status->SetDouble("percentFull", percent_full);
-  status->SetInteger("approximateEventCount", approximate_event_count);
+  base::DictionaryValue status;
+  status.SetDouble("percentFull", percent_full);
+  status.SetInteger("approximateEventCount", approximate_event_count);
 
   std::string status_json;
-  base::JSONWriter::Write(status.get(), &status_json);
+  base::JSONWriter::Write(status, &status_json);
 
   base::RefCountedString* status_base64 = new base::RefCountedString();
   base::Base64Encode(status_json, &status_base64->data());
   callback.Run(status_base64);
 }
 
 void OnMonitoringEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 
 bool EnableMonitoring(const std::string& data64,
                       const WebUIDataSource::GotDataCallback& callback) {
@@ skipping 18 matching lines @@
   callback.Run(res);
 }
 
 void GetMonitoringStatus(const WebUIDataSource::GotDataCallback& callback) {
   bool is_monitoring;
   base::trace_event::CategoryFilter category_filter("");
   base::trace_event::TraceOptions options;
   TracingController::GetInstance()->GetMonitoringStatus(
       &is_monitoring, &category_filter, &options);
 
-  scoped_ptr<base::DictionaryValue>
-    monitoring_options(new base::DictionaryValue());
-  monitoring_options->SetBoolean("isMonitoring", is_monitoring);
-  monitoring_options->SetString("categoryFilter", category_filter.ToString());
-  monitoring_options->SetBoolean("useSystemTracing", options.enable_systrace);
-  monitoring_options->SetBoolean(
+  base::DictionaryValue monitoring_options;
+  monitoring_options.SetBoolean("isMonitoring", is_monitoring);
+  monitoring_options.SetString("categoryFilter", category_filter.ToString());
+  monitoring_options.SetBoolean("useSystemTracing", options.enable_systrace);
+  monitoring_options.SetBoolean(
       "useContinuousTracing",
       options.record_mode == base::trace_event::RECORD_CONTINUOUSLY);
-  monitoring_options->SetBoolean("useSampling", options.enable_sampling);
+  monitoring_options.SetBoolean("useSampling", options.enable_sampling);
 
   std::string monitoring_options_json;
-  base::JSONWriter::Write(monitoring_options.get(), &monitoring_options_json);
+  base::JSONWriter::Write(monitoring_options, &monitoring_options_json);
 
   base::RefCountedString* monitoring_options_base64 =
     new base::RefCountedString();
   base::Base64Encode(monitoring_options_json,
                      &monitoring_options_base64->data());
   callback.Run(monitoring_options_base64);
 }
 
 void TracingCallbackWrapper(const WebUIDataSource::GotDataCallback& callback,
                             base::RefCountedString* data) {
@@ skipping 151 matching lines @@
     web_ui()->CallJavascriptFunction("onUploadComplete",
                                      base::StringValue(feedback));
   } else {
     web_ui()->CallJavascriptFunction("onUploadError",
                                      base::StringValue(feedback));
   }
   trace_uploader_.reset();
 }
 
 }  // namespace content