net: rename BoundNetLog to NetLogWithSource

net/quic/chromium/quic_stream_factory.cc

 // 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.
 
 #include "net/quic/chromium/quic_stream_factory.h"
 
 #include <openssl/aead.h>
 
 #include <algorithm>
 #include <tuple>
@@ skipping 95 matching lines @@
     NetLogCaptureMode capture_mode) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("connection_id", base::Uint64ToString(connection_id));
   return std::move(dict);
 }
 
 // Helper class that is used to log a connection migration event.
 class ScopedConnectionMigrationEventLog {
  public:
   ScopedConnectionMigrationEventLog(NetLog* net_log, std::string trigger)
-      : net_log_(
-            BoundNetLog::Make(net_log,
-                              NetLogSourceType::QUIC_CONNECTION_MIGRATION)) {
+      : net_log_(NetLogWithSource::Make(
+            net_log,
+            NetLogSourceType::QUIC_CONNECTION_MIGRATION)) {
     net_log_.BeginEvent(
         NetLogEventType::QUIC_CONNECTION_MIGRATION_TRIGGERED,
         base::Bind(&NetLogQuicConnectionMigrationTriggerCallback, trigger));
   }
 
   ~ScopedConnectionMigrationEventLog() {
     net_log_.EndEvent(NetLogEventType::QUIC_CONNECTION_MIGRATION_TRIGGERED);
   }
 
-  const BoundNetLog& net_log() { return net_log_; }
+  const NetLogWithSource& net_log() { return net_log_; }
 
  private:
-  const BoundNetLog net_log_;
+  const NetLogWithSource net_log_;
 };
 
 void HistogramCreateSessionFailure(enum CreateSessionFailure error) {
   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.CreationError", error,
                             CREATION_ERROR_MAX);
 }
 
-void HistogramAndLogMigrationFailure(const BoundNetLog& net_log,
+void HistogramAndLogMigrationFailure(const NetLogWithSource& net_log,
                                      enum QuicConnectionMigrationStatus status,
                                      QuicConnectionId connection_id,
                                      std::string reason) {
   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.ConnectionMigration", status,
                             MIGRATION_STATUS_MAX);
   net_log.AddEvent(NetLogEventType::QUIC_CONNECTION_MIGRATION_FAILURE,
                    base::Bind(&NetLogQuicConnectionMigrationFailureCallback,
                               connection_id, reason));
 }
 
@@ skipping 61 matching lines @@
     }
 
     void Cancel() { job_ = nullptr; }
 
    private:
     CertVerifierJob* job_;
   };
 
   CertVerifierJob(const QuicServerId& server_id,
                   int cert_verify_flags,
-                  const BoundNetLog& net_log)
+                  const NetLogWithSource& net_log)
       : server_id_(server_id),
         verify_callback_(nullptr),
         verify_context_(base::WrapUnique(
             new ProofVerifyContextChromium(cert_verify_flags, net_log))),
         start_time_(base::TimeTicks::Now()),
         net_log_(net_log),
         weak_factory_(this) {}
 
   ~CertVerifierJob() {
     if (verify_callback_)
@@ skipping 27 matching lines @@
 
   const QuicServerId& server_id() const { return server_id_; }
 
  private:
   QuicServerId server_id_;
   ProofVerifierCallbackImpl* verify_callback_;
   std::unique_ptr<ProofVerifyContext> verify_context_;
   std::unique_ptr<ProofVerifyDetails> verify_details_;
   std::string verify_error_details_;
   base::TimeTicks start_time_;
-  const BoundNetLog net_log_;
+  const NetLogWithSource net_log_;
   CompletionCallback callback_;
   base::WeakPtrFactory<CertVerifierJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CertVerifierJob);
 };
 
 // Responsible for creating a new QUIC session to the specified server, and
 // for notifying any associated requests when complete.
 class QuicStreamFactory::Job {
  public:
   Job(QuicStreamFactory* factory,
       HostResolver* host_resolver,
       const QuicSessionKey& key,
       bool was_alternative_service_recently_broken,
       int cert_verify_flags,
       QuicServerInfo* server_info,
-      const BoundNetLog& net_log);
+      const NetLogWithSource& net_log);
 
   // Creates a new job to handle the resumption of for connecting an
   // existing session.
   Job(QuicStreamFactory* factory,
       HostResolver* host_resolver,
       QuicChromiumClientSession* session,
       const QuicSessionKey& key);
 
   ~Job();
 
@@ skipping 34 matching lines @@
   IoState io_state_;
 
   QuicStreamFactory* factory_;
   HostResolver* host_resolver_;
   std::unique_ptr<HostResolver::Request> request_;
   QuicSessionKey key_;
   int cert_verify_flags_;
   bool was_alternative_service_recently_broken_;
   std::unique_ptr<QuicServerInfo> server_info_;
   bool started_another_job_;
