net: rename BoundNetLog to NetLogWithSource

net/quic/chromium/quic_stream_factory.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.
 
 #ifndef NET_QUIC_QUIC_STREAM_FACTORY_H_
 #define NET_QUIC_QUIC_STREAM_FACTORY_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 91 matching lines @@
 
   // |cert_verify_flags| is bitwise OR'd of CertVerifier::VerifyFlags and it is
   // passed to CertVerifier::Verify.
   // |destination| will be resolved and resulting IPEndPoint used to open a
   // QuicConnection.  This can be different than HostPortPair::FromURL(url).
   int Request(const HostPortPair& destination,
               PrivacyMode privacy_mode,
               int cert_verify_flags,
               const GURL& url,
               base::StringPiece method,
-              const BoundNetLog& net_log,
+              const NetLogWithSource& net_log,
               const CompletionCallback& callback);
 
   void OnRequestComplete(int rv);
 
   // Helper method that calls |factory_|'s GetTimeDelayForWaitingJob(). It
   // returns the amount of time waiting job should be delayed.
   base::TimeDelta GetTimeDelayForWaitingJob() const;
 
   std::unique_ptr<QuicHttpStream> CreateStream();
 
   std::unique_ptr<BidirectionalStreamImpl> CreateBidirectionalStreamImpl();
 
   // Sets |session_|.
   void SetSession(QuicChromiumClientSession* session);
 
   const QuicServerId& server_id() const { return server_id_; }
 
-  const BoundNetLog& net_log() const { return net_log_; }
+  const NetLogWithSource& net_log() const { return net_log_; }
 
  private:
   QuicStreamFactory* factory_;
   QuicServerId server_id_;
-  BoundNetLog net_log_;
+  NetLogWithSource net_log_;
   CompletionCallback callback_;
   base::WeakPtr<QuicChromiumClientSession> session_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamRequest);
 };
 
 // A factory for creating new QuicHttpStreams on top of a pool of
 // QuicChromiumClientSessions.
 class NET_EXPORT_PRIVATE QuicStreamFactory
     : public NetworkChangeNotifier::IPAddressObserver,
@@ skipping 79 matching lines @@
   // Creates a new QuicHttpStream to |host_port_pair| which will be
   // owned by |request|.
   // If a matching session already exists, this method will return OK.  If no
   // matching session exists, this will return ERR_IO_PENDING and will invoke
   // OnRequestComplete asynchronously.
   int Create(const QuicServerId& server_id,
              const HostPortPair& destination,
              int cert_verify_flags,
              const GURL& url,
              base::StringPiece method,
-             const BoundNetLog& net_log,
+             const NetLogWithSource& net_log,
              QuicStreamRequest* request);
 
   // Called when the handshake for |session| is confirmed. If QUIC is disabled
   // currently disabled, then it closes the connection and returns true.
   bool OnHandshakeConfirmed(QuicChromiumClientSession* session);
 
   // Called when a TCP job completes for an origin that QUIC potentially
   // could be used for.
   void OnTcpJobCompleted(bool succeeded);
 
@@ skipping 46 matching lines @@
   // are left unchanged. Sessions with non-migratable streams are closed
   // if |close_if_cannot_migrate| is true, and continue using their current
   // network otherwise.
   //
   // If |new_network| is NetworkChangeNotifier::kInvalidNetworkHandle,
   // there is no new network to migrate sessions onto, and all sessions are
   // closed.
   void MaybeMigrateOrCloseSessions(
       NetworkChangeNotifier::NetworkHandle new_network,
       bool close_if_cannot_migrate,
-      const BoundNetLog& bound_net_log);
+      const NetLogWithSource& net_log);
 
   // Method that initiates migration of |session| if |session| is
   // active and if there is an alternate network than the one to which
   // |session| is currently bound.
   MigrationResult MaybeMigrateSingleSession(QuicChromiumClientSession* session,
                                             MigrationCause migration_cause);
 
   // Migrates |session| over to using |network|. If |network| is
   // kInvalidNetworkHandle, default network is used.
   MigrationResult MigrateSessionToNewNetwork(
       QuicChromiumClientSession* session,
       NetworkChangeNotifier::NetworkHandle network,
       bool close_session_on_error,
-      const BoundNetLog& bound_net_log);
+      const NetLogWithSource& net_log);
 
   // Migrates |session| over to using |peer_address|. Causes a PING frame
   // to be sent to the new peer address.
   void MigrateSessionToNewPeerAddress(QuicChromiumClientSession* session,
                                       IPEndPoint peer_address,
-                                      const BoundNetLog& bound_net_log);
+                                      const NetLogWithSource& net_log);
 
   // NetworkChangeNotifier::IPAddressObserver methods:
 
   // Until the servers support roaming, close all connections when the local
   // IP address changes.
   void OnIPAddressChanged() override;
 
   // NetworkChangeNotifier::NetworkObserver methods:
   void OnNetworkConnected(
       NetworkChangeNotifier::NetworkHandle network) override;
