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

net/quic/quic_chromium_client_session.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_chromium_client_session.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
@@ skipping 24 matching lines @@
 
 namespace {
 
 // The length of time to wait for a 0-RTT handshake to complete
 // before allowing the requests to possibly proceed over TCP.
 const int k0RttHandshakeTimeoutMs = 300;
 
 // IPv6 packets have an additional 20 bytes of overhead than IPv4 packets.
 const size_t kAdditionalOverheadForIPv6 = 20;
 
+// Maximum number of Readers that are created for any session due to
+// connection migration. A new Reader is created every time this endpoint's
+// IP address changes.
+const size_t kMaxReadersPerQuicSession = 5;
+
 // Histograms for tracking down the crashes from http://crbug.com/354669
 // Note: these values must be kept in sync with the corresponding values in:
 // tools/metrics/histograms/histograms.xml
 enum Location {
   DESTRUCTOR = 0,
   ADD_OBSERVER = 1,
   TRY_CREATE_STREAM = 2,
   CREATE_OUTGOING_RELIABLE_STREAM = 3,
   NOTIFY_FACTORY_OF_SESSION_CLOSED_LATER = 4,
   NOTIFY_FACTORY_OF_SESSION_CLOSED = 5,
@@ skipping 118 matching lines @@
     QuicCryptoClientConfig* crypto_config,
     const char* const connection_description,
     base::TimeTicks dns_resolution_end_time,
     base::TaskRunner* task_runner,
     scoped_ptr<SocketPerformanceWatcher> socket_performance_watcher,
     NetLog* net_log)
     : QuicClientSessionBase(connection, config),
       server_id_(server_id),
       require_confirmation_(false),
       stream_factory_(stream_factory),
-      socket_(std::move(socket)),
       transport_security_state_(transport_security_state),
       server_info_(std::move(server_info)),
       num_total_streams_(0),
       task_runner_(task_runner),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
-      packet_reader_(socket_.get(),
-                     clock,
-                     this,
-                     yield_after_packets,
-                     yield_after_duration,
-                     net_log_),
       dns_resolution_end_time_(dns_resolution_end_time),
       logger_(new QuicConnectionLogger(this,
                                        connection_description,
                                        std::move(socket_performance_watcher),
                                        net_log_)),
       going_away_(false),
       disabled_reason_(QUIC_DISABLED_NOT),
       weak_factory_(this) {
+  sockets_.push_back(std::move(socket));
+  packet_readers_.push_back(make_scoped_ptr(new QuicPacketReader(
+      sockets_.back().get(), clock, this, yield_after_packets,
+      yield_after_duration, net_log_)));
   crypto_stream_.reset(
       crypto_client_stream_factory->CreateQuicCryptoClientStream(
           server_id, this, make_scoped_ptr(new ProofVerifyContextChromium(
                                cert_verify_flags, net_log_)),
           crypto_config));
   connection->set_debug_visitor(logger_.get());
   net_log_.BeginEvent(NetLog::TYPE_QUIC_SESSION,
                       base::Bind(NetLogQuicClientSessionCallback, &server_id,
                                  cert_verify_flags, require_confirmation_));
   IPEndPoint address;
@@ skipping 553 matching lines @@
   } else if (error == QUIC_PUBLIC_RESET) {
     disabled_reason_ = QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE;
   }
 
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.QuicVersion",
                               connection()->version());
   NotifyFactoryOfSessionGoingAway();
   if (!callback_.is_null()) {
     base::ResetAndReturn(&callback_).Run(ERR_QUIC_PROTOCOL_ERROR);
   }
