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

net/quic/quic_chromium_client_session_test.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 <vector>
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/rand_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/socket_performance_watcher.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/http/transport_security_state.h"
 #include "net/log/test_net_log.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/proof_verifier_chromium.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_server_info.h"
+#include "net/quic/quic_connection_helper.h"
 #include "net/quic/quic_crypto_client_stream_factory.h"
+#include "net/quic/quic_default_packet_writer.h"
 #include "net/quic/quic_flags.h"
+#include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_packet_reader.h"
+#include "net/quic/quic_packet_writer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
+#include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
 #include "net/quic/test_tools/quic_chromium_client_session_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
+#include "net/quic/test_tools/quic_test_packet_maker.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simple_quic_framer.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/test/cert_test_util.h"
 #include "net/udp/datagram_client_socket.h"
 
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
 
+const IPEndPoint kIpEndPoint(IPAddressNumber(kIPv4AddressSize, 0), 0);
 const char kServerHostname[] = "test.example.com";
 const uint16_t kServerPort = 443;
+const size_t kMaxReadersPerQuicSession = 5;
+
+class DefaultPacketWriterFactory : public QuicConnection::PacketWriterFactory {
+ public:
+  explicit DefaultPacketWriterFactory(DatagramClientSocket* socket)
+      : socket_(socket) {}
+  ~DefaultPacketWriterFactory() override {}
+
+  QuicPacketWriter* Create(QuicConnection* connection) const override {
+    scoped_ptr<net::QuicDefaultPacketWriter> writer(
+        new net::QuicDefaultPacketWriter(socket_));
+    writer->SetConnection(connection);
+    return writer.release();
+  }
+
+ private:
+  DatagramClientSocket* socket_;
+};
 
 class QuicChromiumClientSessionTest
     : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicChromiumClientSessionTest()
       : crypto_config_(CryptoTestUtils::ProofVerifierForTesting()),
