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

net/proxy/proxy_service.h

 // Copyright (c) 2009 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_PROXY_PROXY_SERVICE_H_
 #define NET_PROXY_PROXY_SERVICE_H_
 
 #include <string>
 #include <vector>
 
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/waitable_event.h"
 #include "net/base/completion_callback.h"
 #include "net/base/network_change_notifier.h"
+#include "net/base/net_log.h"
 #include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_info.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
 class GURL;
 class MessageLoop;
 class URLRequestContext;
 
 namespace net {
 
 class InitProxyResolver;
-class LoadLog;
 class ProxyConfigService;
 class ProxyResolver;
 class ProxyScriptFetcher;
 
 // This class can be used to resolve the proxy server to use when loading a
 // HTTP(S) URL.  It uses the given ProxyResolver to handle the actual proxy
 // resolution.  See ProxyResolverV8 for example.
 class ProxyService : public base::RefCountedThreadSafe<ProxyService>,
                      public NetworkChangeNotifier::Observer {
  public:
@@ skipping 19 matching lines @@
   // callback is still pending. NULL can be passed for |pac_request| if
   // the caller will not need to cancel the request.
   //
   // We use the three possible proxy access types in the following order,
   // doing fallback if one doesn't work.  See "init_proxy_resolver.h"
   // for the specifics.
   //   1.  WPAD auto-detection
   //   2.  PAC URL
   //   3.  named proxy
   //
-  // Profiling information for the request is saved to |load_log| if non-NULL.
+  // Profiling information for the request is saved to |net_log| if non-NULL.
   int ResolveProxy(const GURL& url,
                    ProxyInfo* results,
                    CompletionCallback* callback,
                    PacRequest** pac_request,
-                   LoadLog* load_log);
+                   const BoundNetLog& net_log);
 
   // This method is called after a failure to connect or resolve a host name.
   // It gives the proxy service an opportunity to reconsider the proxy to use.
   // The |results| parameter contains the results returned by an earlier call
   // to ResolveProxy.  The semantics of this call are otherwise similar to
   // ResolveProxy.
   //
   // NULL can be passed for |pac_request| if the caller will not need to
   // cancel the request.
   //
   // Returns ERR_FAILED if there is not another proxy config to try.
   //
-  // Profiling information for the request is saved to |load_log| if non-NULL.
+  // Profiling information for the request is saved to |net_log| if non-NULL.
   int ReconsiderProxyAfterError(const GURL& url,
                                 ProxyInfo* results,
                                 CompletionCallback* callback,
                                 PacRequest** pac_request,
-                                LoadLog* load_log);
+                                const BoundNetLog& net_log);
 
   // Call this method with a non-null |pac_request| to cancel the PAC request.
   void CancelPacRequest(PacRequest* pac_request);
 
   // Sets the ProxyScriptFetcher dependency. This is needed if the ProxyResolver
   // is of type ProxyResolverWithoutFetch. ProxyService takes ownership of
   // |proxy_script_fetcher|.
   void SetProxyScriptFetcher(ProxyScriptFetcher* proxy_script_fetcher);
   ProxyScriptFetcher* GetProxyScriptFetcher() const;
 
   // Tells this ProxyService to start using a new ProxyConfigService to
   // retrieve its ProxyConfig from. The new ProxyConfigService will immediately
   // be queried for new config info which will be used for all subsequent
   // ResolveProxy calls. ProxyService takes ownership of
   // |new_proxy_config_service|.
   void ResetConfigService(ProxyConfigService* new_proxy_config_service);
 
   // Tells the resolver to purge any memory it does not need.
   void PurgeMemory();
 
   // Returns the log for the most recent WPAD + PAC initialization.
   // (This shows how much time was spent downloading and parsing the
   // PAC scripts for the current configuration).