-  const BoundNetLog net_log_;
+  const NetLogWithSource net_log_;
   int num_sent_client_hellos_;
   QuicChromiumClientSession* session_;
   CompletionCallback callback_;
   AddressList address_list_;
   base::TimeTicks dns_resolution_start_time_;
   base::TimeTicks dns_resolution_end_time_;
   base::WeakPtrFactory<Job> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 QuicStreamFactory::Job::Job(QuicStreamFactory* factory,
                             HostResolver* host_resolver,
                             const QuicSessionKey& key,
                             bool was_alternative_service_recently_broken,
                             int cert_verify_flags,
                             QuicServerInfo* server_info,
-                            const BoundNetLog& net_log)
+                            const NetLogWithSource& net_log)
     : io_state_(STATE_RESOLVE_HOST),
       factory_(factory),
       host_resolver_(host_resolver),
       key_(key),
       cert_verify_flags_(cert_verify_flags),
       was_alternative_service_recently_broken_(
           was_alternative_service_recently_broken),
       server_info_(server_info),
       started_another_job_(false),
       net_log_(net_log),
@@ skipping 274 matching lines @@
 QuicStreamRequest::~QuicStreamRequest() {
   if (factory_ && !callback_.is_null())
     factory_->CancelRequest(this);
 }
 
 int QuicStreamRequest::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) {
   DCHECK(callback_.is_null());
   DCHECK(factory_);
   server_id_ = QuicServerId(HostPortPair::FromURL(url), privacy_mode);
 
   int rv = factory_->Create(server_id_, destination, cert_verify_flags, url,
                             method, net_log, this);
   if (rv == ERR_IO_PENDING) {
     net_log_ = net_log;
     callback_ = callback;
@@ skipping 254 matching lines @@
   }
 
   return false;
 }
 
 int QuicStreamFactory::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) {
   DCHECK(server_id.host_port_pair().Equals(HostPortPair::FromURL(url)));
   // Enforce session affinity for promised streams.
   QuicClientPromisedInfo* promised =
       push_promise_index_.GetPromised(url.spec());
   if (promised) {
     QuicChromiumClientSession* session =
         static_cast<QuicChromiumClientSession*>(promised->session());
     DCHECK(session);
     if (session->server_id().privacy_mode() == server_id.privacy_mode()) {
@@ skipping 96 matching lines @@
 }
 
 bool QuicStreamFactory::QuicSessionKey::operator==(
     const QuicSessionKey& other) const {
   return destination_.Equals(other.destination_) &&
          server_id_ == other.server_id_;
 }
 
 void QuicStreamFactory::CreateAuxilaryJob(const QuicSessionKey& key,
                                           int cert_verify_flags,
-                                          const BoundNetLog& net_log) {
+                                          const NetLogWithSource& net_log) {
   Job* aux_job =
       new Job(this, host_resolver_, key, WasQuicRecentlyBroken(key.server_id()),
               cert_verify_flags, nullptr, net_log);
   active_jobs_[key.server_id()].insert(aux_job);
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&QuicStreamFactory::Job::RunAuxilaryJob,
                                     aux_job->GetWeakPtr()));
 }
 
 bool QuicStreamFactory::OnResolution(const QuicSessionKey& key,
@@ skipping 265 matching lines @@
   for (NetworkHandle new_network : network_list) {
     if (new_network != old_network)
       return new_network;
   }
   return NetworkChangeNotifier::kInvalidNetworkHandle;
 }
 
 void QuicStreamFactory::MaybeMigrateOrCloseSessions(
     NetworkHandle new_network,
     bool close_if_cannot_migrate,
-    const BoundNetLog& bound_net_log) {
+    const NetLogWithSource& net_log) {
   QuicStreamFactory::SessionIdMap::iterator it = all_sessions_.begin();
   while (it != all_sessions_.end()) {
     QuicChromiumClientSession* session = it->first;
     ++it;
 
     // If session is already bound to |new_network|, move on.
     if (session->GetDefaultSocket()->GetBoundNetwork() == new_network) {
       HistogramAndLogMigrationFailure(
-          bound_net_log, MIGRATION_STATUS_ALREADY_MIGRATED,
-          session->connection_id(), "Already bound to new network");
+          net_log, MIGRATION_STATUS_ALREADY_MIGRATED, session->connection_id(),
+          "Already bound to new network");
       continue;
     }
 
     // Close idle sessions.
     if (session->GetNumActiveStreams() == 0) {
       HistogramAndLogMigrationFailure(
-          bound_net_log, MIGRATION_STATUS_NO_MIGRATABLE_STREAMS,
+          net_log, MIGRATION_STATUS_NO_MIGRATABLE_STREAMS,
           session->connection_id(), "No active sessions");
       session->CloseSessionOnError(
           ERR_NETWORK_CHANGED, QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS);
       continue;
     }
 
     // If session has active streams, mark it as going away.
     OnSessionGoingAway(session);
 
     // Do not migrate sessions where connection migration is disabled.
     if (session->config()->DisableConnectionMigration()) {
-      HistogramAndLogMigrationFailure(bound_net_log, MIGRATION_STATUS_DISABLED,
+      HistogramAndLogMigrationFailure(net_log, MIGRATION_STATUS_DISABLED,
                                       session->connection_id(),
                                       "Migration disabled");
       if (close_if_cannot_migrate) {
         session->CloseSessionOnError(ERR_NETWORK_CHANGED,
                                      QUIC_IP_ADDRESS_CHANGED);
       }
       continue;
     }
 
     // Do not migrate sessions with non-migratable streams.
     if (session->HasNonMigratableStreams()) {
       HistogramAndLogMigrationFailure(
-          bound_net_log, MIGRATION_STATUS_NON_MIGRATABLE_STREAM,
+          net_log, MIGRATION_STATUS_NON_MIGRATABLE_STREAM,
           session->connection_id(), "Non-migratable stream");
       if (close_if_cannot_migrate) {
         session->CloseSessionOnError(
             ERR_NETWORK_CHANGED,
             QUIC_CONNECTION_MIGRATION_NON_MIGRATABLE_STREAM);
       }
       continue;
     }
 
     // No new network was found. Notify session, so it can wait for a
     // new network.
     if (new_network == NetworkChangeNotifier::kInvalidNetworkHandle) {
       session->OnNoNewNetwork();
       continue;
     }
 
     MigrateSessionToNewNetwork(session, new_network,
-                               /*close_session_on_error=*/true, bound_net_log);
+                               /*close_session_on_error=*/true, net_log);
   }
 }
 
 MigrationResult QuicStreamFactory::MaybeMigrateSingleSession(
     QuicChromiumClientSession* session,
     MigrationCause migration_cause) {
   ScopedConnectionMigrationEventLog scoped_event_log(
       net_log_,
       migration_cause == EARLY_MIGRATION ? "EarlyMigration" : "WriteError");
   if (!migrate_sessions_on_network_change_ ||
@@ skipping 16 matching lines @@
   }
   OnSessionGoingAway(session);
   return MigrateSessionToNewNetwork(session, new_network,
                                     migration_cause != WRITE_ERROR,
                                     scoped_event_log.net_log());
 }
 
 void QuicStreamFactory::MigrateSessionToNewPeerAddress(
     QuicChromiumClientSession* session,
     IPEndPoint peer_address,
-    const BoundNetLog& bound_net_log) {
+    const NetLogWithSource& net_log) {
   if (!allow_server_migration_)
     return;
 
   IPEndPoint old_address;
   session->GetDefaultSocket()->GetPeerAddress(&old_address);
   DCHECK_EQ(old_address.GetFamily(), peer_address.GetFamily());
 
   // Specifying kInvalidNetworkHandle for the |network| parameter
   // causes the session to use the default network for the new socket.
   MigrateSessionInner(session, peer_address,
                       NetworkChangeNotifier::kInvalidNetworkHandle,
-                      /*close_session_on_error=*/true, bound_net_log);
+                      /*close_session_on_error=*/true, net_log);
 }
 
 MigrationResult QuicStreamFactory::MigrateSessionToNewNetwork(
     QuicChromiumClientSession* session,
     NetworkHandle network,
     bool close_session_on_error,
-    const BoundNetLog& bound_net_log) {
+    const NetLogWithSource& net_log) {
   return MigrateSessionInner(session, session->connection()->peer_address(),
-                             network, close_session_on_error, bound_net_log);
+                             network, close_session_on_error, net_log);
 }
 
 MigrationResult QuicStreamFactory::MigrateSessionInner(
     QuicChromiumClientSession* session,
     IPEndPoint peer_address,
     NetworkHandle network,
     bool close_session_on_error,
-    const BoundNetLog& bound_net_log) {
+    const NetLogWithSource& net_log) {
   // Use OS-specified port for socket (DEFAULT_BIND) instead of
   // using the PortSuggester since the connection is being migrated
   // and not being newly created.
   std::unique_ptr<DatagramClientSocket> socket(
       client_socket_factory_->CreateDatagramClientSocket(
           DatagramSocket::DEFAULT_BIND, RandIntCallback(),
           session->net_log().net_log(), session->net_log().source()));
   if (ConfigureSocket(socket.get(), peer_address, network) != OK) {
-    HistogramAndLogMigrationFailure(
-        bound_net_log, MIGRATION_STATUS_INTERNAL_ERROR,
-        session->connection_id(), "Socket configuration failed");
+    HistogramAndLogMigrationFailure(net_log, MIGRATION_STATUS_INTERNAL_ERROR,
+                                    session->connection_id(),
+                                    "Socket configuration failed");
     if (close_session_on_error) {
       session->CloseSessionOnError(ERR_NETWORK_CHANGED, QUIC_INTERNAL_ERROR);
     }
     return MigrationResult::FAILURE;
   }
   std::unique_ptr<QuicChromiumPacketReader> new_reader(
       new QuicChromiumPacketReader(socket.get(), clock_.get(), session,
                                    yield_after_packets_, yield_after_duration_,
                                    session->net_log()));
   std::unique_ptr<QuicChromiumPacketWriter> new_writer(
       new QuicChromiumPacketWriter(socket.get()));
   new_writer->set_delegate(session);
 
   if (!session->MigrateToSocket(std::move(socket), std::move(new_reader),
                                 std::move(new_writer))) {
-    HistogramAndLogMigrationFailure(
-        bound_net_log, MIGRATION_STATUS_TOO_MANY_CHANGES,
-        session->connection_id(), "Too many migrations");
+    HistogramAndLogMigrationFailure(net_log, MIGRATION_STATUS_TOO_MANY_CHANGES,
+                                    session->connection_id(),
+                                    "Too many migrations");
     if (close_session_on_error) {
       session->CloseSessionOnError(ERR_NETWORK_CHANGED,
                                    QUIC_CONNECTION_MIGRATION_TOO_MANY_CHANGES);
     }
     return MigrationResult::FAILURE;
   }
   HistogramMigrationStatus(MIGRATION_STATUS_SUCCESS);
-  bound_net_log.AddEvent(
-      NetLogEventType::QUIC_CONNECTION_MIGRATION_SUCCESS,
-      base::Bind(&NetLogQuicConnectionMigrationSuccessCallback,
-                 session->connection_id()));
+  net_log.AddEvent(NetLogEventType::QUIC_CONNECTION_MIGRATION_SUCCESS,
+                   base::Bind(&NetLogQuicConnectionMigrationSuccessCallback,
+                              session->connection_id()));
   return MigrationResult::SUCCESS;
 }
 
 void QuicStreamFactory::OnSSLConfigChanged() {
   CloseAllSessions(ERR_CERT_DATABASE_CHANGED, QUIC_CONNECTION_CANCELLED);
 }
 
 void QuicStreamFactory::OnCertAdded(const X509Certificate* cert) {
   CloseAllSessions(ERR_CERT_DATABASE_CHANGED, QUIC_CONNECTION_CANCELLED);
 }