-        connection_(new PacketSavingConnection(&helper_,
-                                               Perspective::IS_CLIENT,
-                                               SupportedVersions(GetParam()))),
-        session_(
-            connection_,
-            GetSocket(),
-            /*stream_factory=*/nullptr,
-            QuicCryptoClientStreamFactory::GetDefaultFactory(),
-            &clock_,
-            &transport_security_state_,
-            make_scoped_ptr((QuicServerInfo*)nullptr),
-            QuicServerId(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED),
-            kQuicYieldAfterPacketsRead,
-            QuicTime::Delta::FromMilliseconds(
-                kQuicYieldAfterDurationMilliseconds),
-            /*cert_verify_flags=*/0,
-            DefaultQuicConfig(),
-            &crypto_config_,
-            "CONNECTION_UNKNOWN",
-            base::TimeTicks::Now(),
-            base::ThreadTaskRunnerHandle::Get().get(),
-            /*socket_performance_watcher=*/nullptr,
-            &net_log_) {
-    session_.Initialize();
+        default_read_(new MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)),
+        socket_data_(
+            new SequencedSocketData(default_read_.get(), 1, nullptr, 0)),
+        random_(0),
+        helper_(base::ThreadTaskRunnerHandle::Get().get(), &clock_, &random_),
+        maker_(GetParam(), 0, &clock_, kServerHostname) {}
+
+  void Initialize() {
+    socket_factory_.AddSocketDataProvider(socket_data_.get());
+    scoped_ptr<DatagramClientSocket> socket =
+        socket_factory_.CreateDatagramClientSocket(DatagramSocket::DEFAULT_BIND,
+                                                   base::Bind(&base::RandInt),
+                                                   &net_log_, NetLog::Source());
+    socket->Connect(kIpEndPoint);
+    DefaultPacketWriterFactory writer_factory(socket.get());
+    QuicConnection* connection = new QuicConnection(
+        0, kIpEndPoint, &helper_, writer_factory, true, Perspective::IS_CLIENT,
+        SupportedVersions(GetParam()));
+    session_.reset(new QuicChromiumClientSession(
+        connection, std::move(socket),
+        /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
+        &transport_security_state_, make_scoped_ptr((QuicServerInfo*)nullptr),
+        QuicServerId(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED),
+        kQuicYieldAfterPacketsRead,
+        QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
+        /*cert_verify_flags=*/0, DefaultQuicConfig(), &crypto_config_,
+        "CONNECTION_UNKNOWN", base::TimeTicks::Now(),
+        base::ThreadTaskRunnerHandle::Get().get(),
+        /*socket_performance_watcher=*/nullptr, &net_log_));
+
+    scoped_refptr<X509Certificate> cert(
+        ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
+    verify_details_.cert_verify_result.verified_cert = cert;
+    verify_details_.cert_verify_result.is_issued_by_known_root = true;
     // Advance the time, because timers do not like uninitialized times.
-    connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
+    clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+    session_->Initialize();
+    session_->StartReading();
   }
 
   void TearDown() override {
-    session_.CloseSessionOnError(ERR_ABORTED, QUIC_INTERNAL_ERROR);
-  }
-
-  scoped_ptr<DatagramClientSocket> GetSocket() {
-    socket_factory_.AddSocketDataProvider(&socket_data_);
-    return socket_factory_.CreateDatagramClientSocket(
-        DatagramSocket::DEFAULT_BIND, base::Bind(&base::RandInt), &net_log_,
-        NetLog::Source());
+    session_->CloseSessionOnError(ERR_ABORTED, QUIC_INTERNAL_ERROR);
   }
 
   void CompleteCryptoHandshake() {
-    ASSERT_EQ(ERR_IO_PENDING,
-              session_.CryptoConnect(false, callback_.callback()));
-    CryptoTestUtils::FakeServerOptions server_options;
-    CryptoTestUtils::HandshakeWithFakeServer(
-        &helper_, connection_, session_.GetCryptoStream(), server_options);
-    ASSERT_EQ(OK, callback_.WaitForResult());
+    ASSERT_EQ(OK, session_->CryptoConnect(false, callback_.callback()));
   }
 
-  MockConnectionHelper helper_;
+  QuicPacketWriter* CreateQuicPacketWriter(DatagramClientSocket* socket,
+                                           QuicConnection* connection) const {
+    scoped_ptr<QuicDefaultPacketWriter> writer(
+        new QuicDefaultPacketWriter(socket));
+    writer->SetConnection(connection);
+    return writer.release();
+  }
+
   QuicCryptoClientConfig crypto_config_;
-  PacketSavingConnection* connection_;
   TestNetLog net_log_;
+  BoundTestNetLog bound_net_log_;
   MockClientSocketFactory socket_factory_;
-  StaticSocketDataProvider socket_data_;
-  TransportSecurityState transport_security_state_;
-  QuicChromiumClientSession session_;
+  scoped_ptr<MockRead> default_read_;
+  scoped_ptr<SequencedSocketData> socket_data_;
   MockClock clock_;
   MockRandom random_;
+  QuicConnectionHelper helper_;
+  scoped_ptr<DefaultPacketWriterFactory> writer_factory_;
+  TransportSecurityState transport_security_state_;
+  MockCryptoClientStreamFactory crypto_client_stream_factory_;
+  scoped_ptr<QuicChromiumClientSession> session_;
   QuicConnectionVisitorInterface* visitor_;
   TestCompletionCallback callback_;
+  QuicTestPacketMaker maker_;
+  ProofVerifyDetailsChromium verify_details_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicChromiumClientSessionTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicChromiumClientSessionTest, CryptoConnect) {
+  Initialize();
   CompleteCryptoHandshake();
 }
 
 TEST_P(QuicChromiumClientSessionTest, MaxNumStreams) {
+  MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
+  scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+      1, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
+  MockWrite writes[] = {
+      MockWrite(ASYNC, client_rst->data(), client_rst->length(), 1)};
+  socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes,
+                                             arraysize(writes)));
+
+  Initialize();
   CompleteCryptoHandshake();
+  const size_t kMaxOpenStreams = session_->get_max_open_streams();
 
   std::vector<QuicReliableClientStream*> streams;
