Make NetLog take in callbacks that return Values

net/base/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_BASE_NET_LOG_H_
 #define NET_BASE_NET_LOG_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "net/base/net_export.h"
 
 namespace base {
+class DictionaryValue;
 class TimeTicks;
 class Value;
 }
 
 namespace net {
 
 // NetLog is the destination for log messages generated by the network stack.
 // Each log message has a "source" field which identifies the specific entity
 // that generated the message (for example, which URLRequest or which
 // SocketStream).
@@ skipping 31 matching lines @@
   // 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 = 0;
 
     Source() : type(SOURCE_NONE), id(kInvalidId) {}
     Source(SourceType type, uint32 id) : type(type), id(id) {}
     bool is_valid() const { return id != kInvalidId; }
 
     // The caller takes ownership of the returned Value*.
+    // TODO(mmenke):  Remove this.
     base::Value* ToValue() const;
 
+    // Adds the source to a DictionaryValue containing event parameters,
+    // using the name "source_dependency".
+    void AddToEventParameters(base::DictionaryValue* event_params) const;
+
+    // Attempts to extract a Source from a set of event parameters.  Returns
+    // true and writes the result to |source| on success.  Returns false and
+    // makes |source| an invalid source on failure.
+    static bool FromEventParameters(base::Value* event_params, Source* source);
+
     SourceType type;
     uint32 id;
   };
 
   // Base class for associating additional parameters with an event. Log
   // observers need to know what specific derivations of EventParameters a
   // particular EventType uses, in order to get at the individual components.
   class NET_EXPORT EventParameters
       : public base::RefCountedThreadSafe<EventParameters> {
    public:
@@ skipping 20 matching lines @@
     LOG_ALL,
 
     // Log all events, but do not include the actual transferred bytes as
     // parameters for bytes sent/received events.
     LOG_ALL_BUT_BYTES,
 
     // Only log events which are cheap, and don't consume much memory.
     LOG_BASIC,
   };
 
+  // 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.
+  typedef base::Callback<base::Value*(LogLevel)> ParametersCallback;
+
+  class NET_EXPORT Entry {
+   public:
+    Entry(EventType type,
+          Source source,
+          EventPhase phase,
+          const ParametersCallback* parameters_callback,
+          LogLevel log_level);
+    ~Entry();
+
+    EventType type() const { return type_; }
+    Source source() const { return source_; }
+    EventPhase phase() const { return phase_; }
+
+    // Serializes the specified event to a Value.  The Value also includes the
+    // current time.  Caller takes ownership of returned Value.
+    base::Value* ToValue() const;
+
+    // Returns the parameters as a Value.  Returns NULL if there are no such
+    // objects.  Caller takes ownership of returned Value.
+    base::Value* ParametersToValue() const;
+
+   private:
+    const EventType type_;
+    const Source source_;
+    const EventPhase phase_;
+    const ParametersCallback* parameters_callback_;
+
+    // Log level when the event occurred.
+    const LogLevel log_level_;
+
+    DISALLOW_COPY_AND_ASSIGN(Entry);

[eroman, 2012/05/22 22:08:06]

I suggest leaving a comment warning not to enable copy semantics. Since
consumers that try to copy entries might end up with a stale
parameters_callback_.

+  };
+
   // An observer, that must ensure its own thread safety, for events
   // being added to a NetLog.
   class NET_EXPORT ThreadSafeObserver {
    public:
     // Constructs an observer that wants to see network events, with
     // the specified minimum event granularity.  A ThreadSafeObserver can only
     // observe a single NetLog at a time.
     //
     // Observers will be called on the same thread an entry is added on,
     // and are responsible for ensuring their own thread safety.
@@ skipping 11 matching lines @@
     // otherwise.
     NetLog* net_log() const;
 
     // This method will be called on the thread that the event occurs on.  It
     // is the responsibility of the observer to handle it in a thread safe
     // manner.
     //
     // It is illegal for an Observer to call any NetLog or
     // NetLog::Observer functions in response to a call to OnAddEntry.
     //
     // |type| - The type of the event.

[eroman, 2012/05/22 22:08:06]

Please update the parameters.

     // |time| - The time when the event occurred.
     // |source| - The source that generated the event.
     // |phase| - An optional parameter indicating whether this is the start/end
     //           of an action.
     // |params| - Optional (may be NULL) parameters for this event.
     //            The specific subclass of EventParameters is defined
     //            by the contract for events of this |type|.
     // TODO(eroman): Take a scoped_refptr<EventParameters> instead.

[eroman, 2012/05/22 22:08:06]

Please delete this comment.

-    virtual void OnAddEntry(EventType type,
-                            const base::TimeTicks& time,
-                            const Source& source,
-                            EventPhase phase,
-                            EventParameters* params) = 0;
+    virtual void OnAddEntry(const Entry& entry) = 0;
 
    private:
     friend class NetLog;
 
     // Both of these values are only modified by the NetLog.
     LogLevel log_level_;
     NetLog* net_log_;
 
     DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserver);
   };
