Add a "LoadLog*" parameter to transactions, hostresolver, clientsocketpool.

net/base/host_resolver.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_H_
 #define NET_BASE_HOST_RESOLVER_H_
 
 #include <string>
 
 #include "base/ref_counted.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/completion_callback.h"
 
 class MessageLoop;
 
 namespace net {
 
 class AddressList;
+class LoadLog;
 
 // This class represents the task of resolving hostnames (or IP address
 // literal) to an AddressList object.
 //
 // HostResolver can handle multiple requests at a time, so when cancelling a
 // request the RequestHandle that was returned by Resolve() needs to be
 // given.  A simpler alternative for consumers that only have 1 outstanding
 // request at a time is to create a SingleRequestHostResolver wrapper around
 // HostResolver (which will automatically cancel the single request when it
 // goes out of scope).
@@ skipping 75 matching lines @@
   // the sin(6)_port field of the sockaddr_in{6} struct.  Returns OK if
   // successful or an error code upon failure.
   //
   // When callback is null, the operation completes synchronously.
   //
   // When callback is non-null, the operation will be performed asynchronously.
   // ERR_IO_PENDING is returned if it has been scheduled successfully. Real
   // result code will be passed to the completion callback. If |req| is
   // non-NULL, then |*req| will be filled with a handle to the async request.
   // This handle is not valid after the request has completed.
-  virtual int Resolve(const RequestInfo& info, AddressList* addresses,
-                      CompletionCallback* callback, RequestHandle* out_req) = 0;
+  //
+  // Profiling information for the request is saved to |load_log| if non-NULL.
+  virtual int Resolve(LoadLog* load_log,
+                      const RequestInfo& info,
+                      AddressList* addresses,
+                      CompletionCallback* callback,
+                      RequestHandle* out_req) = 0;
 
   // Cancels the specified request. |req| is the handle returned by Resolve().
   // After a request is cancelled, its completion callback will not be called.
   virtual void CancelRequest(RequestHandle req) = 0;
 
   // Adds an observer to this resolver. The observer will be notified of the
   // start and completion of all requests (excluding cancellation). |observer|
   // must remain valid for the duration of this HostResolver's lifetime.
   virtual void AddObserver(Observer* observer) = 0;
 
@@ skipping 13 matching lines @@
  public:
   explicit SingleRequestHostResolver(HostResolver* resolver);
 
   // If a completion callback is pending when the resolver is destroyed, the
   // host resolution is cancelled, and the completion callback will not be
   // called.
   ~SingleRequestHostResolver();
 
   // Resolves the given hostname (or IP address literal), filling out the
   // |addresses| object upon success. See HostResolver::Resolve() for details.
-  int Resolve(const HostResolver::RequestInfo& info,
-              AddressList* addresses, CompletionCallback* callback);
+  int Resolve(LoadLog* load_log,
+              const HostResolver::RequestInfo& info,
+              AddressList* addresses,
+              CompletionCallback* callback);
 
  private:
   // Callback for when the request to |resolver_| completes, so we dispatch
   // to the user's callback.
   void OnResolveCompletion(int result);
 
   // The actual host resolver that will handle the request.
   scoped_refptr<HostResolver> resolver_;
 
   // The current request (if any).
   HostResolver::RequestHandle cur_request_;
   CompletionCallback* cur_request_callback_;
 
   // Completion callback for when request to |resolver_| completes.
   net::CompletionCallbackImpl<SingleRequestHostResolver> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SingleRequestHostResolver);
 };
 
 // Creates a HostResolver implementation that queries the underlying system.
 // (Except if a unit-test has changed the global HostResolverProc using
 // ScopedHostResolverProc to intercept requests to the system).
 HostResolver* CreateSystemHostResolver();
 
 }  // namespace net
 
 #endif  // NET_BASE_HOST_RESOLVER_H_