Change NetLog::ParametersCallback to return a scoped_ptr.

net/log/net_log.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 "net/log/net_log.h"
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 namespace {
 
 // Returns parameters for logging data transferred events. At a minum includes
 // the number of bytes transferred. If the capture mode allows logging byte
 // contents and |byte_count| > 0, then will include the actual bytes. The
 // bytes are hex-encoded, since base::StringValue only supports UTF-8.
-base::Value* BytesTransferredCallback(int byte_count,
-                                      const char* bytes,
-                                      NetLogCaptureMode capture_mode) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+scoped_ptr<base::Value> BytesTransferredCallback(
+    int byte_count,
+    const char* bytes,
+    NetLogCaptureMode capture_mode) {
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("byte_count", byte_count);
   if (capture_mode.include_socket_bytes() && byte_count > 0)
     dict->SetString("hex_encoded_bytes", base::HexEncode(bytes, byte_count));
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* SourceEventParametersCallback(
+scoped_ptr<base::Value> SourceEventParametersCallback(
     const NetLog::Source source,
     NetLogCaptureMode /* capture_mode */) {
   if (!source.IsValid())
-    return NULL;
-  base::DictionaryValue* event_params = new base::DictionaryValue();
-  source.AddToEventParameters(event_params);
-  return event_params;
+    return scoped_ptr<base::Value>();
+  scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
+  source.AddToEventParameters(event_params.get());
+  return event_params.Pass();
 }
 
-base::Value* NetLogBoolCallback(const char* name,
-                                bool value,
-                                NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* event_params = new base::DictionaryValue();
+scoped_ptr<base::Value> NetLogBoolCallback(
+    const char* name,
+    bool value,
+    NetLogCaptureMode /* capture_mode */) {
+  scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetBoolean(name, value);
-  return event_params;
+  return event_params.Pass();
 }
 
-base::Value* NetLogIntegerCallback(const char* name,
-                                   int value,
-                                   NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* event_params = new base::DictionaryValue();
+scoped_ptr<base::Value> NetLogIntegerCallback(
+    const char* name,
+    int value,
+    NetLogCaptureMode /* capture_mode */) {
+  scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetInteger(name, value);
-  return event_params;
+  return event_params.Pass();
 }
 
-base::Value* NetLogInt64Callback(const char* name,
-                                 int64 value,
-                                 NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* event_params = new base::DictionaryValue();
+scoped_ptr<base::Value> NetLogInt64Callback(
+    const char* name,
+    int64 value,
+    NetLogCaptureMode /* capture_mode */) {
+  scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetString(name, base::Int64ToString(value));
-  return event_params;
+  return event_params.Pass();
 }
 
-base::Value* NetLogStringCallback(const char* name,
-                                  const std::string* value,
-                                  NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* event_params = new base::DictionaryValue();
+scoped_ptr<base::Value> NetLogStringCallback(
+    const char* name,
+    const std::string* value,
+    NetLogCaptureMode /* capture_mode */) {
+  scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetString(name, *value);
-  return event_params;
+  return event_params.Pass();
 }
 
-base::Value* NetLogString16Callback(const char* name,
-                                    const base::string16* value,
-                                    NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* event_params = new base::DictionaryValue();
+scoped_ptr<base::Value> NetLogString16Callback(
+    const char* name,
+    const base::string16* value,
+    NetLogCaptureMode /* capture_mode */) {
+  scoped_ptr<base::DictionaryValue> event_params(new base::DictionaryValue());
   event_params->SetString(name, *value);
-  return event_params;
+  return event_params.Pass();
 }
 
 }  // namespace
 
 // LoadTimingInfo requires this be 0.
 const uint32 NetLog::Source::kInvalidId = 0;
 
 NetLog::Source::Source() : type(SOURCE_NONE), id(kInvalidId) {
 }
 
@@ skipping 58 matching lines @@
         data_->parameters_callback->Run(capture_mode_));
     if (value)
       entry_dict->Set("params", value.Pass());
   }
 
   return entry_dict;
 }
 
 base::Value* NetLog::Entry::ParametersToValue() const {
   if (data_->parameters_callback)
-    return data_->parameters_callback->Run(capture_mode_);
+    return data_->parameters_callback->Run(capture_mode_).release();
   return NULL;
 }
 
 NetLog::EntryData::EntryData(EventType type,
                              Source source,
                              EventPhase phase,
                              base::TimeTicks time,
                              const ParametersCallback* parameters_callback)
     : type(type),
       source(source),
@@ skipping 113 matching lines @@
 #include "net/log/net_log_event_type_list.h"
 #undef EVENT_TYPE
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 // static
 base::Value* NetLog::GetEventTypesAsValue() {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   for (int i = 0; i < EVENT_COUNT; ++i) {
     dict->SetInteger(EventTypeToString(static_cast<EventType>(i)), i);
   }
-  return dict;
+  return dict.release();
 }
 
 // static
 const char* NetLog::SourceTypeToString(SourceType source) {
   switch (source) {
 #define SOURCE_TYPE(label) \
   case SOURCE_##label:     \
     return #label;
 #include "net/log/net_log_source_type_list.h"
 #undef SOURCE_TYPE
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 // static
 base::Value* NetLog::GetSourceTypesAsValue() {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   for (int i = 0; i < SOURCE_COUNT; ++i) {
     dict->SetInteger(SourceTypeToString(static_cast<SourceType>(i)), i);
   }
-  return dict;
+  return dict.release();
 }
 
 // static
 const char* NetLog::EventPhaseToString(EventPhase phase) {
   switch (phase) {
     case PHASE_BEGIN:
       return "PHASE_BEGIN";
     case PHASE_END:
       return "PHASE_END";
     case PHASE_NONE:
@@ skipping 146 matching lines @@
   Liveness liveness = liveness_;
 
   if (liveness == ALIVE)
     return;
 
   base::debug::Alias(&liveness);
   CHECK_EQ(ALIVE, liveness);
 }
 
 }  // namespace net