net: rename BoundNetLog to NetLogWithSource

net/socket/client_socket_pool_base.h

 // Copyright (c) 2012 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.
 //
 // A ClientSocketPoolBase is used to restrict the number of sockets open at
 // a time.  It also maintains a list of idle persistent sockets for reuse.
 // Subclasses of ClientSocketPool should compose ClientSocketPoolBase to handle
 // the core logic of (1) restricting the number of active (connected or
 // connecting) sockets per "group" (generally speaking, the hostname), (2)
 // maintaining a per-group list of idle, persistent sockets for reuse, and (3)
@@ skipping 66 matching lines @@
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // A |timeout_duration| of 0 corresponds to no timeout.
   ConnectJob(const std::string& group_name,
              base::TimeDelta timeout_duration,
              RequestPriority priority,
              ClientSocketPool::RespectLimits respect_limits,
              Delegate* delegate,
-             const BoundNetLog& net_log);
+             const NetLogWithSource& net_log);
   virtual ~ConnectJob();
 
   // Accessors
   const std::string& group_name() const { return group_name_; }
-  const BoundNetLog& net_log() { return net_log_; }
+  const NetLogWithSource& net_log() { return net_log_; }
 
   // Releases ownership of the underlying socket to the caller.
   // Returns the released socket, or NULL if there was a connection
   // error.
   std::unique_ptr<StreamSocket> PassSocket();
 
   // Begins connecting the socket.  Returns OK on success, ERR_IO_PENDING if it
   // cannot complete synchronously without blocking, or another net error code
   // on error.  In asynchronous completion, the ConnectJob will notify
   // |delegate_| via OnConnectJobComplete.  In both asynchronous and synchronous
   // completion, ReleaseSocket() can be called to acquire the connected socket
   // if it succeeded.
   int Connect();
 
   virtual LoadState GetLoadState() const = 0;
 
   // If Connect returns an error (or OnConnectJobComplete reports an error
   // result) this method will be called, allowing the pool to add
   // additional error state to the ClientSocketHandle (post late-binding).
   virtual void GetAdditionalErrorState(ClientSocketHandle* handle) {}
 
   const LoadTimingInfo::ConnectTiming& connect_timing() const {
     return connect_timing_;
   }
 
-  const BoundNetLog& net_log() const { return net_log_; }
+  const NetLogWithSource& net_log() const { return net_log_; }
 
  protected:
   RequestPriority priority() const { return priority_; }
   ClientSocketPool::RespectLimits respect_limits() const {
     return respect_limits_;
   }
   void SetSocket(std::unique_ptr<StreamSocket> socket);
   StreamSocket* socket() { return socket_.get(); }
   void NotifyDelegateOfCompletion(int rv);
   void ResetTimer(base::TimeDelta remainingTime);
@@ skipping 12 matching lines @@
 
   const std::string group_name_;
   const base::TimeDelta timeout_duration_;
   // TODO(akalin): Support reprioritization.
   const RequestPriority priority_;
   const ClientSocketPool::RespectLimits respect_limits_;
   // Timer to abort jobs that take too long.
   base::OneShotTimer timer_;
   Delegate* delegate_;
   std::unique_ptr<StreamSocket> socket_;
-  BoundNetLog net_log_;
+  NetLogWithSource net_log_;
   // A ConnectJob is idle until Connect() has been called.
   bool idle_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectJob);
 };
 
 namespace internal {
 
 // ClientSocketPoolBaseHelper is an internal class that implements almost all
 // the functionality from ClientSocketPoolBase without using templates.
@@ skipping 12 matching lines @@
     NO_IDLE_SOCKETS = 0x1,  // Do not return an idle socket. Create a new one.
   };
 
   class NET_EXPORT_PRIVATE Request {
    public:
     Request(ClientSocketHandle* handle,
             const CompletionCallback& callback,
             RequestPriority priority,
             ClientSocketPool::RespectLimits respect_limits,
             Flags flags,
-            const BoundNetLog& net_log);
+            const NetLogWithSource& net_log);
 
     virtual ~Request();
 
     ClientSocketHandle* handle() const { return handle_; }
     const CompletionCallback& callback() const { return callback_; }
     RequestPriority priority() const { return priority_; }
     ClientSocketPool::RespectLimits respect_limits() const {
       return respect_limits_;
     }
     Flags flags() const { return flags_; }
