Updated NetLog::ParametersCallback & all related calbacks returning value as scoped_ptr<base::Value…

net/log/net_log.h

 // 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.
 
 #ifndef NET_LOG_NET_LOG_H_
 #define NET_LOG_NET_LOG_H_
 
 #include <string>
 
 #include "build/build_config.h"
 
 #include "base/atomicops.h"
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
+#include "base/values.h"
 #include "net/base/net_export.h"
 #include "net/log/net_log_capture_mode.h"
 
 namespace base {
 class DictionaryValue;
 class Value;
 }
 
 namespace net {
 
@@ skipping 34 matching lines @@
 #define SOURCE_TYPE(label) SOURCE_##label,
 #include "net/log/net_log_source_type_list.h"
 #undef SOURCE_TYPE
     SOURCE_COUNT
   };
 
   // A callback function that return a Value representation of the parameters
   // associated with an event.  If called, it will be called synchonously,
   // so it need not have owning references.  May be called more than once, or
   // not at all.  May return NULL.
-  typedef base::Callback<base::Value*(NetLogCaptureMode)> ParametersCallback;
+  typedef base::Callback<scoped_ptr<base::Value>(NetLogCaptureMode)>
+      ParametersCallback;
 
   // Identifies the entity that generated this log. The |id| field should
   // uniquely identify the source, and is used by log observers to infer
   // message groupings. Can use NetLog::NextID() to create unique IDs.
   struct NET_EXPORT Source {
     static const uint32 kInvalidId;
 
     Source();
     Source(SourceType type, uint32 id);
     bool IsValid() const;
@@ skipping 39 matching lines @@
     Entry(const EntryData* data, NetLogCaptureMode capture_mode);
     ~Entry();
 
     EventType type() const { return data_->type; }
     Source source() const { return data_->source; }
     EventPhase phase() const { return data_->phase; }
 
     // Serializes the specified event to a Value.  The Value also includes the
     // current time.  Caller takes ownership of returned Value.  Takes in a time
     // to allow back-dating entries.
-    base::Value* ToValue() const;
+    scoped_ptr<base::Value> ToValue() const;
 
     // Returns the parameters as a Value.  Returns NULL if there are no
     // parameters.  Caller takes ownership of returned Value.
-    base::Value* ParametersToValue() const;
+    scoped_ptr<base::Value> ParametersToValue() const;
 
    private:
     const EntryData* const data_;
 
     // Log capture mode when the event occurred.
     const NetLogCaptureMode capture_mode_;
 
     // It is not safe to copy this class, since |parameters_callback_| may
     // include pointers that become stale immediately after the event is added,
     // even if the code were modified to keep its own copy of the callback.
@@ skipping 239 matching lines @@
   NetLog::Source source_;
   NetLog* net_log_;
 
   // TODO(eroman): Temporary until crbug.com/467797 is solved.
   Liveness liveness_ = ALIVE;
 };
 
 }  // namespace net
 
 #endif  // NET_LOG_NET_LOG_H_