Add net log entries that summarize transmit and receive byte counts.

net/base/net_log.h

 // Copyright (c) 2010 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_
 
 #include <string>
 #include <vector>
 
@@ skipping 49 matching lines @@
     PHASE_END,
   };
 
   // The "source" identifies the entity that generated the log message.
   enum SourceType {
     SOURCE_NONE,
     SOURCE_URL_REQUEST,
     SOURCE_SOCKET_STREAM,
     SOURCE_INIT_PROXY_RESOLVER,
     SOURCE_CONNECT_JOB,
+    SOURCE_SOCKET,
   };
 
   // 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 Source {
-    Source() : type(SOURCE_NONE), id(-1) {}
-    Source(SourceType type, int id) : type(type), id(id) {}
+    static const uint32 kInvalidId = 0;
+
+    Source() : type(SOURCE_NONE), id(kInvalidId) {}
+    Source(SourceType type, uint32 id) : type(type), id(id) {}
+    bool is_valid() { return id != kInvalidId; }
 
     SourceType type;
-    int id;
+    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 EventParameters : public base::RefCounted<EventParameters> {
    public:
     EventParameters() {}
     virtual ~EventParameters() {}
 
@@ skipping 17 matching lines @@
   //  |extra_parameters| - Optional (may be NULL) parameters for this event.
   //                       The specific subclass of EventParameters is defined
   //                       by the contract for events of this |type|.
   virtual void AddEntry(EventType type,
                         const base::TimeTicks& time,
                         const Source& source,
                         EventPhase phase,
                         EventParameters* extra_parameters) = 0;
 
   // Returns a unique ID which can be used as a source ID.
-  virtual int NextID() = 0;
+  virtual uint32 NextID() = 0;
 
   // Returns true if more complicated messages should be sent to the log.
   // TODO(eroman): This is a carry-over from refactoring; figure out
   //               something better.
   virtual bool HasListener() const = 0;
 
   // Returns a C-String symbolic name for |event_type|.
   static const char* EventTypeToString(EventType event_type);
 
   // Returns a list of all the available EventTypes.
   static std::vector<EventType> GetAllEventTypes();
 
  private:
   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 BoundNetLog {
  public:
   BoundNetLog() : net_log_(NULL) {}
 
   // TODO(eroman): This is a complete hack to allow passing in NULL in
   // place of a BoundNetLog. I added this while refactoring to simplify the
   // task of updating all the callers.
-  BoundNetLog(int) : net_log_(NULL) {}
+  BoundNetLog(uint32) : net_log_(NULL) {}
 
   BoundNetLog(const NetLog::Source& source, NetLog* net_log)
       : source_(source), net_log_(net_log) {
   }
 
   void AddEntry(NetLog::EventType type,
                 NetLog::EventPhase phase,
                 NetLog::EventParameters* extra_parameters) const;
 
   void AddEntryWithTime(NetLog::EventType type,
                         const base::TimeTicks& time,
                         NetLog::EventPhase phase,
                         NetLog::EventParameters* extra_parameters) const;
 
   // Convenience methods that call through to the NetLog, passing in the
   // currently bound source.
   void AddEvent(NetLog::EventType event_type) const;
   void AddEventWithParameters(NetLog::EventType event_type,
                               NetLog::EventParameters* params) const;
   bool HasListener() const;
   void BeginEvent(NetLog::EventType event_type) const;
   void BeginEventWithParameters(NetLog::EventType event_type,
                                 NetLog::EventParameters* params) const;
   void BeginEventWithString(NetLog::EventType event_type,
                             const std::string& string) const;
+  void BeginEventWithInteger(NetLog::EventType event_type, int integer) const;
   void AddEventWithInteger(NetLog::EventType event_type, int integer) const;
   void EndEvent(NetLog::EventType event_type) const;
   void EndEventWithParameters(NetLog::EventType event_type,
                               NetLog::EventParameters* params) const;
   void EndEventWithInteger(NetLog::EventType event_type, int integer) const;
 
   // Deprecated: Don't add new dependencies that use these methods. Instead, use
   // AddEventWithParameters().
   void AddString(const std::string& string) const;
   void AddStringLiteral(const char* literal) const;
@@ skipping 91 matching lines @@
   // messages.
   explicit CapturingNetLog(size_t max_num_entries)
       : next_id_(0), max_num_entries_(max_num_entries) {}
 
   // NetLog implementation:
   virtual void AddEntry(EventType type,
                         const base::TimeTicks& time,
                         const Source& source,
                         EventPhase phase,
                         EventParameters* extra_parameters);
-  virtual int NextID();
+  virtual uint32 NextID();
   virtual bool HasListener() const { return true; }
 
   // Returns the list of all entries in the log.
   const EntryList& entries() const { return entries_; }
 
   void Clear();
 
  private:
-  int next_id_;
+  uint32 next_id_;
   size_t max_num_entries_;
   EntryList entries_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingNetLog);
 };
 
 // Helper class that exposes a similar API as BoundNetLog, but uses a
 // CapturingNetLog rather than the more generic NetLog.
 //
 // CapturingBoundNetLog can easily be converted to a BoundNetLog using the
@@ skipping 26 matching lines @@
  private:
   NetLog::Source source_;
   scoped_ptr<CapturingNetLog> capturing_net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingBoundNetLog);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_LOG_H_