-    const BoundNetLog& net_log() const { return net_log_; }
+    const NetLogWithSource& net_log() const { return net_log_; }
 
     // TODO(eroman): Temporary until crbug.com/467797 is solved.
     void CrashIfInvalid() const;
 
    private:
     // TODO(eroman): Temporary until crbug.com/467797 is solved.
     enum Liveness {
       ALIVE = 0xCA11AB13,
       DEAD = 0xDEADBEEF,
     };
 
     ClientSocketHandle* const handle_;
     const CompletionCallback callback_;
     // TODO(akalin): Support reprioritization.
     const RequestPriority priority_;
     const ClientSocketPool::RespectLimits respect_limits_;
     const Flags flags_;
-    const BoundNetLog net_log_;
+    const NetLogWithSource net_log_;
 
     // TODO(eroman): Temporary until crbug.com/467797 is solved.
     Liveness liveness_ = ALIVE;
 
     DISALLOW_COPY_AND_ASSIGN(Request);
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
@@ skipping 316 matching lines @@
   // Process a pending socket request for a group.
   void ProcessPendingRequest(const std::string& group_name, Group* group);
 
   // Assigns |socket| to |handle| and updates |group|'s counters appropriately.
   void HandOutSocket(std::unique_ptr<StreamSocket> socket,
                      ClientSocketHandle::SocketReuseType reuse_type,
                      const LoadTimingInfo::ConnectTiming& connect_timing,
                      ClientSocketHandle* handle,
                      base::TimeDelta time_idle,
                      Group* group,
-                     const BoundNetLog& net_log);
+                     const NetLogWithSource& net_log);
 
   // Adds |socket| to the list of idle sockets for |group|.
   void AddIdleSocket(std::unique_ptr<StreamSocket> socket, Group* group);
 
   // Iterates through |group_map_|, canceling all ConnectJobs and deleting
   // groups if they are no longer needed.
   void CancelAllConnectJobs();
 
   // Iterates through |group_map_|, posting |error| callbacks for all
   // requests, and then deleting groups if they are no longer needed.
@@ skipping 100 matching lines @@
 class ClientSocketPoolBase {
  public:
   class Request : public internal::ClientSocketPoolBaseHelper::Request {
    public:
     Request(ClientSocketHandle* handle,
             const CompletionCallback& callback,
             RequestPriority priority,
             ClientSocketPool::RespectLimits respect_limits,
             internal::ClientSocketPoolBaseHelper::Flags flags,
             const scoped_refptr<SocketParams>& params,
-            const BoundNetLog& net_log)
+            const NetLogWithSource& net_log)
         : internal::ClientSocketPoolBaseHelper::Request(handle,
                                                         callback,
                                                         priority,
                                                         respect_limits,
                                                         flags,
                                                         net_log),
           params_(params) {}
 
     const scoped_refptr<SocketParams>& params() const { return params_; }
 
@@ skipping 52 matching lines @@
   }
 
   // RequestSocket bundles up the parameters into a Request and then forwards to
   // ClientSocketPoolBaseHelper::RequestSocket().
   int RequestSocket(const std::string& group_name,
                     const scoped_refptr<SocketParams>& params,
                     RequestPriority priority,
                     ClientSocketPool::RespectLimits respect_limits,
                     ClientSocketHandle* handle,
                     const CompletionCallback& callback,
-                    const BoundNetLog& net_log) {
+                    const NetLogWithSource& net_log) {
     std::unique_ptr<const Request> request(new Request(
         handle, callback, priority, respect_limits,
         internal::ClientSocketPoolBaseHelper::NORMAL, params, net_log));
     return helper_.RequestSocket(group_name, std::move(request));
   }
 
   // RequestSockets bundles up the parameters into a Request and then forwards
   // to ClientSocketPoolBaseHelper::RequestSockets().  Note that it assigns the
   // priority to IDLE and specifies the NO_IDLE_SOCKETS flag.
   void RequestSockets(const std::string& group_name,
                       const scoped_refptr<SocketParams>& params,
                       int num_sockets,
-                      const BoundNetLog& net_log) {
+                      const NetLogWithSource& net_log) {
     const Request request(nullptr /* no handle */, CompletionCallback(), IDLE,
                           ClientSocketPool::RespectLimits::ENABLED,
                           internal::ClientSocketPoolBaseHelper::NO_IDLE_SOCKETS,
                           params, net_log);
     helper_.RequestSockets(group_name, request, num_sockets);
   }
 
   void CancelRequest(const std::string& group_name,
                      ClientSocketHandle* handle) {
     return helper_.CancelRequest(group_name, handle);
@@ skipping 97 matching lines @@
   };
 
   internal::ClientSocketPoolBaseHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_