Add a source id to global NetLog entries.

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>
 
@@ skipping 115 matching lines @@
     // Returns the NetLog we are currently watching, if any.  Returns NULL
     // 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.
+    // |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.
     virtual void OnAddEntry(EventType type,

[eroman, 2012/03/14 21:53:48]

I think we can probably just remove this in favor of the timeless version.

I don't remember exactly why I had the time parameter. It was either for
unit-tests, or some attempt at avoiding duplicated calls to TimeTicks::Now() in
code which already got the time (the latter seems un-important).

Feel free not to do that as part of this CL, I can investigate that afterwards.

[mmenke, 2012/03/14 22:25:23]

I thought it was so that times from the CapturingBoundNetLog on other threads
would be preserved.  (Left as-is, for this CL)

                             const base::TimeTicks& time,
                             const Source& source,
                             EventPhase phase,
                             EventParameters* params) = 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);
   };
 
   NetLog() {}
   virtual ~NetLog() {}
 
-  // Emits an event to the log stream.
-  //  |type| - The type of the event.
-  //  |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<> instead.
-  virtual void AddEntry(EventType type,
-                        const base::TimeTicks& time,
-                        const Source& source,
-                        EventPhase phase,
-                        EventParameters* params) = 0;
+  // Emits a global event to the log stream, with its own unique source id.

[eroman, 2012/03/14 21:53:48]

nit: source ID for consistency

[mmenke, 2012/03/14 22:25:23]

Done

+  void AddGlobalEntry(EventType type,
+                      const scoped_refptr<EventParameters>& params);
 
   // Returns a unique ID which can be used as a source ID.
   virtual uint32 NextID() = 0;
 
   // Returns the logging level for this NetLog. This is used to avoid computing
   // and saving expensive log entries.
   virtual LogLevel GetLogLevel() const = 0;
 
   // Adds an observer and sets its log level.  The observer must not be
   // watching any NetLog, including this one, when this is called.
@@ skipping 45 matching lines @@
   // 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);
 
  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;
+
   // 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;
+
   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) {}
 
-  BoundNetLog(const NetLog::Source& source, NetLog* net_log)
-      : source_(source), net_log_(net_log) {
-  }
-
   // Convenience methods that call through to the NetLog, passing in the
   // currently bound source.
   void AddEntry(NetLog::EventType type,
                 NetLog::EventPhase phase,
                 const scoped_refptr<NetLog::EventParameters>& params) const;
 
-  void AddEntryWithTime(
-      NetLog::EventType type,
-      const base::TimeTicks& time,
-      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,
                   const scoped_refptr<NetLog::EventParameters>& params) const;
   void EndEvent(NetLog::EventType event_type,
                 const scoped_refptr<NetLog::EventParameters>& params) const;
 
@@ skipping 25 matching lines @@
   bool IsLoggingAllEvents() const;
 
   // Helper to create a BoundNetLog given a NetLog and a SourceType. Takes care
   // of creating a unique source ID, and handles the case of NULL net_log.
   static BoundNetLog Make(NetLog* net_log, NetLog::SourceType source_type);
 
   const NetLog::Source& source() const { return source_; }
   NetLog* net_log() const { return net_log_; }
 
  private:
+  BoundNetLog(const NetLog::Source& source, NetLog* net_log)
+      : source_(source), net_log_(net_log) {
+  }
+
   NetLog::Source source_;
   NetLog* net_log_;
 };
 
 // NetLogStringParameter is a subclass of EventParameters that encapsulates a
 // single std::string parameter.
 class NET_EXPORT NetLogStringParameter : public NetLog::EventParameters {
  public:
   // |name| must be a string literal.
   NetLogStringParameter(const char* name, const std::string& value);
@@ skipping 68 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_