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

net/quic/quic_chromium_client_session.h

 // 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.
 //
 // A client specific QuicSession subclass.  This class owns the underlying
 // QuicConnection and QuicConnectionHelper objects.  The connection stores
 // a non-owning pointer to the helper so this session needs to ensure that
 // the helper outlives the connection.
 
 #ifndef NET_QUIC_QUIC_CHROMIUM_CLIENT_SESSION_H_
@@ skipping 156 matching lines @@
   // QuicClientSessionBase methods:
   void OnProofValid(const QuicCryptoClientConfig::CachedState& cached) override;
   void OnProofVerifyDetailsAvailable(
       const ProofVerifyDetails& verify_details) override;
 
   // QuicConnectionVisitorInterface methods:
   void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
   void OnSuccessfulVersionNegotiation(const QuicVersion& version) override;
 
   // QuicPacketReader::Visitor methods:
-  void OnReadError(int result) override;
+  void OnReadError(int result, const DatagramClientSocket* socket) override;
   bool OnPacket(const QuicEncryptedPacket& packet,
                 IPEndPoint local_address,
                 IPEndPoint peer_address) override;
 
   // Gets the SSL connection information.
   bool GetSSLInfo(SSLInfo* ssl_info) const;
 
   // Performs a crypto handshake with the server.
   int CryptoConnect(bool require_confirmation,
                     const CompletionCallback& callback);
 
   // Resumes a crypto handshake with the server after a timeout.
   int ResumeCryptoConnect(const CompletionCallback& callback);
 
-  // Causes the QuicConnectionHelper to start reading from the socket
+  // Causes the QuicConnectionHelper to start reading from all sockets
   // and passing the data along to the QuicConnection.
   void StartReading();
 
   // Close the session because of |error| and notifies the factory
   // that this session has been closed, which will delete the session.
   void CloseSessionOnError(int error, QuicErrorCode quic_error);
 
   // Close the session because of |error| and notifies the factory later that
   // this session has been closed, which will delete the session.
   void CloseSessionOnErrorAndNotifyFactoryLater(int error,
@@ skipping 12 matching lines @@
 
   // Returns true if |hostname| may be pooled onto this session.  If this
   // is a secure QUIC session, then |hostname| must match the certificate
   // presented during the handshake.
   bool CanPool(const std::string& hostname, PrivacyMode privacy_mode) const;
 
   const QuicServerId& server_id() const { return server_id_; }
 
   QuicDisabledReason disabled_reason() const { return disabled_reason_; }
 
+  // Migrates session onto new socket, i.e., starts reading from |socket|
+  // in addition to any previous sockets, and sets |writer| to be the new
+  // default writer. Returns true if socket was successfully added to the
+  // session and the session was successfully migrated to using the new socket.
+  // Returns false if number of migrations exceeds kMaxReadersPerQuicSession.
+  // Takes ownership of |socket|, |reader|, and |writer|.
+  bool MigrateToSocket(scoped_ptr<DatagramClientSocket> socket,
+                       scoped_ptr<QuicPacketReader> reader,
+                       scoped_ptr<QuicPacketWriter> writer);
+
+  // Returns current default socket. This is the socket over which all
+  // QUIC packets are sent. This default socket can change, so do not store the
+  // returned socket.
+  const DatagramClientSocket* GetDefaultSocket() const;
+
  protected:
   // QuicSession methods:
   QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override;
 
  private:
   friend class test::QuicChromiumClientSessionPeer;
 
   typedef std::set<Observer*> ObserverSet;
   typedef std::list<StreamRequest*> StreamRequestQueue;
 
@@ skipping 29 matching lines @@
   // Notifies the factory that this session has been closed which will
   // delete |this|.
   void NotifyFactoryOfSessionClosed();
 
   void OnConnectTimeout();
 
   QuicServerId server_id_;
   bool require_confirmation_;
   scoped_ptr<QuicCryptoClientStream> crypto_stream_;
   QuicStreamFactory* stream_factory_;
-  scoped_ptr<DatagramClientSocket> socket_;
+  std::vector<scoped_ptr<DatagramClientSocket>> sockets_;
   TransportSecurityState* transport_security_state_;
   scoped_ptr<QuicServerInfo> server_info_;
   scoped_ptr<CertVerifyResult> cert_verify_result_;
   scoped_ptr<ct::CTVerifyResult> ct_verify_result_;
   std::string pinning_failure_log_;
   ObserverSet observers_;
   StreamRequestQueue stream_requests_;
   CompletionCallback callback_;
   size_t num_total_streams_;
   base::TaskRunner* task_runner_;
   BoundNetLog net_log_;
-  QuicPacketReader packet_reader_;
+  std::vector<scoped_ptr<QuicPacketReader>> packet_readers_;
   base::TimeTicks dns_resolution_end_time_;
   base::TimeTicks handshake_start_;  // Time the handshake was started.
   scoped_ptr<QuicConnectionLogger> logger_;
   // True when the session is going away, and streams may no longer be created
   // on this session. Existing stream will continue to be processed.
   bool going_away_;
   QuicDisabledReason disabled_reason_;
   base::WeakPtrFactory<QuicChromiumClientSession> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicChromiumClientSession);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CHROMIUM_CLIENT_SESSION_H_