-  for (size_t i = 0; i < kDefaultMaxStreamsPerConnection; i++) {
+  for (size_t i = 0; i < kMaxOpenStreams; i++) {
     QuicReliableClientStream* stream =
-        session_.CreateOutgoingDynamicStream(kDefaultPriority);
+        session_->CreateOutgoingDynamicStream(kDefaultPriority);
     EXPECT_TRUE(stream);
     streams.push_back(stream);
   }
-  EXPECT_FALSE(session_.CreateOutgoingDynamicStream(kDefaultPriority));
+  EXPECT_FALSE(session_->CreateOutgoingDynamicStream(kDefaultPriority));
 
-  EXPECT_EQ(kDefaultMaxStreamsPerConnection,
-            session_.GetNumOpenOutgoingStreams());
+  EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
 
   // Close a stream and ensure I can now open a new one.
   QuicStreamId stream_id = streams[0]->id();
-  session_.CloseStream(stream_id);
+  session_->CloseStream(stream_id);
 
-  EXPECT_FALSE(session_.CreateOutgoingDynamicStream(kDefaultPriority));
+  EXPECT_FALSE(session_->CreateOutgoingDynamicStream(kDefaultPriority));
   QuicRstStreamFrame rst1(stream_id, QUIC_STREAM_NO_ERROR, 0);
-  session_.OnRstStream(rst1);
-  EXPECT_EQ(kDefaultMaxStreamsPerConnection - 1,
-            session_.GetNumOpenOutgoingStreams());
-  EXPECT_TRUE(session_.CreateOutgoingDynamicStream(kDefaultPriority));
+  session_->OnRstStream(rst1);
+  EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumOpenOutgoingStreams());
+  EXPECT_TRUE(session_->CreateOutgoingDynamicStream(kDefaultPriority));
 }
 
 TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) {
+  MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
+  scoped_ptr<QuicEncryptedPacket> client_rst(maker_.MakeRstPacket(
+      1, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT));
+  MockWrite writes[] = {
+      MockWrite(ASYNC, client_rst->data(), client_rst->length(), 1)};
+  socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes,
+                                             arraysize(writes)));
+
+  Initialize();
   CompleteCryptoHandshake();
+  const size_t kMaxOpenStreams = session_->get_max_open_streams();
 
   std::vector<QuicReliableClientStream*> streams;
