Minor refactor of MaybeMigrateOrCloseSessions.

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 1165 matching lines @@
   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) {
   MaybeMigrateOrCloseSessions(network, /*force_close=*/false);
 }
 
-void QuicStreamFactory::MaybeMigrateOrCloseSessions(
-    NetworkChangeNotifier::NetworkHandle network,
-    bool force_close) {
-  DCHECK_NE(NetworkChangeNotifier::kInvalidNetworkHandle, network);
-
+NetworkChangeNotifier::NetworkHandle QuicStreamFactory::FindAlternateNetwork(
+    NetworkChangeNotifier::NetworkHandle network) {
   // Find a new network that sessions bound to |network| can be migrated to.
   NetworkChangeNotifier::NetworkList network_list;
   NetworkChangeNotifier::GetConnectedNetworks(&network_list);
   NetworkChangeNotifier::NetworkHandle new_network =
       NetworkChangeNotifier::kInvalidNetworkHandle;
   for (NetworkChangeNotifier::NetworkHandle n : network_list) {
     if (n != network) {
       new_network = n;
       break;
     }
   }
+  return new_network;
+}

[Ryan Hamilton, 2016/01/21 15:16:02]

This can now be simpler:

NetworkChangeNotifier::NetworkHandle QuicStreamFactory::FindAlternateNetwork(
     NetworkChangeNotifier::NetworkHandle old_network){
  NetworkChangeNotifier::NetworkList networks;
  NetworkChangeNotifier::GetConnectedNetworks(&networks);
  for (NetworkChangeNotifier::NetworkHandle new_network : networks) {
    if (new_network != old_network)
      return network;
  }
  return NetworkChangeNotifier::kInvalidNetworkHandle;
}

[Jana, 2016/01/21 18:25:50]

Ah, right, of course. Done.

+
+void QuicStreamFactory::MaybeMigrateOrCloseSessions(
+    NetworkChangeNotifier::NetworkHandle network,
+    bool force_close) {
+  DCHECK_NE(NetworkChangeNotifier::kInvalidNetworkHandle, network);
+  NetworkChangeNotifier::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);
       continue;
     }
     if (session->GetNumActiveStreams() == 0) {
       // Close idle sessions.
       session->CloseSessionOnError(
           ERR_NETWORK_CHANGED, QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS);
       HistogramMigrationStatus(MIGRATION_STATUS_NO_MIGRATABLE_STREAMS);
       continue;
     }
     // If session has active streams, mark it as going away.
     OnSessionGoingAway(session);
     if (new_network == NetworkChangeNotifier::kInvalidNetworkHandle) {
       // No new network was found.
       if (force_close) {
         session->CloseSessionOnError(ERR_NETWORK_CHANGED,
                                      QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK);
       }
       continue;
     }
-
-    // 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) {
-      session->CloseSessionOnError(ERR_NETWORK_CHANGED, QUIC_INTERNAL_ERROR);
-      HistogramMigrationStatus(MIGRATION_STATUS_INTERNAL_ERROR);
-      continue;
-    }
-
-    scoped_ptr<QuicPacketReader> new_reader(new QuicPacketReader(
-        socket.get(), clock_.get(), session, yield_after_packets_,
-        yield_after_duration_, session->net_log()));
-    scoped_ptr<QuicPacketWriter> new_writer(
-        new QuicDefaultPacketWriter(socket.get()));
-
-    if (!session->MigrateToSocket(std::move(socket), std::move(new_reader),
-                                  std::move(new_writer))) {
-      session->CloseSessionOnError(ERR_NETWORK_CHANGED,
-                                   QUIC_CONNECTION_MIGRATION_TOO_MANY_CHANGES);
-      HistogramMigrationStatus(MIGRATION_STATUS_TOO_MANY_CHANGES);
-    } else {
-      HistogramMigrationStatus(MIGRATION_STATUS_SUCCESS);
-    }
+    MigrateSessionToNetwork(session, new_network);
   }
 }
 
+void QuicStreamFactory::MigrateSessionToNetwork(
+    QuicChromiumClientSession* session,
+    NetworkChangeNotifier::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) {
+    session->CloseSessionOnError(ERR_NETWORK_CHANGED, QUIC_INTERNAL_ERROR);
+    HistogramMigrationStatus(MIGRATION_STATUS_INTERNAL_ERROR);
+    return;
+  }
+  scoped_ptr<QuicPacketReader> new_reader(new QuicPacketReader(
+      socket.get(), clock_.get(), session, yield_after_packets_,
+      yield_after_duration_, session->net_log()));
+  scoped_ptr<QuicPacketWriter> new_writer(
+      new QuicDefaultPacketWriter(socket.get()));
+
+  if (!session->MigrateToSocket(std::move(socket), std::move(new_reader),
+                                std::move(new_writer))) {
+    session->CloseSessionOnError(ERR_NETWORK_CHANGED,
+                                 QUIC_CONNECTION_MIGRATION_TOO_MANY_CHANGES);
+    HistogramMigrationStatus(MIGRATION_STATUS_TOO_MANY_CHANGES);
+    return;
+  }
+  HistogramMigrationStatus(MIGRATION_STATUS_SUCCESS);
+}
+
 void QuicStreamFactory::OnSSLConfigChanged() {
   CloseAllSessions(ERR_CERT_DATABASE_CHANGED, QUIC_INTERNAL_ERROR);
 }
 
 void QuicStreamFactory::OnCertAdded(const X509Certificate* cert) {
   CloseAllSessions(ERR_CERT_DATABASE_CHANGED, QUIC_INTERNAL_ERROR);
 }
 
 void QuicStreamFactory::OnCACertChanged(const X509Certificate* cert) {
   // We should flush the sessions if we removed trust from a
@@ skipping 323 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