Generalize the net module's LoadLog facility from a passive container, to an event stream (NetLog).

net/base/host_resolver_impl.h

 // Copyright (c) 2006-2008 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_HOST_RESOLVER_IMPL_H_
 #define NET_BASE_HOST_RESOLVER_IMPL_H_
 
 #include <string>
 #include <vector>
 
 #include "base/scoped_ptr.h"
 #include "net/base/host_cache.h"
 #include "net/base/host_resolver.h"
 #include "net/base/host_resolver_proc.h"
+#include "net/base/net_log.h"
 #include "net/base/network_change_notifier.h"
 
 namespace net {
 
 // For each hostname that is requested, HostResolver creates a
 // HostResolverImpl::Job. This job gets dispatched to a thread in the global
 // WorkerPool, where it runs SystemHostResolverProc(). If requests for that same
 // host are made while the job is already outstanding, then they are attached
 // to the existing job rather than creating a new one. This avoids doing
 // parallel resolves for the same host.
@@ skipping 51 matching lines @@
   HostResolverImpl(HostResolverProc* resolver_proc,
                    HostCache* cache,
                    NetworkChangeNotifier* notifier,
                    size_t max_jobs);
 
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
                       CompletionCallback* callback,
                       RequestHandle* out_req,
-                      LoadLog* load_log);
+                      const BoundNetLog& net_log);
   virtual void CancelRequest(RequestHandle req);
   virtual void AddObserver(HostResolver::Observer* observer);
   virtual void RemoveObserver(HostResolver::Observer* observer);
 
   virtual void SetDefaultAddressFamily(AddressFamily address_family) {
     default_address_family_ = address_family;
   }
 
   virtual HostResolverImpl* GetAsHostResolverImpl() { return this; }
 
   // TODO(eroman): hack for http://crbug.com/15513
   void Shutdown();
 
   // Returns the cache this resolver uses, or NULL if caching is disabled.
   HostCache* cache() { return cache_.get(); }
 
   // Clears the request trace log.
   void ClearRequestsTrace();
 
   // Starts/ends capturing requests to a trace log.
   void EnableRequestsTracing(bool enable);
 
   bool IsRequestsTracingEnabled() const;
 
-  // Returns a copy of the requests trace log, or NULL if there is none.
-  scoped_refptr<LoadLog> GetRequestsTrace();
+  // Gets a copy of the requests trace log.
+  bool GetRequestsTrace(std::vector<NetLog::Entry>* entries);
 
   // Applies a set of constraints for requests that belong to the specified
   // pool. NOTE: Don't call this after requests have been already been started.
   //
   //  |pool_index| -- Specifies which pool these constraints should be applied
   //                  to.
   //  |max_outstanding_jobs| -- How many concurrent jobs are allowed for this
   //                            pool.
   //  |max_pending_requests| -- How many requests can be enqueued for this pool
   //                            before we start dropping requests. Dropped
@@ skipping 30 matching lines @@
   // Returns the outstanding job for |key|, or NULL if there is none.
   Job* FindOutstandingJob(const Key& key);
 
   // Removes |job| from the outstanding jobs list.
   void RemoveOutstandingJob(Job* job);
 
   // Callback for when |job| has completed with |error| and |addrlist|.
   void OnJobComplete(Job* job, int error, const AddressList& addrlist);
 
   // Called when a request has just been started.
-  void OnStartRequest(LoadLog* load_log,
+  void OnStartRequest(const BoundNetLog& net_log,
                       int request_id,
                       const RequestInfo& info);
 
   // Called when a request has just completed (before its callback is run).
-  void OnFinishRequest(LoadLog* load_log,
+  void OnFinishRequest(const BoundNetLog& net_log,
                        int request_id,
                        const RequestInfo& info,
                        int error);
 
   // Called when a request has been cancelled.
-  void OnCancelRequest(LoadLog* load_log,
+  void OnCancelRequest(const BoundNetLog& net_log,
                        int request_id,
                        const RequestInfo& info);
 
   // NetworkChangeNotifier::Observer methods:
   virtual void OnIPAddressChanged();
 
   // Returns true if the constraints for |pool| are met, and a new job can be
   // created for this pool.
   bool CanCreateJobForPool(const JobPool& pool) const;
 
@@ skipping 60 matching lines @@
   NetworkChangeNotifier* const network_change_notifier_;
 
   scoped_refptr<RequestsTrace> requests_trace_;
 
   DISALLOW_COPY_AND_ASSIGN(HostResolverImpl);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_HOST_RESOLVER_IMPL_H_