Migrates QUIC sessions to a new network when old network is (about to be) disconnected.

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 "base/location.h"
@@ skipping 1094 matching lines @@
     }
   }
   return list.Pass();
 }
 
 void QuicStreamFactory::ClearCachedStatesInCryptoConfig() {
   crypto_config_.ClearCachedStates();
 }
 
 void QuicStreamFactory::OnIPAddressChanged() {
-  CloseAllSessions(ERR_NETWORK_CHANGED);
+  // CloseAllIdleSessions(ERR_NETWORK_CHANGED);
+  for (QuicStreamFactory::SessionIdMap::iterator it = all_sessions_.begin();
+       it != all_sessions_.end(); ++it) {

[Ryan Hamilton, 2015/09/08 04:09:38]

Can you do a C++11 range loop here?

[Jana, 2015/11/17 01:50:09]

Done.

+    QuicChromiumClientSession* session = it->first;
+    QuicServerId server_id = it->second;
+    if (session->GetNumOpenStreams() == 0) {
+      // If idle session, close session
+      active_sessions_.erase(server_id);
+      session->CloseSessionOnError(ERR_NETWORK_CHANGED, QUIC_INTERNAL_ERROR);

[Ryan Hamilton, 2015/09/08 04:09:38]

not sure about INTERNAL_ERROR

nit: add a continue, to remove the "} else {" and outdent.

[Jana, 2015/11/17 01:50:09]

Done.

+    } else {
+      // If session is active, (i) create a new socket (which should be

[Ryan Hamilton, 2015/09/08 04:09:38]

nit: s/is active/has active streams/

[Jana, 2015/11/17 01:50:09]

Done.

+      // bound to the new interface), (ii) add a new PacketReader to the
+      // session that reads from the new socket, (iii) replace the
+      // connection's PacketWriter with a new PacketWriter that uses the
+      // new socket, and (iv) make the session go away.
+      scoped_ptr<DatagramClientSocket> socket(
+          client_socket_factory_->CreateDatagramClientSocket(
+              DatagramSocket::DEFAULT_BIND, RandIntCallback(),
+              // Fix net_log.source()
+              session->net_log().net_log(), session->net_log().source()));
+      if (!session->AddPacketReader(new QuicPacketReader(socket.get(), session,
+                                                         session->net_log()))) {
+        CloseAllSessions(ERR_NETWORK_CHANGED);
+        set_require_confirmation(true);

[Ryan Hamilton, 2015/09/08 04:09:38]

Is this required?

[Jana, 2015/11/17 01:50:08]

We've not verified this new network, and while it doesn't matter for this
session, since we'll move all packet writes to this new network anyways, a new
session should verify before using this network.

That said, we need something, and simple setting this flag isn't enough... I
think we need a "verified" flag that is set on a network when the network is
verified. I'll work on getting that in in this CL.

+        continue;
+      }
+      session->StartReading();
+
+      DefaultPacketWriterFactory packet_writer_factory(socket.get());
+      QuicConnection* connection = session->connection();
+      connection->SetQuicPacketWriter(packet_writer_factory.Create(connection),
+                                      /*owns_writer=*/true);
+
+      session->AddSocket(socket.Pass());

[Ryan Hamilton, 2015/09/08 04:09:38]

Yeah, probably a single method which takes Socket, Reader and Writer would be
best. That method could also call StartReading().

[Jana, 2015/11/17 01:50:09]

Done. PTAL.

+      OnSessionGoingAway(session);
+    }
+  }
   set_require_confirmation(true);

[Ryan Hamilton, 2015/09/08 04:09:38]

Might as well do this before the for loop since it can be easier to read if
there's nothing after the big loop

[Jana, 2015/11/17 01:50:09]

Done.

 }
 
 void QuicStreamFactory::OnCertAdded(const X509Certificate* cert) {
   CloseAllSessions(ERR_CERT_DATABASE_CHANGED);
 }
 
 void QuicStreamFactory::OnCACertChanged(const X509Certificate* cert) {
   // We should flush the sessions if we removed trust from a
   // cert, because a previously trusted server may have become
   // untrusted.
@@ skipping 46 matching lines @@
           net_log.net_log(), net_log.source()));
 
   if (enable_non_blocking_io_ &&
       client_socket_factory_ == ClientSocketFactory::GetDefaultFactory()) {
 #if defined(OS_WIN)
     static_cast<UDPClientSocket*>(socket.get())->UseNonBlockingIO();
 #endif
   }
 
   int rv = socket->Connect(addr);
-
   if (rv != OK) {
     HistogramCreateSessionFailure(CREATION_ERROR_CONNECTING_SOCKET);
     return rv;
   }
   UMA_HISTOGRAM_COUNTS("Net.QuicEphemeralPortsSuggested",
                        port_suggester->call_count());
   if (enable_port_selection) {
     DCHECK_LE(1u, port_suggester->call_count());
   } else {
     DCHECK_EQ(0u, port_suggester->call_count());
@@ skipping 209 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