-  LoadLog* init_proxy_resolver_log() const {
+  const CapturingBoundNetLog& init_proxy_resolver_log() const {
     return init_proxy_resolver_log_;
   }
 
   // Returns true if we have called UpdateConfig() at least once.
   bool config_has_been_initialized() const {
     return config_.id() != ProxyConfig::INVALID_ID;
   }
 
   // Returns the last configuration fetched from ProxyConfigService.
   const ProxyConfig& config() {
@@ skipping 67 matching lines @@
 
   // Creates a proxy resolver appropriate for this platform that doesn't rely
   // on V8.
   static ProxyResolver* CreateNonV8ProxyResolver();
 
   // Identifies the proxy configuration.
   ProxyConfig::ID config_id() const { return config_.id(); }
 
   // Checks to see if the proxy configuration changed, and then updates config_
   // to reference the new configuration.
-  void UpdateConfig(LoadLog* load_log);
+  void UpdateConfig(const BoundNetLog& net_log);
 
   // Assign |config| as the current configuration.
   void SetConfig(const ProxyConfig& config);
 
   // Starts downloading and testing the various PAC choices.
   // Calls OnInitProxyResolverComplete() when completed.
   void StartInitProxyResolver();
 
   // Tries to update the configuration if it hasn't been checked in a while.
-  void UpdateConfigIfOld(LoadLog* load_log);
+  void UpdateConfigIfOld(const BoundNetLog& net_log);
 
   // Returns true if the proxy resolver is being initialized for PAC
   // (downloading PAC script(s) + testing).
   // Resolve requests will be frozen until the initialization has completed.
   bool IsInitializingProxyResolver() const {
     return init_proxy_resolver_.get() != NULL;
   }
 
   // Callback for when the proxy resolver has been initialized with a
   // PAC script.
@@ skipping 15 matching lines @@
   bool ContainsPendingRequest(PacRequest* req);
 
   // Removes |req| from the list of pending requests.
   void RemovePendingRequest(PacRequest* req);
 
   // Called when proxy resolution has completed (either synchronously or
   // asynchronously). Handles logging the result, and cleaning out
   // bad entries from the results list.
   int DidFinishResolvingProxy(ProxyInfo* result,
                               int result_code,
-                              LoadLog* load_log);
+                              const BoundNetLog& net_log);
 
   // NetworkChangeNotifier::Observer methods:
   virtual void OnIPAddressChanged();
 
   scoped_ptr<ProxyConfigService> config_service_;
   scoped_ptr<ProxyResolver> resolver_;
 
   // We store the proxy config and a counter (ID) that is incremented each time
   // the config changes.
   ProxyConfig config_;
@@ skipping 21 matching lines @@
   // Callback for when |init_proxy_resolver_| is done.
   CompletionCallbackImpl<ProxyService> init_proxy_resolver_callback_;
 
   // Helper to download the PAC script (wpad + custom) and apply fallback rules.
   //
   // Note that the declaration is important here: |proxy_script_fetcher_| and
   // |proxy_resolver_| must outlive |init_proxy_resolver_|.
   scoped_ptr<InitProxyResolver> init_proxy_resolver_;
 
   // Log from the *last* time |init_proxy_resolver_.Init()| was called, or NULL.
-  scoped_refptr<LoadLog> init_proxy_resolver_log_;
+  CapturingBoundNetLog init_proxy_resolver_log_;
 
   // The (possibly NULL) network change notifier that we use to decide when
   // to refetch PAC scripts or re-run WPAD.
   NetworkChangeNotifier* const network_change_notifier_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyService);
 };
 
 // Wrapper for invoking methods on a ProxyService synchronously.
 class SyncProxyServiceHelper
     : public base::RefCountedThreadSafe<SyncProxyServiceHelper> {
  public:
   SyncProxyServiceHelper(MessageLoop* io_message_loop,
                          ProxyService* proxy_service);
 
-  int ResolveProxy(const GURL& url, ProxyInfo* proxy_info, LoadLog* load_log);
+  int ResolveProxy(const GURL& url, ProxyInfo* proxy_info, const BoundNetLog& net_log);
   int ReconsiderProxyAfterError(const GURL& url,
-                                ProxyInfo* proxy_info, LoadLog* load_log);
+                                ProxyInfo* proxy_info, const BoundNetLog& net_log);
 
  private:
   friend class base::RefCountedThreadSafe<SyncProxyServiceHelper>;
 
   ~SyncProxyServiceHelper() {}
 
-  void StartAsyncResolve(const GURL& url, LoadLog* load_log);
-  void StartAsyncReconsider(const GURL& url, LoadLog* load_log);
+  void StartAsyncResolve(const GURL& url, const BoundNetLog& net_log);
+  void StartAsyncReconsider(const GURL& url, const BoundNetLog& net_log);
 
   void OnCompletion(int result);
 
   MessageLoop* io_message_loop_;
   ProxyService* proxy_service_;
 
   base::WaitableEvent event_;
   CompletionCallbackImpl<SyncProxyServiceHelper> callback_;
   ProxyInfo proxy_info_;
   int result_;
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_PROXY_SERVICE_H_