@@ skipping 52 matching lines @@
   // Returns a C-String symbolic name for |source_type|.
   static const char* SourceTypeToString(SourceType source_type);
 
   // Returns a dictionary that maps source type symbolic names to their enum
   // values.  Caller takes ownership of the returned Value.
   static base::Value* GetSourceTypesAsValue();
 
   // Returns a C-String symbolic name for |event_phase|.
   static const char* EventPhaseToString(EventPhase event_phase);
 
-  // Serializes the specified event to a DictionaryValue.
-  // If |use_strings| is true, uses strings rather than numeric ids.
-  static base::Value* EntryToDictionaryValue(NetLog::EventType type,
-                                             const base::TimeTicks& time,
-                                             const NetLog::Source& source,
-                                             NetLog::EventPhase phase,
-                                             NetLog::EventParameters* params,
-                                             bool use_strings);
+  static Source GetSourceFromEventParameters(base::Value* event_params);
 
  protected:
-  // This is the internal function used by AddGlobalEntry and BoundNetLogs.
-  virtual void AddEntry(
-      EventType type,
-      const Source& source,
-      EventPhase phase,
-      const scoped_refptr<NetLog::EventParameters>& params) = 0;
+  // Child classes should respond to the new entry here.  This includes
+  // creating the Entry object and alerting their observers.
+  virtual void OnAddEntry(const Entry& entry) = 0;
 
   // Subclasses must call these in the corresponding functions to set an
   // observer's |net_log_| and |log_level_| values.
   void OnAddObserver(ThreadSafeObserver* observer, LogLevel log_level);
   void OnSetObserverLogLevel(ThreadSafeObserver* observer,
                              LogLevel log_level);
   void OnRemoveObserver(ThreadSafeObserver* observer);
 
  private:
   friend class BoundNetLog;
 
+  void AddEntry(EventType type,
+                const Source& source,
+                EventPhase phase,
+                const NetLog::ParametersCallback* parameters_callback);
+
   DISALLOW_COPY_AND_ASSIGN(NetLog);
 };
 
 // Helper that binds a Source to a NetLog, and exposes convenience methods to
 // output log messages without needing to pass in the source.
 class NET_EXPORT BoundNetLog {
  public:
   BoundNetLog() : net_log_(NULL) {}
 
-  // Convenience methods that call through to the NetLog, passing in the
-  // currently bound source.
+  void AddEntry(NetLog::EventType type, NetLog::EventPhase phase);
+  void AddEntry(NetLog::EventType type,
+                NetLog::EventPhase phase,
+                const NetLog::ParametersCallback& get_parameters);
+
+  void AddEvent(NetLog::EventType type);
+  void AddEvent(NetLog::EventType type,
+                const NetLog::ParametersCallback& get_parameters);
+
+  void BeginEvent(NetLog::EventType type);
+  void BeginEvent(NetLog::EventType type,
+                  const NetLog::ParametersCallback& get_parameters);
+
+  void EndEvent(NetLog::EventType type);
+  void EndEvent(NetLog::EventType type,
+                const NetLog::ParametersCallback& get_parameters);
+
   void AddEntry(NetLog::EventType type,
                 NetLog::EventPhase phase,
                 const scoped_refptr<NetLog::EventParameters>& params) const;
 
   // Convenience methods that call through to the NetLog, passing in the
   // currently bound source, current time, and a fixed "capture phase"
   // (begin, end, or none).
   void AddEvent(NetLog::EventType event_type,
                 const scoped_refptr<NetLog::EventParameters>& params) const;
   void BeginEvent(NetLog::EventType event_type,
@@ skipping 129 matching lines @@
 
  private:
   BoundNetLog net_log_;
   const NetLog::EventType event_type_;
   scoped_refptr<NetLog::EventParameters> end_event_params_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_LOG_H_