-  for (size_t i = 0; i < kDefaultMaxStreamsPerConnection; i++) {
+  for (size_t i = 0; i < kMaxOpenStreams; i++) {
     QuicReliableClientStream* stream =
-        session_.CreateOutgoingDynamicStream(kDefaultPriority);
+        session_->CreateOutgoingDynamicStream(kDefaultPriority);
     EXPECT_TRUE(stream);
     streams.push_back(stream);
   }
 
   QuicReliableClientStream* stream;
   QuicChromiumClientSession::StreamRequest stream_request;
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING,
-            stream_request.StartRequest(session_.GetWeakPtr(), &stream,
+            stream_request.StartRequest(session_->GetWeakPtr(), &stream,
                                         callback.callback()));
 
   // Close a stream and ensure I can now open a new one.
   QuicStreamId stream_id = streams[0]->id();
-  session_.CloseStream(stream_id);
+  session_->CloseStream(stream_id);
   QuicRstStreamFrame rst1(stream_id, QUIC_STREAM_NO_ERROR, 0);
-  session_.OnRstStream(rst1);
+  session_->OnRstStream(rst1);
   ASSERT_TRUE(callback.have_result());
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(stream != nullptr);
 }
 
 TEST_P(QuicChromiumClientSessionTest, GoAwayReceived) {
+  Initialize();
   CompleteCryptoHandshake();
 
   // After receiving a GoAway, I should no longer be able to create outgoing
   // streams.
-  session_.connection()->OnGoAwayFrame(
+  session_->connection()->OnGoAwayFrame(
       QuicGoAwayFrame(QUIC_PEER_GOING_AWAY, 1u, "Going away."));
-  EXPECT_EQ(nullptr, session_.CreateOutgoingDynamicStream(kDefaultPriority));
+  EXPECT_EQ(nullptr, session_->CreateOutgoingDynamicStream(kDefaultPriority));
 }
 
 TEST_P(QuicChromiumClientSessionTest, CanPool) {
+  Initialize();
   // Load a cert that is valid for:
   //   www.example.org
   //   mail.example.org
   //   www.example.com
 
   ProofVerifyDetailsChromium details;
   details.cert_verify_result.verified_cert =
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
   ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
 
   CompleteCryptoHandshake();
-  session_.OnProofVerifyDetailsAvailable(details);
+  session_->OnProofVerifyDetailsAvailable(details);
 
-  EXPECT_TRUE(session_.CanPool("www.example.org", PRIVACY_MODE_DISABLED));
-  EXPECT_FALSE(session_.CanPool("www.example.org", PRIVACY_MODE_ENABLED));
-  EXPECT_TRUE(session_.CanPool("mail.example.org", PRIVACY_MODE_DISABLED));
-  EXPECT_TRUE(session_.CanPool("mail.example.com", PRIVACY_MODE_DISABLED));
-  EXPECT_FALSE(session_.CanPool("mail.google.com", PRIVACY_MODE_DISABLED));
+  EXPECT_TRUE(session_->CanPool("www.example.org", PRIVACY_MODE_DISABLED));
+  EXPECT_FALSE(session_->CanPool("www.example.org", PRIVACY_MODE_ENABLED));
+  EXPECT_TRUE(session_->CanPool("mail.example.org", PRIVACY_MODE_DISABLED));
+  EXPECT_TRUE(session_->CanPool("mail.example.com", PRIVACY_MODE_DISABLED));
+  EXPECT_FALSE(session_->CanPool("mail.google.com", PRIVACY_MODE_DISABLED));
 }
 
 TEST_P(QuicChromiumClientSessionTest, ConnectionPooledWithTlsChannelId) {
+  Initialize();
   // Load a cert that is valid for:
   //   www.example.org
   //   mail.example.org
   //   www.example.com
 
   ProofVerifyDetailsChromium details;
   details.cert_verify_result.verified_cert =
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
   ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
 
   CompleteCryptoHandshake();
-  session_.OnProofVerifyDetailsAvailable(details);
-  QuicChromiumClientSessionPeer::SetHostname(&session_, "www.example.org");
-  QuicChromiumClientSessionPeer::SetChannelIDSent(&session_, true);
+  session_->OnProofVerifyDetailsAvailable(details);
+  QuicChromiumClientSessionPeer::SetHostname(session_.get(), "www.example.org");
+  QuicChromiumClientSessionPeer::SetChannelIDSent(session_.get(), true);
 
-  EXPECT_TRUE(session_.CanPool("www.example.org", PRIVACY_MODE_DISABLED));
-  EXPECT_TRUE(session_.CanPool("mail.example.org", PRIVACY_MODE_DISABLED));
-  EXPECT_FALSE(session_.CanPool("mail.example.com", PRIVACY_MODE_DISABLED));
-  EXPECT_FALSE(session_.CanPool("mail.google.com", PRIVACY_MODE_DISABLED));
+  EXPECT_TRUE(session_->CanPool("www.example.org", PRIVACY_MODE_DISABLED));
+  EXPECT_TRUE(session_->CanPool("mail.example.org", PRIVACY_MODE_DISABLED));
+  EXPECT_FALSE(session_->CanPool("mail.example.com", PRIVACY_MODE_DISABLED));
+  EXPECT_FALSE(session_->CanPool("mail.google.com", PRIVACY_MODE_DISABLED));
 }
 
 TEST_P(QuicChromiumClientSessionTest, ConnectionNotPooledWithDifferentPin) {
+  Initialize();
+
   uint8_t primary_pin = 1;
   uint8_t backup_pin = 2;
   uint8_t bad_pin = 3;
   AddPin(&transport_security_state_, "mail.example.org", primary_pin,
          backup_pin);
 
   ProofVerifyDetailsChromium details;
   details.cert_verify_result.verified_cert =
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
   details.cert_verify_result.is_issued_by_known_root = true;
   details.cert_verify_result.public_key_hashes.push_back(
       GetTestHashValue(bad_pin));
 
   ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
 
   CompleteCryptoHandshake();
-  session_.OnProofVerifyDetailsAvailable(details);
-  QuicChromiumClientSessionPeer::SetHostname(&session_, "www.example.org");
-  QuicChromiumClientSessionPeer::SetChannelIDSent(&session_, true);
+  session_->OnProofVerifyDetailsAvailable(details);
+  QuicChromiumClientSessionPeer::SetHostname(session_.get(), "www.example.org");
+  QuicChromiumClientSessionPeer::SetChannelIDSent(session_.get(), true);
 
-  EXPECT_FALSE(session_.CanPool("mail.example.org", PRIVACY_MODE_DISABLED));
+  EXPECT_FALSE(session_->CanPool("mail.example.org", PRIVACY_MODE_DISABLED));
 }
 
 TEST_P(QuicChromiumClientSessionTest, ConnectionPooledWithMatchingPin) {
+  Initialize();
+
   uint8_t primary_pin = 1;
   uint8_t backup_pin = 2;
   AddPin(&transport_security_state_, "mail.example.org", primary_pin,
          backup_pin);
 
   ProofVerifyDetailsChromium details;
   details.cert_verify_result.verified_cert =
       ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
   details.cert_verify_result.is_issued_by_known_root = true;
   details.cert_verify_result.public_key_hashes.push_back(
       GetTestHashValue(primary_pin));
 
   ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
 
   CompleteCryptoHandshake();
-  session_.OnProofVerifyDetailsAvailable(details);
-  QuicChromiumClientSessionPeer::SetHostname(&session_, "www.example.org");
-  QuicChromiumClientSessionPeer::SetChannelIDSent(&session_, true);
-
-  EXPECT_TRUE(session_.CanPool("mail.example.org", PRIVACY_MODE_DISABLED));
+  session_->OnProofVerifyDetailsAvailable(details);
+  QuicChromiumClientSessionPeer::SetHostname(session_.get(), "www.example.org");
+  QuicChromiumClientSessionPeer::SetChannelIDSent(session_.get(), true);
+
+  EXPECT_TRUE(session_->CanPool("mail.example.org", PRIVACY_MODE_DISABLED));
+}
+
+TEST_P(QuicChromiumClientSessionTest, MigrateToSocket) {
+  Initialize();
+  CompleteCryptoHandshake();
+
+  char data[] = "ABCD";
+  scoped_ptr<QuicEncryptedPacket> ping(
+      maker_.MakePingPacket(1, /*include_version=*/false));
+  scoped_ptr<QuicEncryptedPacket> ack_and_data_out(maker_.MakeAckAndDataPacket(
+      2, false, 5, 1, 1, false, 0, StringPiece(data)));
+  MockRead reads[] = {MockRead(SYNCHRONOUS, ping->data(), ping->length(), 0),
+                      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 1)};
+  MockWrite writes[] = {MockWrite(SYNCHRONOUS, ping->data(), ping->length(), 2),
+                        MockWrite(SYNCHRONOUS, ack_and_data_out->data(),
+                                  ack_and_data_out->length(), 3)};
+  StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
+                                       arraysize(writes));
+  socket_factory_.AddSocketDataProvider(&socket_data);
+
+  // Create connected socket.
+  scoped_ptr<DatagramClientSocket> new_socket =
+      socket_factory_.CreateDatagramClientSocket(DatagramSocket::DEFAULT_BIND,
+                                                 base::Bind(&base::RandInt),
+                                                 &net_log_, NetLog::Source());
+  EXPECT_EQ(OK, new_socket->Connect(kIpEndPoint));
+
+  // Create reader and writer.
+  scoped_ptr<QuicPacketReader> new_reader(new QuicPacketReader(
+      new_socket.get(), &clock_, session_.get(), kQuicYieldAfterPacketsRead,
+      QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
+      bound_net_log_.bound()));
+  scoped_ptr<QuicPacketWriter> new_writer(
+      CreateQuicPacketWriter(new_socket.get(), session_->connection()));
+
+  // Migrate session.
+  EXPECT_TRUE(session_->MigrateToSocket(
+      std::move(new_socket), std::move(new_reader), std::move(new_writer)));
+
+  // Write data to session.
+  struct iovec iov[1];
+  iov[0].iov_base = data;
+  iov[0].iov_len = 4;
+  session_->WritevData(5, QuicIOVector(iov, arraysize(iov), 4), 0, false,
+                       MAY_FEC_PROTECT, nullptr);
+
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+}
+
+TEST_P(QuicChromiumClientSessionTest, MigrateToSocketMaxReaders) {
+  Initialize();
+  CompleteCryptoHandshake();
+
+  for (size_t i = 0; i < kMaxReadersPerQuicSession; ++i) {
+    MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 1)};
+    scoped_ptr<QuicEncryptedPacket> ping_out(
+        maker_.MakePingPacket(i + 1, /*include_version=*/true));
+    MockWrite writes[] = {
+        MockWrite(SYNCHRONOUS, ping_out->data(), ping_out->length(), i + 2)};
+    StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
+                                         arraysize(writes));
+    socket_factory_.AddSocketDataProvider(&socket_data);
+
+    // Create connected socket.
+    scoped_ptr<DatagramClientSocket> new_socket =
+        socket_factory_.CreateDatagramClientSocket(DatagramSocket::DEFAULT_BIND,
+                                                   base::Bind(&base::RandInt),
+                                                   &net_log_, NetLog::Source());
+    EXPECT_EQ(OK, new_socket->Connect(kIpEndPoint));
+
+    // Create reader and writer.
+    scoped_ptr<QuicPacketReader> new_reader(new QuicPacketReader(
+        new_socket.get(), &clock_, session_.get(), kQuicYieldAfterPacketsRead,
+        QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
+        bound_net_log_.bound()));
+    scoped_ptr<QuicPacketWriter> new_writer(
+        CreateQuicPacketWriter(new_socket.get(), session_->connection()));
+
+    // Migrate session.
+    if (i < kMaxReadersPerQuicSession - 1) {
+      EXPECT_TRUE(session_->MigrateToSocket(
+          std::move(new_socket), std::move(new_reader), std::move(new_writer)));
+      EXPECT_TRUE(socket_data.AllReadDataConsumed());
+      EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+    } else {
+      // Max readers exceeded.
+      EXPECT_FALSE(session_->MigrateToSocket(
+          std::move(new_socket), std::move(new_reader), std::move(new_writer)));
+
+      EXPECT_FALSE(socket_data.AllReadDataConsumed());
+      EXPECT_FALSE(socket_data.AllWriteDataConsumed());
+    }
+  }
+}
+
+TEST_P(QuicChromiumClientSessionTest, MigrateToSocketReadError) {
+  scoped_ptr<QuicEncryptedPacket> ping(
+      maker_.MakePingPacket(1, /*include_version=*/true));
+  MockRead old_reads[] = {
+      MockRead(SYNCHRONOUS, ping->data(), ping->length(), 0),
+      MockRead(ASYNC, ERR_IO_PENDING, 1),  // causes reading to pause.
+      MockRead(ASYNC, ERR_NETWORK_CHANGED, 2)};
+  socket_data_.reset(
+      new SequencedSocketData(old_reads, arraysize(old_reads), nullptr, 0));
+  Initialize();
+  CompleteCryptoHandshake();
+
+  MockWrite writes[] = {
+      MockWrite(SYNCHRONOUS, ping->data(), ping->length(), 1)};
+  MockRead new_reads[] = {
+      MockRead(SYNCHRONOUS, ping->data(), ping->length(), 0),
+      MockRead(ASYNC, ERR_IO_PENDING, 2),  // pause reading.
+      MockRead(ASYNC, ping->data(), ping->length(), 3),
+      MockRead(ASYNC, ERR_IO_PENDING, 4),  // pause reading
+      MockRead(ASYNC, ERR_NETWORK_CHANGED, 5)};
+  SequencedSocketData new_socket_data(new_reads, arraysize(new_reads), writes,
+                                      arraysize(writes));
+  socket_factory_.AddSocketDataProvider(&new_socket_data);
+
+  // Create connected socket.
+  scoped_ptr<DatagramClientSocket> new_socket =
+      socket_factory_.CreateDatagramClientSocket(DatagramSocket::DEFAULT_BIND,
+                                                 base::Bind(&base::RandInt),
+                                                 &net_log_, NetLog::Source());
+  EXPECT_EQ(OK, new_socket->Connect(kIpEndPoint));
+
+  // Create reader and writer.
+  scoped_ptr<QuicPacketReader> new_reader(new QuicPacketReader(
+      new_socket.get(), &clock_, session_.get(), kQuicYieldAfterPacketsRead,
+      QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
+      bound_net_log_.bound()));
+  scoped_ptr<QuicPacketWriter> new_writer(
+      CreateQuicPacketWriter(new_socket.get(), session_->connection()));
+
+  // Store old socket and migrate session.

[Ryan Hamilton, 2016/01/12 20:13:00]

nit: I'd probably remove "Store old" since I think that describes what's
happening *in* MigrateToSocket?

[Jana, 2016/01/12 22:04:33]

Ah -- sorry left over comment. Removed.

+  EXPECT_TRUE(session_->MigrateToSocket(
+      std::move(new_socket), std::move(new_reader), std::move(new_writer)));
+
+  // Read error on old socket does not impact session.
+  EXPECT_TRUE(socket_data_->IsPaused());
+  socket_data_->Resume();
+  EXPECT_TRUE(session_->connection()->connected());
+  EXPECT_TRUE(new_socket_data.IsPaused());
+  new_socket_data.Resume();
+
+  // Read error on new socket causes session close.
+  EXPECT_TRUE(new_socket_data.IsPaused());
+  EXPECT_TRUE(session_->connection()->connected());
+  new_socket_data.Resume();
+  EXPECT_FALSE(session_->connection()->connected());
+
+  EXPECT_TRUE(socket_data_->AllReadDataConsumed());
+  EXPECT_TRUE(socket_data_->AllWriteDataConsumed());
+  EXPECT_TRUE(new_socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(new_socket_data.AllWriteDataConsumed());
+}

[Ryan Hamilton, 2016/01/12 20:13:01]

Great test!

I think we also need on which verifies that a read error on the old socket does
not close the connection.  It would be great if the test verified that it was
able to read data on the old socket after the migration, but then a read error
happened, and all was well.

[Jana, 2016/01/12 22:04:33]

As discussed offline, this is being verified in this test.

+
+TEST_P(QuicChromiumClientSessionTest, MigrateToSocketWriteError) {
+  Initialize();
+  CompleteCryptoHandshake();
+
+  scoped_ptr<QuicEncryptedPacket> ping(
+      maker_.MakePingPacket(1, /*include_version=*/true));
+  MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
+  MockWrite writes[] = {MockWrite(SYNCHRONOUS, ping->data(), ping->length(), 1),
+                        MockWrite(SYNCHRONOUS, ERR_FAILED, 2)};
+  SequencedSocketData socket_data(reads, arraysize(reads), writes,
+                                  arraysize(writes));
+  socket_factory_.AddSocketDataProvider(&socket_data);
+
+  // Create connected socket.
+  scoped_ptr<DatagramClientSocket> new_socket =
+      socket_factory_.CreateDatagramClientSocket(DatagramSocket::DEFAULT_BIND,
+                                                 base::Bind(&base::RandInt),
+                                                 &net_log_, NetLog::Source());
+  EXPECT_EQ(OK, new_socket->Connect(kIpEndPoint));
+
+  // Create reader and writer.
+  scoped_ptr<QuicPacketReader> new_reader(new QuicPacketReader(
+      new_socket.get(), &clock_, session_.get(), kQuicYieldAfterPacketsRead,
+      QuicTime::Delta::FromMilliseconds(kQuicYieldAfterDurationMilliseconds),
+      bound_net_log_.bound()));
+  scoped_ptr<QuicPacketWriter> new_writer(
+      CreateQuicPacketWriter(new_socket.get(), session_->connection()));
+
+  // Store old socket and migrate session.
+  EXPECT_TRUE(session_->MigrateToSocket(
+      std::move(new_socket), std::move(new_reader), std::move(new_writer)));
+
+  // Write error on new socket causes session close.
+  EXPECT_TRUE(session_->connection()->connected());
+  session_->connection()->SendPing(/*force=*/true);
+  EXPECT_FALSE(session_->connection()->connected());
+
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net