@@ skipping 86 matching lines @@
   return OK;
 }
 
 int QuicStreamFactory::CreateSession(
     const QuicSessionKey& key,
     int cert_verify_flags,
     std::unique_ptr<QuicServerInfo> 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) {
   if (need_to_evaluate_consecutive_disabled_count_) {
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&QuicStreamFactory::MaybeClearConsecutiveDisabledCount,
                    weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(kDisableQuicTimeoutSecs));
 
     need_to_evaluate_consecutive_disabled_count_ = false;
   }
@@ skipping 141 matching lines @@
 bool QuicStreamFactory::CryptoConfigCacheIsEmpty(
     const QuicServerId& server_id) {
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_.LookupOrCreate(server_id);
   return cached->IsEmpty();
 }
 
 QuicAsyncStatus QuicStreamFactory::StartCertVerifyJob(
     const QuicServerId& server_id,
     int cert_verify_flags,
-    const BoundNetLog& net_log) {
+    const NetLogWithSource& net_log) {
   if (!race_cert_verification_)
     return QUIC_FAILURE;
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_.LookupOrCreate(server_id);
   if (!cached || cached->certs().empty() ||
       HasActiveCertVerifierJob(server_id)) {
     return QUIC_FAILURE;
   }
   std::unique_ptr<CertVerifierJob> cert_verifier_job(
       new CertVerifierJob(server_id, cert_verify_flags, net_log));
@@ skipping 130 matching lines @@
 void QuicStreamFactory::OpenFactory() {
   status_ = OPEN;
 }
 
 void QuicStreamFactory::MaybeClearConsecutiveDisabledCount() {
   if (status_ == OPEN)
     consecutive_disabled_count_ = 0;
 }
 
 }  // namespace net