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()))),
+        socket_(GetSocket()),
+        random_(0),
+        helper_(base::ThreadTaskRunnerHandle::Get().get(), &clock_, &random_),
+        writer_factory_(socket_.get()),
+        connection_(new QuicConnection(0,
+                                       kIpEndPoint,
+                                       &helper_,
+                                       writer_factory_,
+                                       true,
+                                       Perspective::IS_CLIENT,
+                                       SupportedVersions(GetParam()))),
         session_(
             connection_,
-            GetSocket(),
+            std::move(socket_),
             /*stream_factory=*/nullptr,
-            QuicCryptoClientStreamFactory::GetDefaultFactory(),
+            &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_) {
+            &net_log_),
+        maker_(GetParam(), 0, &clock_, kServerHostname) {
+    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.
+    clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
     session_.Initialize();
-    // Advance the time, because timers do not like uninitialized times.
-    connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
+    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());
+    reads_[0] = MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0);
+    socket_data_.reset(
+        new StaticSocketDataProvider(reads_, arraysize(reads_), nullptr, 0));
+    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);
+    return socket;
   }
 
   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_;
+  MockRead reads_[1];
+  scoped_ptr<StaticSocketDataProvider> socket_data_;
+  scoped_ptr<DatagramClientSocket> socket_;
   MockClock clock_;
   MockRandom random_;
+  QuicConnectionHelper helper_;
+  DefaultPacketWriterFactory writer_factory_;
+  QuicConnection* connection_;
+  TransportSecurityState transport_security_state_;
+  MockCryptoClientStreamFactory crypto_client_stream_factory_;
+  QuicChromiumClientSession session_;
   QuicConnectionVisitorInterface* visitor_;
   TestCompletionCallback callback_;
+  QuicTestPacketMaker maker_;
+  ProofVerifyDetailsChromium verify_details_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicChromiumClientSessionTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicChromiumClientSessionTest, CryptoConnect) {
   CompleteCryptoHandshake();
 }
 
 TEST_P(QuicChromiumClientSessionTest, MaxNumStreams) {
   CompleteCryptoHandshake();
+  const size_t kMaxOpenStreams = session_.get_max_open_streams();

[Ryan Hamilton, 2016/01/08 05:01:06]

What's the story with this change?

[Jana, 2016/01/09 02:06:54]

It's being set to kDefaultMaxNumStreams/2 in
MockCryptoClientStream::SetConfigNegotiated(), so when I added a mock cryptp
stream factory to the session, the session's max number of streams changed. I
figured since this test wasn't actually testing what the max was set to but that
the max was being respected, using the session's currently set max value made
more sense than a constant.

 
   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);
     EXPECT_TRUE(stream);
     streams.push_back(stream);
   }
   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);
 
   EXPECT_FALSE(session_.CreateOutgoingDynamicStream(kDefaultPriority));
   QuicRstStreamFrame rst1(stream_id, QUIC_STREAM_NO_ERROR, 0);
   session_.OnRstStream(rst1);
-  EXPECT_EQ(kDefaultMaxStreamsPerConnection - 1,
-            session_.GetNumOpenOutgoingStreams());
+  EXPECT_EQ(kMaxOpenStreams - 1, session_.GetNumOpenOutgoingStreams());
   EXPECT_TRUE(session_.CreateOutgoingDynamicStream(kDefaultPriority));
 }
 
 TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) {
   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);
     EXPECT_TRUE(stream);
     streams.push_back(stream);
   }
 
   QuicReliableClientStream* stream;
   QuicChromiumClientSession::StreamRequest stream_request;
   TestCompletionCallback callback;
   ASSERT_EQ(ERR_IO_PENDING,
@@ skipping 103 matching lines @@
   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));
 }
 
+TEST_P(QuicChromiumClientSessionTest, MigrateToSocket) {
+  CompleteCryptoHandshake();
+
+  char data[] = "ABCD";
+  scoped_ptr<QuicEncryptedPacket> ping_in(
+      maker_.MakePingPacket(1, /*include_version=*/false));
+  scoped_ptr<QuicEncryptedPacket> ping_out(
+      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_in->data(), ping_in->length(), 0),
+      MockRead(SYNCHRONOUS, ERR_IO_PENDING, 1)};
+  MockWrite writes[] = {
+      MockWrite(SYNCHRONOUS, ping_out->data(), ping_out->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_, 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) {
+  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_, 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());
+    }
+  }
+}

[Ryan Hamilton, 2016/01/08 05:01:06]

These tests look good! I think we also need to test read and write errors.
Errors on the old sockets are innocuous, but errors on the new sockets are
fatal, iirc.

+
 }  // namespace
 }  // namespace test
 }  // namespace net