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

net/quic/quic_stream_factory_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_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/test_data_directory.h"
@@ skipping 98 matching lines @@
 class MockQuicServerInfoFactory : public QuicServerInfoFactory {
  public:
   MockQuicServerInfoFactory() {}
   ~MockQuicServerInfoFactory() override {}
 
   QuicServerInfo* GetForServer(const QuicServerId& server_id) override {
     return new MockQuicServerInfo(server_id);
   }
 };
 
+class MockNetworkChangeNotifier : public NetworkChangeNotifier {
+ public:
+  MockNetworkChangeNotifier() : force_network_handles_supported_(false) {}
+
+  ConnectionType GetCurrentConnectionType() const override {
+    return CONNECTION_UNKNOWN;
+  }
+
+  void ForceNetworkHandlesSupported() {
+    force_network_handles_supported_ = true;
+  }
+
+  bool AreNetworkHandlesCurrentlySupported() const override {
+    return force_network_handles_supported_;
+  }
+
+  void SetConnectedNetworksList(NetworkList network_list) {
+    connected_networks_ = network_list;
+  }
+
+  void GetCurrentConnectedNetworks(NetworkList* network_list) const override {
+    network_list->clear();
+    *network_list = connected_networks_;
+  }
+
+ private:
+  bool force_network_handles_supported_;
+  NetworkChangeNotifier::NetworkList connected_networks_;
+};
+
+// Class to replace existing NetworkChangeNotifier singleton with a
+// MockNetworkChangeNotifier for a test. To use, simply create a
+// ScopedMockNetworkChangeNotifier object in the test.
+class ScopedMockNetworkChangeNotifier {
+ public:
+  ScopedMockNetworkChangeNotifier()
+      : mock_network_change_notifier_(nullptr),
+        disable_network_change_notifier_for_tests_(nullptr) {
+    // Disable existing NetworkChangeNotifier first, then create mock.
+    disable_network_change_notifier_for_tests_ =
+        new NetworkChangeNotifier::DisableForTest();
+    mock_network_change_notifier_ = new MockNetworkChangeNotifier();

[Ryan Hamilton, 2015/12/18 22:00:19]

I think you can initialize these in the initializer list instead of the body.

[Jana, 2015/12/21 23:10:19]

Done.

+  }
+
+  ~ScopedMockNetworkChangeNotifier() {
+    delete mock_network_change_notifier_;
+    delete disable_network_change_notifier_for_tests_;

[Ryan Hamilton, 2015/12/18 22:00:19]

Can you use a scoped_ptr<> instead of needing to explicitly delete them?

[Jana, 2015/12/21 23:10:19]

Done.

+  }
+
+  MockNetworkChangeNotifier* mock_network_change_notifier() {
+    return mock_network_change_notifier_;
+  }
+
+ private:
+  MockNetworkChangeNotifier* mock_network_change_notifier_;
+  NetworkChangeNotifier::DisableForTest*
+      disable_network_change_notifier_for_tests_;
+};
+
 class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
  protected:
   QuicStreamFactoryTest()
       : random_generator_(0),
         clock_(new MockClock()),
         runner_(new TestTaskRunner(clock_)),
         maker_(GetParam().version, 0, clock_, kDefaultServerHostName),
         cert_verifier_(CertVerifier::CreateDefault()),
         channel_id_service_(
             new ChannelIDService(new DefaultChannelIDStore(nullptr),
@@ skipping 12 matching lines @@
         prefer_aes_(false),
         max_number_of_lossy_connections_(0),
         packet_loss_threshold_(1.0f),
         max_disabled_reasons_(3),
         threshold_timeouts_with_open_streams_(2),
         threshold_public_resets_post_handshake_(2),
         receive_buffer_size_(0),
         delay_tcp_race_(false),
         store_server_configs_in_properties_(false),
         close_sessions_on_ip_change_(false),
-        idle_connection_timeout_seconds_(kIdleConnectionTimeoutSeconds) {
+        idle_connection_timeout_seconds_(kIdleConnectionTimeoutSeconds),
+        migrate_sessions_on_network_change_(false) {
     clock_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
   }
 
   void Initialize() {
     factory_.reset(new QuicStreamFactory(
         &host_resolver_, &socket_factory_, http_server_properties_.GetWeakPtr(),
         cert_verifier_.get(), nullptr, channel_id_service_.get(),
         &transport_security_state_, cert_transparency_verifier_.get(),
         /*SocketPerformanceWatcherFactory*/ nullptr,
         &crypto_client_stream_factory_, &random_generator_, clock_,
         kDefaultMaxPacketSize, std::string(),
         SupportedVersions(GetParam().version), enable_port_selection_,
         always_require_handshake_confirmation_, disable_connection_pooling_,
         load_server_info_timeout_srtt_multiplier_, enable_connection_racing_,
         enable_non_blocking_io_, disable_disk_cache_, prefer_aes_,
         max_number_of_lossy_connections_, packet_loss_threshold_,
         max_disabled_reasons_, threshold_timeouts_with_open_streams_,
         threshold_public_resets_post_handshake_, receive_buffer_size_,
         delay_tcp_race_, store_server_configs_in_properties_,
         close_sessions_on_ip_change_, idle_connection_timeout_seconds_,
-        QuicTagVector()));
+        migrate_sessions_on_network_change_, QuicTagVector()));
     factory_->set_require_confirmation(false);
     factory_->set_quic_server_info_factory(new MockQuicServerInfoFactory());
   }
 
   bool HasActiveSession(const HostPortPair& host_port_pair) {
     return QuicStreamFactoryPeer::HasActiveSession(factory_.get(),
                                                    host_port_pair);
   }
 
   scoped_ptr<QuicHttpStream> CreateFromSession(
@@ skipping 84 matching lines @@
     return verify_details;
   }
 
   void NotifyIPAddressChanged() {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     // For thread safety, the NCN queues tasks to do the actual notifications,
     // so we need to spin the message loop so the notification is delivered.
     base::MessageLoop::current()->RunUntilIdle();
   }
 
+  void NotifySpecificNetworkChange(
+      NetworkChangeNotifier::NetworkChangeType type,
+      NetworkChangeNotifier::NetworkHandle network) {
+    NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChangeForTests(
+        type, network);
+    // For thread safety, the NCN queues tasks to do the actual notifications,

[Ryan Hamilton, 2015/12/18 22:00:19]

I'd remove the first part of this (about thread safety) and just say:

// Spin the message loop so notifications are delivered.

Or actually, that method you're calling is ForTests(). Can it just spin the
message loop for you?

[Jana, 2015/12/21 23:10:19]

I'm following the same pattern as is done with delivering NCN notifications for
tests elsewhere as well. (I've modified the comment there too)

+    // so we need to spin the message loop so the notification is delivered.
+    base::MessageLoop::current()->RunUntilIdle();
+  }
+
   MockHostResolver host_resolver_;
   DeterministicMockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockRandom random_generator_;
   MockClock* clock_;  // Owned by factory_.
   scoped_refptr<TestTaskRunner> runner_;
   QuicTestPacketMaker maker_;
   HttpServerPropertiesImpl http_server_properties_;
   scoped_ptr<CertVerifier> cert_verifier_;
   scoped_ptr<ChannelIDService> channel_id_service_;
@@ skipping 17 matching lines @@
   int max_number_of_lossy_connections_;
   double packet_loss_threshold_;
   int max_disabled_reasons_;
   int threshold_timeouts_with_open_streams_;
   int threshold_public_resets_post_handshake_;
   int receive_buffer_size_;
   bool delay_tcp_race_;
   bool store_server_configs_in_properties_;
   bool close_sessions_on_ip_change_;
   int idle_connection_timeout_seconds_;
+  bool migrate_sessions_on_network_change_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version,
                         QuicStreamFactoryTest,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(QuicStreamFactoryTest, Create) {
   Initialize();
 
   MockRead reads[] = {
@@ skipping 962 matching lines @@
   EXPECT_EQ(OK, callback_.WaitForResult());
   stream = request2.ReleaseStream();
   stream.reset();  // Will reset stream 3.
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 }
 
+TEST_P(QuicStreamFactoryTest, OnNetworkChange) {

[Ryan Hamilton, 2015/12/18 22:00:19]

Does this test all of the various combinations? Active streams vs no active
streams. New network vs no new network, etc...

[Jana, 2015/12/21 23:10:19]

No it doesn't. I had meant to add them before sending out for review, but
clearly I didn't. I'll add them in the spit out CL.

+  ScopedMockNetworkChangeNotifier scoped_mock_ncn;
+  MockNetworkChangeNotifier* mock_ncn =
+      scoped_mock_ncn.mock_network_change_notifier();
+  mock_ncn->ForceNetworkHandlesSupported();
+  NetworkChangeNotifier::NetworkList connected_networks = {1, 2};
+  mock_ncn->SetConnectedNetworksList(connected_networks);
+
+  migrate_sessions_on_network_change_ = true;
+  Initialize();
+
+  // Set up first socket data provider
+  MockRead reads[] = {
+      MockRead(ASYNC, OK, 0)  // EOF
+  };
+
+  DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
+  socket_data.StopAfter(1);
+  socket_factory_.AddSocketDataProvider(&socket_data);
+
+  // Set up second socket data provider that is used after migration.
+  MockRead reads1[] = {
+      MockRead(ASYNC, OK, 0)  // EOF
+  };
+  scoped_ptr<QuicEncryptedPacket> ping(
+      maker_.MakePingPacket(1, /*include_version=*/true));
+  MockWrite writes1[] = {
+      MockWrite(ASYNC, ping->data(), ping->length(), 1),
+  };
+  DeterministicSocketData socket_data1(reads1, arraysize(reads1), writes1,
+                                       arraysize(writes1));
+  socket_data1.StopAfter(1);
+  socket_factory_.AddSocketDataProvider(&socket_data1);
+
+  // Create request and QuicHttpStream.
+  QuicStreamRequest request(factory_.get());
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_pair_, privacy_mode_,
+                            /*cert_verify_flags=*/0, host_port_pair_.host(),
+                            "GET", net_log_, callback_.callback()));
+
+  EXPECT_EQ(OK, callback_.WaitForResult());
+  scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
+  EXPECT_TRUE(stream.get());
+
+  // Cause QUIC stream to be created.
+  HttpRequestInfo request_info;
+  EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
+                                         net_log_, CompletionCallback()));
+
+  // Ensure that session is alive and active.
+  QuicChromiumClientSession* session =
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+
+  // Cause connection migration to happen. This should cause a PING frame
+  // to be emitted.
+  NotifySpecificNetworkChange(NetworkChangeNotifier::SOON_TO_DISCONNECT, 1);
+
+  // The session should now be marked as going away. Ensure that
+  // while it is still alive, it is no longer active.
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_FALSE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  // Create a new request for the same destination and verify that a
+  // new session is created.
+  MockRead reads2[] = {
+      MockRead(ASYNC, OK, 0)  // EOF
+  };
+  DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
+  socket_data2.StopAfter(1);
+  socket_factory_.AddSocketDataProvider(&socket_data2);
+  QuicStreamRequest request2(factory_.get());
+  EXPECT_EQ(ERR_IO_PENDING,
+            request2.Request(host_port_pair_, privacy_mode_,
+                             /*cert_verify_flags=*/0, host_port_pair_.host(),
+                             "GET", net_log_, callback_.callback()));
+  EXPECT_EQ(OK, callback_.WaitForResult());
+  scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
+  EXPECT_TRUE(stream2.get());
+
+  EXPECT_TRUE(
+      QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
+  EXPECT_NE(session, QuicStreamFactoryPeer::GetActiveSession(factory_.get(),
+                                                             host_port_pair_));
+  EXPECT_EQ(true,
+            QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data2.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
+}
+
 TEST_P(QuicStreamFactoryTest, OnSSLConfigChanged) {
   Initialize();
   MockRead reads[] = {
       MockRead(ASYNC, 0, 0)  // EOF
   };
   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
   std::vector<MockWrite> writes;
   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
   DeterministicSocketData socket_data(reads, arraysize(reads),
                                       writes.empty() ? nullptr : &writes[0],
@@ skipping 1426 matching lines @@
   EXPECT_EQ(1u, observer.executed_count());
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 }  // namespace test
 }  // namespace net