Early connection migration in QUIC.

net/quic/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/quic_stream_factory.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 41 matching lines @@
 #endif
 
 #if defined(USE_OPENSSL)
 #include <openssl/aead.h>
 #include "crypto/openssl_util.h"
 #else
 #include "base/cpu.h"
 #endif
 
 using std::min;
+using NetworkHandle = net::NetworkChangeNotifier::NetworkHandle;
 
 namespace net {
 
 namespace {
 
 enum CreateSessionFailure {
   CREATION_ERROR_CONNECTING_SOCKET,
   CREATION_ERROR_SETTING_RECEIVE_BUFFER,
   CREATION_ERROR_SETTING_SEND_BUFFER,
   CREATION_ERROR_MAX
@@ skipping 512 matching lines @@
     int max_disabled_reasons,
     int threshold_public_resets_post_handshake,
     int threshold_timeouts_with_open_streams,
     int socket_receive_buffer_size,
     bool delay_tcp_race,
     int max_server_configs_stored_in_properties,
     bool close_sessions_on_ip_change,
     bool disable_quic_on_timeout_with_open_streams,
     int idle_connection_timeout_seconds,
     bool migrate_sessions_on_network_change,
+    bool migrate_sessions_early,
     const QuicTagVector& connection_options)
     : require_confirmation_(true),
       host_resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
       http_server_properties_(http_server_properties),
       transport_security_state_(transport_security_state),
       cert_transparency_verifier_(cert_transparency_verifier),
       quic_crypto_client_stream_factory_(quic_crypto_client_stream_factory),
       random_generator_(random_generator),
       clock_(clock),
@@ skipping 29 matching lines @@
           threshold_public_resets_post_handshake),
       socket_receive_buffer_size_(socket_receive_buffer_size),
       delay_tcp_race_(delay_tcp_race),
       yield_after_packets_(kQuicYieldAfterPacketsRead),
       yield_after_duration_(QuicTime::Delta::FromMilliseconds(
           kQuicYieldAfterDurationMilliseconds)),
       close_sessions_on_ip_change_(close_sessions_on_ip_change),
       migrate_sessions_on_network_change_(
           migrate_sessions_on_network_change &&
           NetworkChangeNotifier::AreNetworkHandlesSupported()),
+      migrate_sessions_early_(migrate_sessions_early &&
+                              migrate_sessions_on_network_change_),
       port_seed_(random_generator_->RandUint64()),
       check_persisted_supports_quic_(true),
       has_initialized_data_(false),
       task_runner_(nullptr),
       weak_factory_(this) {
   if (disable_quic_on_timeout_with_open_streams)
     threshold_timeouts_with_open_streams_ = 1;
   DCHECK(transport_security_state_);
   DCHECK(http_server_properties_);
   crypto_config_.set_user_agent_id(user_agent_id);
@@ skipping 20 matching lines @@
   if (!IsEcdsaSupported())
     crypto_config_.DisableEcdsa();
   // When disk cache is used to store the server configs, HttpCache code calls
   // |set_quic_server_info_factory| if |quic_server_info_factory_| wasn't
   // created.
   if (max_server_configs_stored_in_properties > 0) {
     quic_server_info_factory_.reset(
         new PropertiesBasedQuicServerInfoFactory(http_server_properties_));
   }
 
-  DCHECK(
-      !(close_sessions_on_ip_change_ && migrate_sessions_on_network_change_));
+  // migrate_sessions_early_ should only be set to true if
+  // migrate_sessions_on_network_change_ is set to true.
+  DCHECK(migrate_sessions_on_network_change_ || !migrate_sessions_early_);
+  // close_sessions_on_ip_change_ and migrate_sessions_on_network_change_ should
+  // never be simultaneously set to true.
+  DCHECK(!close_sessions_on_ip_change_ || !migrate_sessions_on_network_change_);
   if (migrate_sessions_on_network_change_) {
     NetworkChangeNotifier::AddNetworkObserver(this);
   } else if (close_sessions_on_ip_change_) {
     NetworkChangeNotifier::AddIPAddressObserver(this);
   }
 }
 
 QuicStreamFactory::~QuicStreamFactory() {
   CloseAllSessions(ERR_ABORTED, QUIC_CONNECTION_CANCELLED);
   while (!all_sessions_.empty()) {
@@ skipping 486 matching lines @@
 
 void QuicStreamFactory::ClearCachedStatesInCryptoConfig() {
   crypto_config_.ClearCachedStates();
 }
 
 void QuicStreamFactory::OnIPAddressChanged() {
   CloseAllSessions(ERR_NETWORK_CHANGED, QUIC_IP_ADDRESS_CHANGED);
   set_require_confirmation(true);
 }
 
-void QuicStreamFactory::OnNetworkConnected(
-    NetworkChangeNotifier::NetworkHandle network) {}
+void QuicStreamFactory::OnNetworkConnected(NetworkHandle network) {}
 
-void QuicStreamFactory::OnNetworkMadeDefault(
-    NetworkChangeNotifier::NetworkHandle network) {}
+void QuicStreamFactory::OnNetworkMadeDefault(NetworkHandle network) {}
 
-void QuicStreamFactory::OnNetworkDisconnected(
-    NetworkChangeNotifier::NetworkHandle network) {
+void QuicStreamFactory::OnNetworkDisconnected(NetworkHandle network) {
   MaybeMigrateOrCloseSessions(network, /*force_close=*/true);
   set_require_confirmation(true);
 }
 
 // This method is expected to only be called when migrating from Cellular to
 // WiFi on Android.
-void QuicStreamFactory::OnNetworkSoonToDisconnect(
-    NetworkChangeNotifier::NetworkHandle network) {
+void QuicStreamFactory::OnNetworkSoonToDisconnect(NetworkHandle network) {
   MaybeMigrateOrCloseSessions(network, /*force_close=*/false);
 }
 
-NetworkChangeNotifier::NetworkHandle QuicStreamFactory::FindAlternateNetwork(
-    NetworkChangeNotifier::NetworkHandle old_network) {
+NetworkHandle QuicStreamFactory::FindAlternateNetwork(
+    NetworkHandle old_network) {
   // Find a new network that sessions bound to |old_network| can be migrated to.
   NetworkChangeNotifier::NetworkList network_list;
   NetworkChangeNotifier::GetConnectedNetworks(&network_list);
-  for (NetworkChangeNotifier::NetworkHandle new_network : network_list) {
+  for (NetworkHandle new_network : network_list) {
     if (new_network != old_network) {
       return new_network;
     }
   }
   return NetworkChangeNotifier::kInvalidNetworkHandle;
 }
 
-void QuicStreamFactory::MaybeMigrateOrCloseSessions(
-    NetworkChangeNotifier::NetworkHandle network,
-    bool force_close) {
+void QuicStreamFactory::MaybeMigrateOrCloseSessions(NetworkHandle network,
+                                                    bool force_close) {
   DCHECK_NE(NetworkChangeNotifier::kInvalidNetworkHandle, network);
-  NetworkChangeNotifier::NetworkHandle new_network =
-      FindAlternateNetwork(network);
+  NetworkHandle new_network = FindAlternateNetwork(network);
 
   QuicStreamFactory::SessionIdMap::iterator it = all_sessions_.begin();
   while (it != all_sessions_.end()) {
     QuicChromiumClientSession* session = it->first;
     QuicServerId server_id = it->second;
     ++it;
 
     if (session->GetDefaultSocket()->GetBoundNetwork() != network) {
       // If session is not bound to |network|, move on.
       HistogramMigrationStatus(MIGRATION_STATUS_ALREADY_MIGRATED);
@@ skipping 15 matching lines @@
                                      QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK);
       }
       continue;
     }
     MigrateSessionToNetwork(session, new_network);
   }
 }
 
 void QuicStreamFactory::MaybeMigrateSessionEarly(
     QuicChromiumClientSession* session) {
-  if (session->GetNumActiveStreams() == 0) {
+  if (!migrate_sessions_early_) {
     return;
   }
-  NetworkChangeNotifier::NetworkHandle current_network =
-      session->GetDefaultSocket()->GetBoundNetwork();
-  NetworkChangeNotifier::NetworkHandle new_network =
-      FindAlternateNetwork(current_network);
+  NetworkHandle new_network =
+      FindAlternateNetwork(session->GetDefaultSocket()->GetBoundNetwork());
   if (new_network == NetworkChangeNotifier::kInvalidNetworkHandle) {
     // No alternate network found.
     return;
   }
   OnSessionGoingAway(session);
   MigrateSessionToNetwork(session, new_network);
 }
 
 void QuicStreamFactory::MigrateSessionToNetwork(
     QuicChromiumClientSession* session,
-    NetworkChangeNotifier::NetworkHandle new_network) {
+    NetworkHandle new_network) {
   // Use OS-specified port for socket (DEFAULT_BIND) instead of
   // using the PortSuggester since the connection is being migrated
   // and not being newly created.
   scoped_ptr<DatagramClientSocket> socket(
       client_socket_factory_->CreateDatagramClientSocket(
           DatagramSocket::DEFAULT_BIND, RandIntCallback(),
           session->net_log().net_log(), session->net_log().source()));
   QuicConnection* connection = session->connection();
   if (ConfigureSocket(socket.get(), connection->peer_address(), new_network) !=
       OK) {
@@ skipping 42 matching lines @@
   // TODO(rtenneti): crbug.com/498823 - delete active_sessions_.empty() check.
   if (active_sessions_.empty())
     return false;
   return ContainsKey(active_sessions_, server_id);
 }
 
 bool QuicStreamFactory::HasActiveJob(const QuicServerId& key) const {
   return ContainsKey(active_jobs_, key);
 }
 
-int QuicStreamFactory::ConfigureSocket(
-    DatagramClientSocket* socket,
-    IPEndPoint addr,
-    NetworkChangeNotifier::NetworkHandle network) {
+int QuicStreamFactory::ConfigureSocket(DatagramClientSocket* socket,
+                                       IPEndPoint addr,
+                                       NetworkHandle network) {
   if (enable_non_blocking_io_ &&
       client_socket_factory_ == ClientSocketFactory::GetDefaultFactory()) {
 #if defined(OS_WIN)
     static_cast<UDPClientSocket*>(socket)->UseNonBlockingIO();
 #endif
   }
 
   // If caller leaves network unspecified, use current default.
   int rv;
   if (migrate_sessions_on_network_change_) {
@@ skipping 296 matching lines @@
   // Since the session was active, there's no longer an
   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the TCP
   // job also fails. So to avoid not using QUIC when we otherwise could, we mark
   // it as recently broken, which means that 0-RTT will be disabled but we'll
   // still race.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 }  // namespace net