OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/http/http_server_properties_manager.h" | 5 #include "net/http/http_server_properties_manager.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
11 #include "base/json/json_reader.h" | 11 #include "base/json/json_reader.h" |
12 #include "base/json/json_writer.h" | 12 #include "base/json/json_writer.h" |
13 #include "base/macros.h" | 13 #include "base/macros.h" |
14 #include "base/memory/ptr_util.h" | 14 #include "base/memory/ptr_util.h" |
15 #include "base/memory/ref_counted.h" | 15 #include "base/memory/ref_counted.h" |
16 #include "base/single_thread_task_runner.h" | 16 #include "base/single_thread_task_runner.h" |
17 #include "base/strings/string_number_conversions.h" | 17 #include "base/strings/string_number_conversions.h" |
18 #include "base/strings/stringprintf.h" | 18 #include "base/strings/stringprintf.h" |
19 #include "base/test/scoped_mock_time_message_loop_task_runner.h" | 19 #include "base/test/scoped_mock_time_message_loop_task_runner.h" |
20 #include "base/test/test_mock_time_task_runner.h" | 20 #include "base/test/test_mock_time_task_runner.h" |
21 #include "base/test/test_simple_task_runner.h" | 21 #include "base/test/test_simple_task_runner.h" |
22 #include "base/threading/thread_task_runner_handle.h" | 22 #include "base/threading/thread_task_runner_handle.h" |
23 #include "base/values.h" | 23 #include "base/values.h" |
24 #include "net/base/ip_address.h" | 24 #include "net/base/ip_address.h" |
| 25 #include "net/http/http_network_session.h" |
25 #include "testing/gmock/include/gmock/gmock.h" | 26 #include "testing/gmock/include/gmock/gmock.h" |
26 #include "testing/gtest/include/gtest/gtest.h" | 27 #include "testing/gtest/include/gtest/gtest.h" |
27 #include "url/gurl.h" | 28 #include "url/gurl.h" |
28 | 29 |
29 namespace net { | 30 namespace net { |
30 | 31 |
31 namespace { | 32 namespace { |
32 | 33 |
33 using base::StringPrintf; | 34 using base::StringPrintf; |
34 using base::TestMockTimeTaskRunner; | 35 using base::TestMockTimeTaskRunner; |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
156 // TODO(rtenneti): After we stop supporting version 3 and everyone has migrated | 157 // TODO(rtenneti): After we stop supporting version 3 and everyone has migrated |
157 // to version 4, delete the following code. | 158 // to version 4, delete the following code. |
158 static const int kHttpServerPropertiesVersions[] = {3, 4, 5}; | 159 static const int kHttpServerPropertiesVersions[] = {3, 4, 5}; |
159 | 160 |
160 class HttpServerPropertiesManagerTest : public testing::TestWithParam<int> { | 161 class HttpServerPropertiesManagerTest : public testing::TestWithParam<int> { |
161 protected: | 162 protected: |
162 HttpServerPropertiesManagerTest() = default; | 163 HttpServerPropertiesManagerTest() = default; |
163 | 164 |
164 void SetUp() override { | 165 void SetUp() override { |
165 one_day_from_now_ = base::Time::Now() + base::TimeDelta::FromDays(1); | 166 one_day_from_now_ = base::Time::Now() + base::TimeDelta::FromDays(1); |
| 167 advertised_versions_ = HttpNetworkSession::Params().quic_supported_versions; |
166 pref_delegate_ = new MockPrefDelegate; | 168 pref_delegate_ = new MockPrefDelegate; |
167 http_server_props_manager_.reset( | 169 http_server_props_manager_.reset( |
168 new StrictMock<TestingHttpServerPropertiesManager>( | 170 new StrictMock<TestingHttpServerPropertiesManager>( |
169 pref_delegate_, pref_test_task_runner_.task_runner(), | 171 pref_delegate_, pref_test_task_runner_.task_runner(), |
170 net_test_task_runner_)); | 172 net_test_task_runner_)); |
171 | 173 |
172 EXPECT_FALSE(http_server_props_manager_->IsInitialized()); | 174 EXPECT_FALSE(http_server_props_manager_->IsInitialized()); |
173 ExpectCacheUpdate(); | 175 ExpectCacheUpdate(); |
174 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 176 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
175 pref_test_task_runner_->RunUntilIdle(); | 177 pref_test_task_runner_->RunUntilIdle(); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
231 bool HasAlternativeService(const url::SchemeHostPort& server) { | 233 bool HasAlternativeService(const url::SchemeHostPort& server) { |
232 const AlternativeServiceInfoVector alternative_service_info_vector = | 234 const AlternativeServiceInfoVector alternative_service_info_vector = |
233 http_server_props_manager_->GetAlternativeServiceInfos(server); | 235 http_server_props_manager_->GetAlternativeServiceInfos(server); |
234 return !alternative_service_info_vector.empty(); | 236 return !alternative_service_info_vector.empty(); |
235 } | 237 } |
236 | 238 |
237 MockPrefDelegate* pref_delegate_; // Owned by HttpServerPropertiesManager. | 239 MockPrefDelegate* pref_delegate_; // Owned by HttpServerPropertiesManager. |
238 std::unique_ptr<TestingHttpServerPropertiesManager> | 240 std::unique_ptr<TestingHttpServerPropertiesManager> |
239 http_server_props_manager_; | 241 http_server_props_manager_; |
240 base::Time one_day_from_now_; | 242 base::Time one_day_from_now_; |
| 243 QuicVersionVector advertised_versions_; |
241 | 244 |
242 // Overrides the main thread's message loop with a mock tick clock. Making the | 245 // Overrides the main thread's message loop with a mock tick clock. Making the |
243 // main thread the |pref_test_task_runner_| matches expectations better than | 246 // main thread the |pref_test_task_runner_| matches expectations better than |
244 // having an independent TestMockTimeTaskRunner and makes tests easier to | 247 // having an independent TestMockTimeTaskRunner and makes tests easier to |
245 // write. | 248 // write. |
246 base::ScopedMockTimeMessageLoopTaskRunner pref_test_task_runner_; | 249 base::ScopedMockTimeMessageLoopTaskRunner pref_test_task_runner_; |
247 | 250 |
248 // Mock the net task runner as well. | 251 // Mock the net task runner as well. |
249 scoped_refptr<TestMockTimeTaskRunner> net_test_task_runner_ = | 252 scoped_refptr<TestMockTimeTaskRunner> net_test_task_runner_ = |
250 new TestMockTimeTaskRunner; | 253 new TestMockTimeTaskRunner; |
(...skipping 471 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
722 | 725 |
723 TEST_P(HttpServerPropertiesManagerTest, GetAlternativeServiceInfos) { | 726 TEST_P(HttpServerPropertiesManagerTest, GetAlternativeServiceInfos) { |
724 ExpectPrefsUpdate(1); | 727 ExpectPrefsUpdate(1); |
725 ExpectScheduleUpdatePrefsOnNetworkSequence(); | 728 ExpectScheduleUpdatePrefsOnNetworkSequence(); |
726 | 729 |
727 url::SchemeHostPort spdy_server_mail("http", "mail.google.com", 80); | 730 url::SchemeHostPort spdy_server_mail("http", "mail.google.com", 80); |
728 EXPECT_FALSE(HasAlternativeService(spdy_server_mail)); | 731 EXPECT_FALSE(HasAlternativeService(spdy_server_mail)); |
729 const AlternativeService alternative_service(kProtoHTTP2, "mail.google.com", | 732 const AlternativeService alternative_service(kProtoHTTP2, "mail.google.com", |
730 443); | 733 443); |
731 http_server_props_manager_->SetAlternativeService( | 734 http_server_props_manager_->SetAlternativeService( |
732 spdy_server_mail, alternative_service, one_day_from_now_); | 735 spdy_server_mail, alternative_service, one_day_from_now_, |
| 736 QuicVersionVector()); |
733 // ExpectScheduleUpdatePrefsOnNetworkSequence() should be called only once. | 737 // ExpectScheduleUpdatePrefsOnNetworkSequence() should be called only once. |
734 http_server_props_manager_->SetAlternativeService( | 738 http_server_props_manager_->SetAlternativeService( |
735 spdy_server_mail, alternative_service, one_day_from_now_); | 739 spdy_server_mail, alternative_service, one_day_from_now_, |
| 740 QuicVersionVector()); |
736 | 741 |
737 // Run the task. | 742 // Run the task. |
738 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 743 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
739 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); | 744 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
740 net_test_task_runner_->FastForwardUntilNoTasksRemain(); | 745 net_test_task_runner_->FastForwardUntilNoTasksRemain(); |
741 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); | 746 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
742 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 747 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
743 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); | 748 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
744 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 749 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
745 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 750 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
818 { | 823 { |
819 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); | 824 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
820 | 825 |
821 spdy_server_mail = url::SchemeHostPort("http", "mail.google.com", 80); | 826 spdy_server_mail = url::SchemeHostPort("http", "mail.google.com", 80); |
822 EXPECT_FALSE(HasAlternativeService(spdy_server_mail)); | 827 EXPECT_FALSE(HasAlternativeService(spdy_server_mail)); |
823 alternative_service = | 828 alternative_service = |
824 AlternativeService(kProtoHTTP2, "mail.google.com", 443); | 829 AlternativeService(kProtoHTTP2, "mail.google.com", 443); |
825 | 830 |
826 ExpectScheduleUpdatePrefsOnNetworkSequence(); | 831 ExpectScheduleUpdatePrefsOnNetworkSequence(); |
827 http_server_props_manager_->SetAlternativeService( | 832 http_server_props_manager_->SetAlternativeService( |
828 spdy_server_mail, alternative_service, one_day_from_now_); | 833 spdy_server_mail, alternative_service, one_day_from_now_, |
| 834 QuicVersionVector()); |
829 | 835 |
830 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( | 836 EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken( |
831 alternative_service)); | 837 alternative_service)); |
832 EXPECT_FALSE( | 838 EXPECT_FALSE( |
833 http_server_props_manager_->WasAlternativeServiceRecentlyBroken( | 839 http_server_props_manager_->WasAlternativeServiceRecentlyBroken( |
834 alternative_service)); | 840 alternative_service)); |
835 | 841 |
836 ExpectScheduleUpdatePrefsOnNetworkSequence(); | 842 ExpectScheduleUpdatePrefsOnNetworkSequence(); |
837 http_server_props_manager_->MarkAlternativeServiceBroken( | 843 http_server_props_manager_->MarkAlternativeServiceBroken( |
838 alternative_service); | 844 alternative_service); |
(...skipping 152 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
991 const QuicServerId mail_quic_server_id("mail.google.com", 80); | 997 const QuicServerId mail_quic_server_id("mail.google.com", 80); |
992 const std::string quic_server_info1("quic_server_info1"); | 998 const std::string quic_server_info1("quic_server_info1"); |
993 | 999 |
994 { | 1000 { |
995 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); | 1001 TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_); |
996 | 1002 |
997 http_server_props_manager_->SetSupportsSpdy(spdy_server, true); | 1003 http_server_props_manager_->SetSupportsSpdy(spdy_server, true); |
998 AlternativeService alternative_service(kProtoHTTP2, "mail.google.com", | 1004 AlternativeService alternative_service(kProtoHTTP2, "mail.google.com", |
999 1234); | 1005 1234); |
1000 http_server_props_manager_->SetAlternativeService( | 1006 http_server_props_manager_->SetAlternativeService( |
1001 spdy_server, alternative_service, one_day_from_now_); | 1007 spdy_server, alternative_service, one_day_from_now_, |
| 1008 QuicVersionVector()); |
1002 http_server_props_manager_->SetSupportsQuic(true, actual_address); | 1009 http_server_props_manager_->SetSupportsQuic(true, actual_address); |
1003 ServerNetworkStats stats; | 1010 ServerNetworkStats stats; |
1004 stats.srtt = base::TimeDelta::FromMicroseconds(10); | 1011 stats.srtt = base::TimeDelta::FromMicroseconds(10); |
1005 http_server_props_manager_->SetServerNetworkStats(spdy_server, stats); | 1012 http_server_props_manager_->SetServerNetworkStats(spdy_server, stats); |
1006 | 1013 |
1007 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, | 1014 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, |
1008 quic_server_info1); | 1015 quic_server_info1); |
1009 } | 1016 } |
1010 | 1017 |
1011 // Run the task. | 1018 // Run the task. |
(...skipping 150 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1162 const url::SchemeHostPort server_www("https", "www.google.com", 80); | 1169 const url::SchemeHostPort server_www("https", "www.google.com", 80); |
1163 const url::SchemeHostPort server_mail("https", "mail.google.com", 80); | 1170 const url::SchemeHostPort server_mail("https", "mail.google.com", 80); |
1164 | 1171 |
1165 // #1 & #2: Set alternate protocol. | 1172 // #1 & #2: Set alternate protocol. |
1166 AlternativeServiceInfoVector alternative_service_info_vector; | 1173 AlternativeServiceInfoVector alternative_service_info_vector; |
1167 AlternativeService www_alternative_service1(kProtoHTTP2, "", 443); | 1174 AlternativeService www_alternative_service1(kProtoHTTP2, "", 443); |
1168 base::Time expiration1; | 1175 base::Time expiration1; |
1169 ASSERT_TRUE(base::Time::FromUTCString("2036-12-01 10:00:00", &expiration1)); | 1176 ASSERT_TRUE(base::Time::FromUTCString("2036-12-01 10:00:00", &expiration1)); |
1170 alternative_service_info_vector.push_back( | 1177 alternative_service_info_vector.push_back( |
1171 AlternativeServiceInfo(www_alternative_service1, expiration1)); | 1178 AlternativeServiceInfo(www_alternative_service1, expiration1)); |
| 1179 |
1172 AlternativeService www_alternative_service2(kProtoHTTP2, "www.google.com", | 1180 AlternativeService www_alternative_service2(kProtoHTTP2, "www.google.com", |
1173 1234); | 1181 1234); |
1174 base::Time expiration2; | 1182 base::Time expiration2; |
1175 ASSERT_TRUE(base::Time::FromUTCString("2036-12-31 10:00:00", &expiration2)); | 1183 ASSERT_TRUE(base::Time::FromUTCString("2036-12-31 10:00:00", &expiration2)); |
1176 alternative_service_info_vector.push_back( | 1184 alternative_service_info_vector.push_back( |
1177 AlternativeServiceInfo(www_alternative_service2, expiration2)); | 1185 AlternativeServiceInfo(www_alternative_service2, expiration2)); |
1178 ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices( | 1186 ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices( |
1179 server_www, alternative_service_info_vector)); | 1187 server_www, alternative_service_info_vector)); |
1180 | 1188 |
1181 AlternativeService mail_alternative_service(kProtoHTTP2, "foo.google.com", | 1189 AlternativeService mail_alternative_service(kProtoHTTP2, "foo.google.com", |
1182 444); | 1190 444); |
1183 base::Time expiration3 = base::Time::Max(); | 1191 base::Time expiration3 = base::Time::Max(); |
1184 ASSERT_TRUE(http_server_props_manager_->SetAlternativeService( | 1192 ASSERT_TRUE(http_server_props_manager_->SetAlternativeService( |
1185 server_mail, mail_alternative_service, expiration3)); | 1193 server_mail, mail_alternative_service, expiration3, QuicVersionVector())); |
1186 | 1194 |
1187 // #3: Set ServerNetworkStats. | 1195 // #3: Set ServerNetworkStats. |
1188 ServerNetworkStats stats; | 1196 ServerNetworkStats stats; |
1189 stats.srtt = base::TimeDelta::FromInternalValue(42); | 1197 stats.srtt = base::TimeDelta::FromInternalValue(42); |
1190 http_server_props_manager_->SetServerNetworkStats(server_mail, stats); | 1198 http_server_props_manager_->SetServerNetworkStats(server_mail, stats); |
1191 | 1199 |
1192 // #4: Set quic_server_info string. | 1200 // #4: Set quic_server_info string. |
1193 QuicServerId mail_quic_server_id("mail.google.com", 80); | 1201 QuicServerId mail_quic_server_id("mail.google.com", 80); |
1194 std::string quic_server_info1("quic_server_info1"); | 1202 std::string quic_server_info1("quic_server_info1"); |
1195 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, | 1203 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, |
(...skipping 10 matching lines...) Expand all Loading... |
1206 net_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1214 net_test_task_runner_->FastForwardUntilNoTasksRemain(); |
1207 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); | 1215 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
1208 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1216 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
1209 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 1217 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
1210 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1218 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1211 | 1219 |
1212 // Verify preferences. | 1220 // Verify preferences. |
1213 const char expected_json[] = | 1221 const char expected_json[] = |
1214 "{\"quic_servers\":{\"https://" | 1222 "{\"quic_servers\":{\"https://" |
1215 "mail.google.com:80\":{\"server_info\":\"quic_server_info1\"}}," | 1223 "mail.google.com:80\":{\"server_info\":\"quic_server_info1\"}}," |
1216 "\"servers\":[" | 1224 "\"servers\":[{\"https://www.google.com:80\":{" |
1217 "{\"https://www.google.com:80\":{" | 1225 "\"alternative_service\":[{\"advertised_versions\":[],\"expiration\":" |
1218 "\"alternative_service\":[{\"expiration\":\"13756212000000000\"," | 1226 "\"13756212000000000\",\"port\":443,\"protocol_str\":\"h2\"}," |
1219 "\"port\":443,\"protocol_str\":\"h2\"}," | 1227 "{\"advertised_versions\":[],\"expiration\":\"13758804000000000\"," |
1220 "{\"expiration\":\"13758804000000000\",\"host\":\"www.google.com\"," | 1228 "\"host\":\"www.google.com\",\"port\":1234,\"protocol_str\":\"h2\"}]}}," |
1221 "\"port\":1234,\"protocol_str\":\"h2\"}]}}," | |
1222 "{\"https://mail.google.com:80\":{\"alternative_service\":[{" | 1229 "{\"https://mail.google.com:80\":{\"alternative_service\":[{" |
1223 "\"expiration\":\"9223372036854775807\",\"host\":\"foo.google.com\"," | 1230 "\"advertised_versions\":[],\"expiration\":\"9223372036854775807\"," |
1224 "\"port\":444,\"protocol_str\":\"h2\"}]," | 1231 "\"host\":\"foo.google.com\",\"port\":444,\"protocol_str\":\"h2\"}]," |
1225 "\"network_stats\":{\"srtt\":42}}}" | 1232 "\"network_stats\":{\"srtt\":42}}}]," |
1226 "]," | |
1227 "\"supports_quic\":{\"address\":\"127.0.0.1\",\"used_quic\":true}," | 1233 "\"supports_quic\":{\"address\":\"127.0.0.1\",\"used_quic\":true}," |
1228 "\"version\":5}"; | 1234 "\"version\":5}"; |
1229 | 1235 |
1230 const base::Value* http_server_properties = | 1236 const base::Value* http_server_properties = |
1231 &pref_delegate_->GetServerProperties(); | 1237 &pref_delegate_->GetServerProperties(); |
1232 std::string preferences_json; | 1238 std::string preferences_json; |
1233 EXPECT_TRUE( | 1239 EXPECT_TRUE( |
1234 base::JSONWriter::Write(*http_server_properties, &preferences_json)); | 1240 base::JSONWriter::Write(*http_server_properties, &preferences_json)); |
1235 EXPECT_EQ(expected_json, preferences_json); | 1241 EXPECT_EQ(expected_json, preferences_json); |
1236 } | 1242 } |
(...skipping 323 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1560 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); | 1566 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
1561 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); | 1567 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
1562 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 1568 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
1563 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1569 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1564 Mock::VerifyAndClearExpectations(http_server_props_manager_.get()); | 1570 Mock::VerifyAndClearExpectations(http_server_props_manager_.get()); |
1565 http_server_props_manager_.reset(); | 1571 http_server_props_manager_.reset(); |
1566 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); | 1572 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
1567 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); | 1573 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
1568 } | 1574 } |
1569 | 1575 |
| 1576 TEST_P(HttpServerPropertiesManagerTest, PersistAdvertisedVersionsToPref) { |
| 1577 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(5); |
| 1578 |
| 1579 const url::SchemeHostPort server_www("https", "www.google.com", 80); |
| 1580 const url::SchemeHostPort server_mail("https", "mail.google.com", 80); |
| 1581 |
| 1582 // #1 & #2: Set alternate protocol. |
| 1583 AlternativeServiceInfoVector alternative_service_info_vector; |
| 1584 // Quic alternative service set with two advertised QUIC versions. |
| 1585 AlternativeService quic_alternative_service1(kProtoQUIC, "", 443); |
| 1586 base::Time expiration1; |
| 1587 ASSERT_TRUE(base::Time::FromUTCString("2036-12-01 10:00:00", &expiration1)); |
| 1588 QuicVersionVector advertised_versions = {QUIC_VERSION_37, QUIC_VERSION_35}; |
| 1589 alternative_service_info_vector.push_back(AlternativeServiceInfo( |
| 1590 quic_alternative_service1, expiration1, advertised_versions)); |
| 1591 // HTTP/2 alternative service should not set any advertised version. |
| 1592 AlternativeService h2_alternative_service(kProtoHTTP2, "www.google.com", |
| 1593 1234); |
| 1594 base::Time expiration2; |
| 1595 ASSERT_TRUE(base::Time::FromUTCString("2036-12-31 10:00:00", &expiration2)); |
| 1596 alternative_service_info_vector.push_back( |
| 1597 AlternativeServiceInfo(h2_alternative_service, expiration2)); |
| 1598 ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices( |
| 1599 server_www, alternative_service_info_vector)); |
| 1600 |
| 1601 // Set another QUIC alternative service with a single advertised QUIC version. |
| 1602 AlternativeService mail_alternative_service(kProtoQUIC, "foo.google.com", |
| 1603 444); |
| 1604 base::Time expiration3 = base::Time::Max(); |
| 1605 ASSERT_TRUE(http_server_props_manager_->SetAlternativeService( |
| 1606 server_mail, mail_alternative_service, expiration3, |
| 1607 advertised_versions_)); |
| 1608 // #3: Set ServerNetworkStats. |
| 1609 ServerNetworkStats stats; |
| 1610 stats.srtt = base::TimeDelta::FromInternalValue(42); |
| 1611 http_server_props_manager_->SetServerNetworkStats(server_mail, stats); |
| 1612 |
| 1613 // #4: Set quic_server_info string. |
| 1614 QuicServerId mail_quic_server_id("mail.google.com", 80); |
| 1615 std::string quic_server_info1("quic_server_info1"); |
| 1616 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, |
| 1617 quic_server_info1); |
| 1618 |
| 1619 // #5: Set SupportsQuic. |
| 1620 IPAddress actual_address(127, 0, 0, 1); |
| 1621 http_server_props_manager_->SetSupportsQuic(true, actual_address); |
| 1622 |
| 1623 // Update Prefs. |
| 1624 ExpectPrefsUpdate(1); |
| 1625 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1626 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
| 1627 net_test_task_runner_->FastForwardUntilNoTasksRemain(); |
| 1628 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
| 1629 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
| 1630 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
| 1631 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
| 1632 |
| 1633 // Verify preferences with correct advertised version field. |
| 1634 const char expected_json[] = |
| 1635 "{\"quic_servers\":{\"https://mail.google.com:80\":{" |
| 1636 "\"server_info\":\"quic_server_info1\"}},\"servers\":[" |
| 1637 "{\"https://www.google.com:80\":{\"alternative_service\":[{" |
| 1638 "\"advertised_versions\":[35,37],\"expiration\":\"13756212000000000\"," |
| 1639 "\"port\":443,\"protocol_str\":\"quic\"},{\"advertised_versions\":[]," |
| 1640 "\"expiration\":\"13758804000000000\",\"host\":\"www.google.com\"," |
| 1641 "\"port\":1234,\"protocol_str\":\"h2\"}]}}," |
| 1642 "{\"https://mail.google.com:80\":{\"alternative_service\":[{" |
| 1643 "\"advertised_versions\":[37],\"expiration\":\"9223372036854775807\"," |
| 1644 "\"host\":\"foo.google.com\",\"port\":444,\"protocol_str\":\"quic\"}]," |
| 1645 "\"network_stats\":{\"srtt\":42}}}],\"supports_quic\":{" |
| 1646 "\"address\":\"127.0.0.1\",\"used_quic\":true},\"version\":5}"; |
| 1647 |
| 1648 const base::Value* http_server_properties = |
| 1649 &pref_delegate_->GetServerProperties(); |
| 1650 std::string preferences_json; |
| 1651 EXPECT_TRUE( |
| 1652 base::JSONWriter::Write(*http_server_properties, &preferences_json)); |
| 1653 EXPECT_EQ(expected_json, preferences_json); |
| 1654 } |
| 1655 |
| 1656 TEST_P(HttpServerPropertiesManagerTest, ReadAdvertisedVersionsFromPref) { |
| 1657 std::unique_ptr<base::Value> server_value = base::JSONReader::Read( |
| 1658 "{\"alternative_service\":[" |
| 1659 "{\"port\":443,\"protocol_str\":\"quic\"}," |
| 1660 "{\"port\":123,\"protocol_str\":\"quic\"," |
| 1661 "\"expiration\":\"9223372036854775807\"," |
| 1662 "\"advertised_versions\":[37,35]}]}"); |
| 1663 ASSERT_TRUE(server_value); |
| 1664 base::DictionaryValue* server_dict; |
| 1665 ASSERT_TRUE(server_value->GetAsDictionary(&server_dict)); |
| 1666 |
| 1667 const url::SchemeHostPort server("https", "example.com", 443); |
| 1668 AlternativeServiceMap alternative_service_map(/*max_size=*/5); |
| 1669 EXPECT_TRUE(http_server_props_manager_->AddToAlternativeServiceMap( |
| 1670 server, *server_dict, &alternative_service_map)); |
| 1671 |
| 1672 AlternativeServiceMap::iterator it = alternative_service_map.Get(server); |
| 1673 ASSERT_NE(alternative_service_map.end(), it); |
| 1674 AlternativeServiceInfoVector alternative_service_info_vector = it->second; |
| 1675 ASSERT_EQ(2u, alternative_service_info_vector.size()); |
| 1676 |
| 1677 // Verify the first alternative service with no advertised version listed. |
| 1678 EXPECT_EQ(kProtoQUIC, |
| 1679 alternative_service_info_vector[0].alternative_service.protocol); |
| 1680 EXPECT_EQ("", alternative_service_info_vector[0].alternative_service.host); |
| 1681 EXPECT_EQ(443, alternative_service_info_vector[0].alternative_service.port); |
| 1682 // Expiration defaults to one day from now, testing with tolerance. |
| 1683 const base::Time now = base::Time::Now(); |
| 1684 const base::Time expiration = alternative_service_info_vector[0].expiration; |
| 1685 EXPECT_LE(now + base::TimeDelta::FromHours(23), expiration); |
| 1686 EXPECT_GE(now + base::TimeDelta::FromDays(1), expiration); |
| 1687 EXPECT_TRUE(alternative_service_info_vector[0].advertised_versions().empty()); |
| 1688 |
| 1689 // Verify the second alterntaive service with two advertised versions. |
| 1690 EXPECT_EQ(kProtoQUIC, |
| 1691 alternative_service_info_vector[1].alternative_service.protocol); |
| 1692 EXPECT_EQ("", alternative_service_info_vector[1].alternative_service.host); |
| 1693 EXPECT_EQ(123, alternative_service_info_vector[1].alternative_service.port); |
| 1694 EXPECT_EQ(base::Time::Max(), alternative_service_info_vector[1].expiration); |
| 1695 // Verify advertised versions. |
| 1696 const QuicVersionVector loaded_advertised_versions = |
| 1697 alternative_service_info_vector[1].advertised_versions(); |
| 1698 EXPECT_EQ(2u, loaded_advertised_versions.size()); |
| 1699 EXPECT_EQ(QUIC_VERSION_35, loaded_advertised_versions[0]); |
| 1700 EXPECT_EQ(QUIC_VERSION_37, loaded_advertised_versions[1]); |
| 1701 } |
| 1702 |
| 1703 TEST_P(HttpServerPropertiesManagerTest, |
| 1704 UpdatePrefWhenAdvertisedVersionsChange) { |
| 1705 ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(4); |
| 1706 |
| 1707 const url::SchemeHostPort server_www("https", "www.google.com", 80); |
| 1708 |
| 1709 // #1: Set alternate protocol. |
| 1710 AlternativeServiceInfoVector alternative_service_info_vector; |
| 1711 // Quic alternative service set with a single QUIC version: QUIC_VERSION_37. |
| 1712 AlternativeService quic_alternative_service1(kProtoQUIC, "", 443); |
| 1713 base::Time expiration1; |
| 1714 ASSERT_TRUE(base::Time::FromUTCString("2036-12-01 10:00:00", &expiration1)); |
| 1715 alternative_service_info_vector.push_back(AlternativeServiceInfo( |
| 1716 quic_alternative_service1, expiration1, advertised_versions_)); |
| 1717 ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices( |
| 1718 server_www, alternative_service_info_vector)); |
| 1719 |
| 1720 // Set quic_server_info string. |
| 1721 QuicServerId mail_quic_server_id("mail.google.com", 80); |
| 1722 std::string quic_server_info1("quic_server_info1"); |
| 1723 http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id, |
| 1724 quic_server_info1); |
| 1725 |
| 1726 // Set SupportsQuic. |
| 1727 IPAddress actual_address(127, 0, 0, 1); |
| 1728 http_server_props_manager_->SetSupportsQuic(true, actual_address); |
| 1729 |
| 1730 // Update Prefs. |
| 1731 ExpectPrefsUpdate(1); |
| 1732 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1733 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
| 1734 net_test_task_runner_->FastForwardUntilNoTasksRemain(); |
| 1735 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
| 1736 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
| 1737 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
| 1738 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
| 1739 |
| 1740 // Verify preferences with correct advertised version field. |
| 1741 const char expected_json[] = |
| 1742 "{\"quic_servers\":{\"https://mail.google.com:80\":" |
| 1743 "{\"server_info\":\"quic_server_info1\"}},\"servers\":[" |
| 1744 "{\"https://www.google.com:80\":" |
| 1745 "{\"alternative_service\":[{\"advertised_versions\":[37]," |
| 1746 "\"expiration\":\"13756212000000000\",\"port\":443," |
| 1747 "\"protocol_str\":\"quic\"}]}}],\"supports_quic\":" |
| 1748 "{\"address\":\"127.0.0.1\",\"used_quic\":true},\"version\":5}"; |
| 1749 |
| 1750 const base::Value* http_server_properties = |
| 1751 &pref_delegate_->GetServerProperties(); |
| 1752 std::string preferences_json; |
| 1753 EXPECT_TRUE( |
| 1754 base::JSONWriter::Write(*http_server_properties, &preferences_json)); |
| 1755 EXPECT_EQ(expected_json, preferences_json); |
| 1756 |
| 1757 // #2: Set AlternativeService with different advertised_versions for the same |
| 1758 // AlternativeService. |
| 1759 AlternativeServiceInfoVector alternative_service_info_vector_2; |
| 1760 // Quic alternative service set with two advertised QUIC versions. |
| 1761 QuicVersionVector advertised_versions = {QUIC_VERSION_37, QUIC_VERSION_35}; |
| 1762 alternative_service_info_vector_2.push_back(AlternativeServiceInfo( |
| 1763 quic_alternative_service1, expiration1, advertised_versions)); |
| 1764 ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices( |
| 1765 server_www, alternative_service_info_vector_2)); |
| 1766 |
| 1767 // Update Prefs. |
| 1768 ExpectPrefsUpdate(1); |
| 1769 EXPECT_TRUE(net_test_task_runner_->HasPendingTask()); |
| 1770 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
| 1771 net_test_task_runner_->FastForwardUntilNoTasksRemain(); |
| 1772 EXPECT_TRUE(pref_test_task_runner_->HasPendingTask()); |
| 1773 pref_test_task_runner_->FastForwardUntilNoTasksRemain(); |
| 1774 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
| 1775 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
| 1776 |
| 1777 // Verify preferences updated with new advertised versions. |
| 1778 const char expected_json_updated[] = |
| 1779 "{\"quic_servers\":{\"https://mail.google.com:80\":" |
| 1780 "{\"server_info\":\"quic_server_info1\"}},\"servers\":[" |
| 1781 "{\"https://www.google.com:80\":" |
| 1782 "{\"alternative_service\":[{\"advertised_versions\":[35,37]," |
| 1783 "\"expiration\":\"13756212000000000\",\"port\":443," |
| 1784 "\"protocol_str\":\"quic\"}]}}],\"supports_quic\":" |
| 1785 "{\"address\":\"127.0.0.1\",\"used_quic\":true},\"version\":5}"; |
| 1786 EXPECT_TRUE( |
| 1787 base::JSONWriter::Write(*http_server_properties, &preferences_json)); |
| 1788 EXPECT_EQ(expected_json_updated, preferences_json); |
| 1789 |
| 1790 // #3: Set AlternativeService with same advertised_versions. |
| 1791 AlternativeServiceInfoVector alternative_service_info_vector_3; |
| 1792 // A same set of QUIC versions but listed in a different order. |
| 1793 QuicVersionVector advertised_versions_2 = {QUIC_VERSION_35, QUIC_VERSION_37}; |
| 1794 alternative_service_info_vector_3.push_back(AlternativeServiceInfo( |
| 1795 quic_alternative_service1, expiration1, advertised_versions_2)); |
| 1796 ASSERT_FALSE(http_server_props_manager_->SetAlternativeServices( |
| 1797 server_www, alternative_service_info_vector_3)); |
| 1798 |
| 1799 // No Prefs update. |
| 1800 EXPECT_FALSE(net_test_task_runner_->HasPendingTask()); |
| 1801 EXPECT_FALSE(pref_test_task_runner_->HasPendingTask()); |
| 1802 } |
| 1803 |
1570 } // namespace net | 1804 } // namespace net |
OLD | NEW |