-  socket_->Close();
+
+  for (auto& socket : sockets_) {
+    socket->Close();
+  }
   QuicSession::OnConnectionClosed(error, from_peer);
   DCHECK(dynamic_streams().empty());
   CloseAllStreams(ERR_UNEXPECTED);
   CloseAllObservers(ERR_UNEXPECTED);
   NotifyFactoryOfSessionClosedLater();
 }
 
 void QuicChromiumClientSession::OnSuccessfulVersionNegotiation(
     const QuicVersion& version) {
   logger_->OnSuccessfulVersionNegotiation(version);
@@ skipping 25 matching lines @@
   cert_verify_result_.reset(new CertVerifyResult);
   cert_verify_result_->CopyFrom(verify_details_chromium->cert_verify_result);
   pinning_failure_log_ = verify_details_chromium->pinning_failure_log;
   scoped_ptr<ct::CTVerifyResult> ct_verify_result_copy(
       new ct::CTVerifyResult(verify_details_chromium->ct_verify_result));
   ct_verify_result_ = std::move(ct_verify_result_copy);
   logger_->OnCertificateVerified(*cert_verify_result_);
 }
 
 void QuicChromiumClientSession::StartReading() {
-  packet_reader_.StartReading();
+  for (auto& packet_reader : packet_readers_) {
+    packet_reader->StartReading();
+  }
 }
 
 void QuicChromiumClientSession::CloseSessionOnError(int error,
                                                     QuicErrorCode quic_error) {
   RecordAndCloseSessionOnError(error, quic_error);
   NotifyFactoryOfSessionClosed();
 }
 
 void QuicChromiumClientSession::CloseSessionOnErrorAndNotifyFactoryLater(
     int error,
@@ skipping 78 matching lines @@
 }
 
 base::WeakPtr<QuicChromiumClientSession>
 QuicChromiumClientSession::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 void QuicChromiumClientSession::OnReadError(
     int result,
     const DatagramClientSocket* socket) {
+  DCHECK(socket != nullptr);
+  if (socket != GetDefaultSocket()) {
+    // Ignore read errors from old sockets that are no longer active.
+    // TODO(jri): Maybe clean up old sockets on error.
+    return;
+  }
   DVLOG(1) << "Closing session on read error: " << result;
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.ReadError", -result);
   NotifyFactoryOfSessionGoingAway();
   CloseSessionOnErrorInner(result, QUIC_PACKET_READ_ERROR);
   NotifyFactoryOfSessionClosedLater();
 }
 
 bool QuicChromiumClientSession::OnPacket(const QuicEncryptedPacket& packet,
                                          IPEndPoint local_address,
                                          IPEndPoint peer_address) {
@@ skipping 48 matching lines @@
   if (IsCryptoHandshakeConfirmed())
     return;
 
   // TODO(rch): re-enable this code once beta is cut.
   //  if (stream_factory_)
   //    stream_factory_->OnSessionConnectTimeout(this);
   //  CloseAllStreams(ERR_QUIC_HANDSHAKE_FAILED);
   //  DCHECK_EQ(0u, GetNumOpenOutgoingStreams());
 }
 
+bool QuicChromiumClientSession::MigrateToSocket(
+    scoped_ptr<DatagramClientSocket> socket,
+    scoped_ptr<QuicPacketReader> reader,
+    scoped_ptr<QuicPacketWriter> writer) {
+  DCHECK_EQ(sockets_.size(), packet_readers_.size());
+  if (sockets_.size() >= kMaxReadersPerQuicSession) {
+    return false;
+  }
+  // TODO(jri): Make SetQuicPacketWriter take a scoped_ptr.
+  connection()->SetQuicPacketWriter(writer.release(), /*owns_writer=*/true);
+  packet_readers_.push_back(std::move(reader));
+  sockets_.push_back(std::move(socket));
+  StartReading();
+  connection()->SendPing(/*force=*/true);
+  return true;
+}
+
+const DatagramClientSocket* QuicChromiumClientSession::GetDefaultSocket()
+    const {
+  DCHECK(sockets_.back().get() != nullptr);
+  // The most recently added socket is the currently active one.
+  return sockets_.back().get();
+}
+
 }  // namespace net