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 159 matching lines @@
   // 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_; }
 
+  // Call to add a new socket to the session. Takes ownership of |socket|.
+  void AddSocket(scoped_ptr<DatagramClientSocket> socket);

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

Do we ever remove sockets? How shall we handle read/write errors?

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

We don't remove sockets at this point. This is why there's a max number of
sockets that we create. Since there's only one Writer at the moment, that error
processing shouldn't change. We maintain multiple readers however, and we need
to catch read errors. I'll do some work on figuring out how to catch
OnReadError.

+
+  // Call to add a new PacketReader to the session. Returns true if reader was
+  // successfully added to the session. Takes ownership of |reader|.
+  bool AddPacketReader(QuicPacketReader* reader);

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

Should this be a scoped_ptr?

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

Done.

+

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

It's a bit odd that we need a socket, reader and writer but only need to pass in
a reader and a socket. This is probably out of scope for this CL...

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

Fixed in the new version, PTAL.

  protected:
   // QuicSession methods:
   QuicDataStream* 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_;
   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_