@@ skipping 73 matching lines @@
   enum FactoryStatus {
     OPEN,     // New streams may be created.
     CLOSED,   // No new streams may be created temporarily.
     DISABLED  // No more streams may be created until the network changes.
   };
 
   // Creates a job which doesn't wait for server config to be loaded from the
   // disk cache. This job is started via a PostTask.
   void CreateAuxilaryJob(const QuicSessionKey& key,
                          int cert_verify_flags,
-                         const BoundNetLog& net_log);
+                         const NetLogWithSource& net_log);
 
   // Returns a newly created QuicHttpStream owned by the caller.
   std::unique_ptr<QuicHttpStream> CreateFromSession(
       QuicChromiumClientSession* session);
 
   bool OnResolution(const QuicSessionKey& key, const AddressList& address_list);
   void OnJobComplete(Job* job, int rv);
   void OnCertVerifyJobComplete(CertVerifierJob* job, int rv);
   bool HasActiveSession(const QuicServerId& server_id) const;
   bool HasActiveJob(const QuicServerId& server_id) const;
   bool HasActiveCertVerifierJob(const QuicServerId& server_id) const;
   int CreateSession(const QuicSessionKey& key,
                     int cert_verify_flags,
                     std::unique_ptr<QuicServerInfo> quic_server_info,
                     const AddressList& address_list,
                     base::TimeTicks dns_resolution_start_time,
                     base::TimeTicks dns_resolution_end_time,
-                    const BoundNetLog& net_log,
+                    const NetLogWithSource& net_log,
                     QuicChromiumClientSession** session);
   void ActivateSession(const QuicSessionKey& key,
                        QuicChromiumClientSession* session);
 
   // Returns |srtt| in micro seconds from ServerNetworkStats. Returns 0 if there
   // is no |http_server_properties_| or if |http_server_properties_| doesn't
   // have ServerNetworkStats for the given |server_id|.
   int64_t GetServerNetworkStatsSmoothedRttInMicroseconds(
       const QuicServerId& server_id) const;
 
   // Helper methods.
   bool WasQuicRecentlyBroken(const QuicServerId& server_id) const;
 
   bool CryptoConfigCacheIsEmpty(const QuicServerId& server_id);
 
   // Starts an asynchronous job for cert verification if
   // |race_cert_verification_| is enabled and if there are cached certs for the
   // given |server_id|.
   QuicAsyncStatus StartCertVerifyJob(const QuicServerId& server_id,
                                      int cert_verify_flags,
-                                     const BoundNetLog& net_log);
+                                     const NetLogWithSource& net_log);
 
   // Initializes the cached state associated with |server_id| in
   // |crypto_config_| with the information in |server_info|. Populates
   // |connection_id| with the next server designated connection id,
   // if any, and otherwise leaves it unchanged.
   void InitializeCachedStateInCryptoConfig(
       const QuicServerId& server_id,
       const std::unique_ptr<QuicServerInfo>& server_info,
       QuicConnectionId* connection_id);
 
   // Initialize |quic_supported_servers_at_startup_| with the list of servers
   // that supported QUIC at start up and also initialize in-memory cache of
   // QuicServerInfo objects from HttpServerProperties.
   void MaybeInitialize();
 
   void ProcessGoingAwaySession(QuicChromiumClientSession* session,
                                const QuicServerId& server_id,
                                bool was_session_active);
 
   // Internal method that migrates |session| over to using
   // |peer_address| and |network|. If |network| is
   // kInvalidNetworkHandle, default network is used. If the migration
   // fails and |close_session_on_error| is true, connection is closed.
   MigrationResult MigrateSessionInner(
       QuicChromiumClientSession* session,
       IPEndPoint peer_address,
       NetworkChangeNotifier::NetworkHandle network,
       bool close_session_on_error,
-      const BoundNetLog& bound_net_log);
+      const NetLogWithSource& net_log);
 
   // Called to re-enable QUIC when QUIC has been disabled.
   void OpenFactory();
   // If QUIC has been working well after having been recently
   // disabled, clear the |consecutive_disabled_count_|.
   void MaybeClearConsecutiveDisabledCount();
 
   bool require_confirmation_;
   NetLog* net_log_;
   HostResolver* host_resolver_;
@@ skipping 152 matching lines @@
   const scoped_refptr<SSLConfigService> ssl_config_service_;
 
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_STREAM_FACTORY_H_