Introduces ability for session to wait on a migration trigger for a new

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 53 matching lines @@
 namespace {
 
 enum CreateSessionFailure {
   CREATION_ERROR_CONNECTING_SOCKET,
   CREATION_ERROR_SETTING_RECEIVE_BUFFER,
   CREATION_ERROR_SETTING_SEND_BUFFER,
   CREATION_ERROR_SETTING_DO_NOT_FRAGMENT,
   CREATION_ERROR_MAX
 };
 
-enum QuicConnectionMigrationStatus {
-  MIGRATION_STATUS_NO_MIGRATABLE_STREAMS,
-  MIGRATION_STATUS_ALREADY_MIGRATED,
-  MIGRATION_STATUS_INTERNAL_ERROR,
-  MIGRATION_STATUS_TOO_MANY_CHANGES,
-  MIGRATION_STATUS_SUCCESS,
-  MIGRATION_STATUS_NON_MIGRATABLE_STREAM,
-  MIGRATION_STATUS_DISABLED,
-  MIGRATION_STATUS_NO_ALTERNATE_NETWORK,
-  MIGRATION_STATUS_MAX
-};
-
 // The maximum receive window sizes for QUIC sessions and streams.
 const int32_t kQuicSessionMaxRecvWindowSize = 15 * 1024 * 1024;  // 15 MB
 const int32_t kQuicStreamMaxRecvWindowSize = 6 * 1024 * 1024;    // 6 MB
 
 // Set the maximum number of undecryptable packets the connection will store.
 const int32_t kMaxUndecryptablePackets = 100;
 
 std::unique_ptr<base::Value> NetLogQuicConnectionMigrationTriggerCallback(
     std::string trigger,
     NetLogCaptureMode capture_mode) {
@@ skipping 1341 matching lines @@
 void QuicStreamFactory::OnIPAddressChanged() {
   num_timeouts_with_open_streams_ = 0;
   status_ = OPEN;
   CloseAllSessions(ERR_NETWORK_CHANGED, QUIC_IP_ADDRESS_CHANGED);
   set_require_confirmation(true);
 }
 
 void QuicStreamFactory::OnNetworkConnected(NetworkHandle network) {
   num_timeouts_with_open_streams_ = 0;
   status_ = OPEN;
+  ScopedConnectionMigrationEventLog scoped_event_log(net_log_,
+                                                     "OnNetworkConnected");
+  for (auto session : all_sessions_) {
+    session.first->OnNetworkConnected(network, scoped_event_log.net_log());
+  }

[Ryan Hamilton, 2016/09/12 03:42:01]

I expected this to call MigrateOrCloseSessions(), but I'm guessing that's
problematic?

[Ryan Hamilton, 2016/09/13 00:33:18]

ping

[Jana, 2016/09/13 01:12:18]

OnNetworkConnected can be called from the NCN when the current network is the
default and is working just fine. We do not want to migrate every time this
notification is received since OnNetworkCOnnected does not mean that a migration
must happen. It just means that sessions that are pending migration now have a
network to use, which is what the ChromiumClientSession's OnNetworkConnected
ensures.

Note that we do call MaybeMigrateOrCloseSessions in OnNetworkMadeDefault.

 }
 
 void QuicStreamFactory::OnNetworkMadeDefault(NetworkHandle network) {
   ScopedConnectionMigrationEventLog scoped_event_log(net_log_,
                                                      "OnNetworkMadeDefault");
   DCHECK_NE(NetworkChangeNotifier::kInvalidNetworkHandle, network);
   MaybeMigrateOrCloseSessions(network, /*close_if_cannot_migrate=*/false,
                               scoped_event_log.net_log());
   set_require_confirmation(true);
 }
@@ skipping 15 matching lines @@
   // Find a new network that sessions bound to |old_network| can be migrated to.
   NetworkChangeNotifier::NetworkList network_list;
   NetworkChangeNotifier::GetConnectedNetworks(&network_list);
   for (NetworkHandle new_network : network_list) {
     if (new_network != old_network)
       return new_network;
   }
   return NetworkChangeNotifier::kInvalidNetworkHandle;
 }
 
+// @@@ look at other cl for changes here.

[Ryan Hamilton, 2016/09/12 03:42:01]

?

[Jana, 2016/09/13 01:12:18]

Leftover comment, removed.

 void QuicStreamFactory::MaybeMigrateOrCloseSessions(
     NetworkHandle new_network,
     bool close_if_cannot_migrate,
     const BoundNetLog& bound_net_log) {
   QuicStreamFactory::SessionIdMap::iterator it = all_sessions_.begin();
   while (it != all_sessions_.end()) {
     QuicChromiumClientSession* session = it->first;
     ++it;
 
-    // Migration attempted, but no new network was found. Close session.
-    if (new_network == NetworkChangeNotifier::kInvalidNetworkHandle) {
-      HistogramAndLogMigrationFailure(
-          bound_net_log, MIGRATION_STATUS_NO_ALTERNATE_NETWORK,
-          session->connection_id(), "No alternate network found");
-      session->CloseSessionOnError(ERR_NETWORK_CHANGED,
-                                   QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK);
-      continue;
-    }
-
     // 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");
       continue;
     }
 
     // Close idle sessions.
     if (session->GetNumActiveStreams() == 0) {
@@ skipping 26 matching lines @@
           bound_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);
   }
 }
 
 MigrationResult QuicStreamFactory::MaybeMigrateSingleSession(
     QuicChromiumClientSession* session,
     MigrationCause migration_cause) {
   ScopedConnectionMigrationEventLog scoped_event_log(
       net_log_,
@@ skipping 284 matching lines @@
     socket_performance_watcher =
         socket_performance_watcher_factory_->CreateSocketPerformanceWatcher(
             SocketPerformanceWatcherFactory::PROTOCOL_QUIC);
   }
 
   *session = new QuicChromiumClientSession(
       connection, std::move(socket), this, quic_crypto_client_stream_factory_,
       clock_.get(), transport_security_state_, std::move(server_info),
       server_id, yield_after_packets_, yield_after_duration_, cert_verify_flags,
       config, &crypto_config_, network_connection_.GetDescription(),
-      dns_resolution_end_time, &push_promise_index_,
-      base::ThreadTaskRunnerHandle::Get().get(),
+      dns_resolution_end_time, &push_promise_index_, task_runner_,
       std::move(socket_performance_watcher), net_log.net_log());
 
   all_sessions_[*session] = key;  // owning pointer
   writer->set_delegate(*session);
 
   (*session)->Initialize();
   bool closed_during_initialize = !base::ContainsKey(all_sessions_, *session) ||
                                   !(*session)->connection()->connected();
   UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.ClosedDuringInitializeSession",
                         closed_during_initialize);
@@ skipping 183 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