Change NetLog::ParametersCallback to return a scoped_ptr.

components/data_reduction_proxy/core/common/data_reduction_proxy_event_creator.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 "components/data_reduction_proxy/core/common/data_reduction_proxy_event_creator.h"
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
@@ skipping 18 matching lines @@
   return entry_value;
 }
 
 int64 GetExpirationTicks(int bypass_seconds) {
   base::TimeTicks expiration_ticks =
       base::TimeTicks::Now() + base::TimeDelta::FromSeconds(bypass_seconds);
   return (expiration_ticks - base::TimeTicks()).InMilliseconds();
 }
 
 // A callback which creates a base::Value containing information about enabling
-// the Data Reduction Proxy. Ownership of the base::Value is passed to the
-// caller.
-base::Value* EnableDataReductionProxyCallback(
+// the Data Reduction Proxy.
+scoped_ptr<base::Value> EnableDataReductionProxyCallback(
     bool secure_transport_restricted,
     const std::vector<net::ProxyServer>& proxies_for_http,
     const std::vector<net::ProxyServer>& proxies_for_https,
     net::NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetBoolean("enabled", true);
   dict->SetBoolean("secure_transport_restricted", secure_transport_restricted);
   scoped_ptr<base::ListValue> http_proxy_list(new base::ListValue());
   for (const auto& proxy : proxies_for_http)
     http_proxy_list->AppendString(proxy.ToURI());
 
   scoped_ptr<base::ListValue> https_proxy_list(new base::ListValue());
   for (const auto& proxy : proxies_for_https)
     https_proxy_list->AppendString(proxy.ToURI());
 
   dict->Set("http_proxy_list", http_proxy_list.Pass());
   dict->Set("https_proxy_list", https_proxy_list.Pass());
 
-  return dict;
+  return dict.Pass();
 }
 
 // A callback which creates a base::Value containing information about disabling
-// the Data Reduction Proxy. Ownership of the base::Value is passed to the
-// caller.
-base::Value* DisableDataReductionProxyCallback(
+// the Data Reduction Proxy.
+scoped_ptr<base::Value> DisableDataReductionProxyCallback(
     net::NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetBoolean("enabled", false);
-  return dict;
+  return dict.Pass();
 }
 
 // A callback which creates a base::Value containing information about bypassing
-// the Data Reduction Proxy. Ownership of the base::Value is passed to the
-// caller.
-base::Value* UrlBypassActionCallback(
+// the Data Reduction Proxy.
+scoped_ptr<base::Value> UrlBypassActionCallback(
     DataReductionProxyBypassAction action,
     const std::string& request_method,
     const GURL& url,
     bool should_retry,
     int bypass_seconds,
     int64 expiration_ticks,
     net::NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("bypass_action_type", action);
   dict->SetString("method", request_method);
   dict->SetString("url", url.spec());
   dict->SetBoolean("should_retry", should_retry);
   dict->SetString("bypass_duration_seconds",
                   base::Int64ToString(bypass_seconds));
   dict->SetString("expiration", base::Int64ToString(expiration_ticks));
-  return dict;
+  return dict.Pass();
 }
 
 // A callback which creates a base::Value containing information about bypassing
-// the Data Reduction Proxy. Ownership of the base::Value is passed to the
-// caller.
-base::Value* UrlBypassTypeCallback(DataReductionProxyBypassType bypass_type,
-                                   const std::string& request_method,
-                                   const GURL& url,
-                                   bool should_retry,
-                                   int bypass_seconds,
-                                   int64 expiration_ticks,
-                                   net::NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+// the Data Reduction Proxy.
+scoped_ptr<base::Value> UrlBypassTypeCallback(
+    DataReductionProxyBypassType bypass_type,
+    const std::string& request_method,
+    const GURL& url,
+    bool should_retry,
+    int bypass_seconds,
+    int64 expiration_ticks,
+    net::NetLogCaptureMode /* capture_mode */) {
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("bypass_type", bypass_type);
   dict->SetString("method", request_method);
   dict->SetString("url", url.spec());
   dict->SetBoolean("should_retry", should_retry);
   dict->SetString("bypass_duration_seconds",
                   base::Int64ToString(bypass_seconds));
   dict->SetString("expiration", base::Int64ToString(expiration_ticks));
-  return dict;
+  return dict.Pass();
 }
 
 // A callback which creates a base::Value containing information about
-// completing the Data Reduction Proxy secure proxy check. Ownership of the
-// base::Value is passed to the caller.
-base::Value* EndCanaryRequestCallback(
+// completing the Data Reduction Proxy secure proxy check.
+scoped_ptr<base::Value> EndCanaryRequestCallback(
     int net_error,
     int http_response_code,
     bool succeeded,
     net::NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("net_error", net_error);
   dict->SetInteger("http_response_code", http_response_code);
   dict->SetBoolean("check_succeeded", succeeded);
-  return dict;
+  return dict.Pass();
 }
 
 // A callback that creates a base::Value containing information about
-// completing the Data Reduction Proxy configuration request. Ownership of the
-// base::Value is passed to the caller.
-base::Value* EndConfigRequestCallback(
+// completing the Data Reduction Proxy configuration request.
+scoped_ptr<base::Value> EndConfigRequestCallback(
     int net_error,
     int http_response_code,
     int failure_count,
     int64 expiration_ticks,
     net::NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("net_error", net_error);
   dict->SetInteger("http_response_code", http_response_code);
   dict->SetInteger("failure_count", failure_count);
   dict->SetString("expiration", base::Int64ToString(expiration_ticks));
-  return dict;
+  return dict.Pass();
 }
 
 }  // namespace
 
 DataReductionProxyEventCreator::DataReductionProxyEventCreator(
     DataReductionProxyEventStorageDelegate* storage_delegate)
     : storage_delegate_(storage_delegate) {
   DCHECK(storage_delegate);
   // Constructed on the UI thread, but should be checked on the IO thread.
   thread_checker_.DetachFromThread();
@@ skipping 161 matching lines @@
     const net::NetLog::ParametersCallback& callback) {
   scoped_ptr<base::Value> event(
       BuildDataReductionProxyEvent(type, net_log.source(), phase, callback));
   if (event) {
     storage_delegate_->AddEvent(event.Pass());
     net_log.AddEntry(type, phase, callback);
   }
 }
 
 }  // namespace data_reduction_proxy