Add support for attaching custom parameters to NetLog events.

chrome/browser/net/passive_log_collector.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 CHROME_BROWSER_NET_PASSIVE_LOG_COLLECTOR_H_
 #define CHROME_BROWSER_NET_PASSIVE_LOG_COLLECTOR_H_
 
 #include <vector>
 
 #include "base/hash_tables.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "net/base/net_log.h"
 
 class PassiveLogCollector : public ChromeNetLog::Observer {
  public:
   struct RequestInfo {
     RequestInfo() : num_entries_truncated(0) {}
     std::string url;
-    std::vector<net::NetLog::Entry> entries;
+    net::CapturingNetLog::EntryList entries;
     size_t num_entries_truncated;
   };
 
   typedef std::vector<RequestInfo> RequestInfoList;
 
   // This class stores and manages the passively logged information for
   // URLRequests/SocketStreams/ConnectJobs.
   class RequestTrackerBase {
    public:
     explicit RequestTrackerBase(size_t max_graveyard_size);
 
-    void OnAddEntry(const net::NetLog::Entry& entry);
+    void OnAddEntry(const net::CapturingNetLog::Entry& entry);
 
     RequestInfoList GetLiveRequests() const;
     void ClearRecentlyDeceased();
     RequestInfoList GetRecentlyDeceased() const;
     void SetUnbounded(bool unbounded);
 
     bool IsUnbounded() const { return is_unbounded_; }
 
     void Clear();
 
     const RequestInfo* GetRequestInfoFromGraveyard(int id) const;
 
    protected:
     enum Action {
       ACTION_NONE,
       ACTION_DELETE,
       ACTION_MOVE_TO_GRAVEYARD,
     };
 
     // Updates |out_info| with the information from |entry|. Returns an action
     // to perform for this map entry on completion.
-    virtual Action DoAddEntry(const net::NetLog::Entry& entry,
+    virtual Action DoAddEntry(const net::CapturingNetLog::Entry& entry,
                               RequestInfo* out_info) = 0;
 
     bool is_unbounded() const { return is_unbounded_; }
 
    private:
     typedef base::hash_map<int, RequestInfo> SourceIDToInfoMap;
 
-    bool HandleNotificationOfConnectJobID(const net::NetLog::Entry& entry,
-                                          RequestInfo* live_entry);
-
     void RemoveFromLiveRequests(int source_id);
     void InsertIntoGraveyard(const RequestInfo& info);
 
     SourceIDToInfoMap live_requests_;
     size_t max_graveyard_size_;
     size_t next_graveyard_index_;
     RequestInfoList graveyard_;
     bool is_unbounded_;
 
     DISALLOW_COPY_AND_ASSIGN(RequestTrackerBase);
   };
 
   // Specialization of RequestTrackerBase for handling ConnectJobs.
   class ConnectJobTracker : public RequestTrackerBase {
    public:
     static const size_t kMaxGraveyardSize;
 
     ConnectJobTracker();
 
    protected:
-    virtual Action DoAddEntry(const net::NetLog::Entry& entry,
+    virtual Action DoAddEntry(const net::CapturingNetLog::Entry& entry,
                               RequestInfo* out_info);
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobTracker);
   };
 
   // Specialization of RequestTrackerBase for handling URLRequest/SocketStream.
   class RequestTracker : public RequestTrackerBase {
    public:
     static const size_t kMaxGraveyardSize;
     static const size_t kMaxGraveyardURLSize;
 
     explicit RequestTracker(ConnectJobTracker* connect_job_tracker);
 
    protected:
-    virtual Action DoAddEntry(const net::NetLog::Entry& entry,
+    virtual Action DoAddEntry(const net::CapturingNetLog::Entry& entry,
                               RequestInfo* out_info);
 
    private:
     // Searches through |connect_job_tracker_| for information on the
     // ConnectJob specified in |entry|, and appends it to |live_entry|.
-    void AddConnectJobInfo(const net::NetLog::Entry& entry,
+    void AddConnectJobInfo(const net::CapturingNetLog::Entry& entry,
                            RequestInfo* live_entry);
 
     ConnectJobTracker* connect_job_tracker_;
 
     DISALLOW_COPY_AND_ASSIGN(RequestTracker);
   };
 
   // Tracks the log entries for the last seen SOURCE_INIT_PROXY_RESOLVER.
   class InitProxyResolverTracker {
    public:
     InitProxyResolverTracker();
 
-    void OnAddEntry(const net::NetLog::Entry& entry);
+    void OnAddEntry(const net::CapturingNetLog::Entry& entry);
 
-    const std::vector<net::NetLog::Entry>& entries() const {
+    const net::CapturingNetLog::EntryList& entries() const {
       return entries_;
     }
 
    private:
-    std::vector<net::NetLog::Entry> entries_;
+    net::CapturingNetLog::EntryList entries_;
     DISALLOW_COPY_AND_ASSIGN(InitProxyResolverTracker);
   };
 
   PassiveLogCollector();
   ~PassiveLogCollector();
 
   // Observer implementation:
-  virtual void OnAddEntry(const net::NetLog::Entry& entry);
+  virtual void OnAddEntry(net::NetLog::EventType type,
+                          const base::TimeTicks& time,
+                          const net::NetLog::Source& source,
+                          net::NetLog::EventPhase phase,
+                          net::NetLog::EventParameters* extra_parameters);
 
   // Clears all of the passively logged data.
   void Clear();
 
   RequestTracker* url_request_tracker() {
     return &url_request_tracker_;
   }
 
   RequestTracker* socket_stream_tracker() {
     return &socket_stream_tracker_;
   }
 
   InitProxyResolverTracker* init_proxy_resolver_tracker() {
     return &init_proxy_resolver_tracker_;
   }
 
  private:
   ConnectJobTracker connect_job_tracker_;
   RequestTracker url_request_tracker_;
   RequestTracker socket_stream_tracker_;
   InitProxyResolverTracker init_proxy_resolver_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(PassiveLogCollector);
 };
 
 #endif  // CHROME_BROWSER_NET_PASSIVE_LOG_COLLECTOR_H_