Add and persist a new field in AlternativeServiceInfo to list QUIC verisons advertised

net/http/http_server_properties_manager_unittest.cc

 // Copyright 2014 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/http/http_server_properties_manager.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/scoped_mock_time_message_loop_task_runner.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/ip_address.h"
+#include "net/http/http_network_session.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 using base::StringPrintf;
 using base::TestMockTimeTaskRunner;
@@ skipping 119 matching lines @@
 // TODO(rtenneti): After we stop supporting version 3 and everyone has migrated
 // to version 4, delete the following code.
 static const int kHttpServerPropertiesVersions[] = {3, 4, 5};
 
 class HttpServerPropertiesManagerTest : public testing::TestWithParam<int> {
  protected:
   HttpServerPropertiesManagerTest() = default;
 
   void SetUp() override {
     one_day_from_now_ = base::Time::Now() + base::TimeDelta::FromDays(1);
+    advertised_versions_ = HttpNetworkSession::Params().quic_supported_versions;
     pref_delegate_ = new MockPrefDelegate;
     http_server_props_manager_.reset(
         new StrictMock<TestingHttpServerPropertiesManager>(
             pref_delegate_, pref_test_task_runner_.task_runner(),
             net_test_task_runner_));
 
     EXPECT_FALSE(http_server_props_manager_->IsInitialized());
     ExpectCacheUpdate();
     EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
     pref_test_task_runner_->RunUntilIdle();
@@ skipping 53 matching lines @@
   bool HasAlternativeService(const url::SchemeHostPort& server) {
     const AlternativeServiceInfoVector alternative_service_info_vector =
         http_server_props_manager_->GetAlternativeServiceInfos(server);
     return !alternative_service_info_vector.empty();
   }
 
   MockPrefDelegate* pref_delegate_;  // Owned by HttpServerPropertiesManager.
   std::unique_ptr<TestingHttpServerPropertiesManager>
       http_server_props_manager_;
   base::Time one_day_from_now_;
+  QuicVersionVector advertised_versions_;
 
   // Overrides the main thread's message loop with a mock tick clock. Making the
   // main thread the |pref_test_task_runner_| matches expectations better than
   // having an independent TestMockTimeTaskRunner and makes tests easier to
   // write.
   base::ScopedMockTimeMessageLoopTaskRunner pref_test_task_runner_;
 
   // Mock the net task runner as well.
   scoped_refptr<TestMockTimeTaskRunner> net_test_task_runner_ =
       new TestMockTimeTaskRunner;
@@ skipping 471 matching lines @@
 
 TEST_P(HttpServerPropertiesManagerTest, GetAlternativeServiceInfos) {
   ExpectPrefsUpdate(1);
   ExpectScheduleUpdatePrefsOnNetworkThread();
 
   url::SchemeHostPort spdy_server_mail("http", "mail.google.com", 80);
   EXPECT_FALSE(HasAlternativeService(spdy_server_mail));
   const AlternativeService alternative_service(kProtoHTTP2, "mail.google.com",
                                                443);
   http_server_props_manager_->SetAlternativeService(
-      spdy_server_mail, alternative_service, one_day_from_now_);
+      spdy_server_mail, alternative_service, one_day_from_now_,
+      advertised_versions_);
   // ExpectScheduleUpdatePrefsOnNetworkThread() should be called only once.
   http_server_props_manager_->SetAlternativeService(
-      spdy_server_mail, alternative_service, one_day_from_now_);
+      spdy_server_mail, alternative_service, one_day_from_now_,
+      advertised_versions_);
 
   // Run the task.
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   AlternativeServiceInfoVector alternative_service_info_vector =
       http_server_props_manager_->GetAlternativeServiceInfos(spdy_server_mail);
   ASSERT_EQ(1u, alternative_service_info_vector.size());
   EXPECT_EQ(alternative_service,
             alternative_service_info_vector[0].alternative_service);
 }
 
 TEST_P(HttpServerPropertiesManagerTest, SetAlternativeServices) {
   ExpectPrefsUpdate(1);
   ExpectScheduleUpdatePrefsOnNetworkThread();
 
   url::SchemeHostPort spdy_server_mail("http", "mail.google.com", 80);
   EXPECT_FALSE(HasAlternativeService(spdy_server_mail));
   AlternativeServiceInfoVector alternative_service_info_vector;
   const AlternativeService alternative_service1(kProtoHTTP2, "mail.google.com",
                                                 443);
-  alternative_service_info_vector.push_back(
-      AlternativeServiceInfo(alternative_service1, one_day_from_now_));
+  alternative_service_info_vector.push_back(AlternativeServiceInfo(
+      alternative_service1, one_day_from_now_, advertised_versions_));
   const AlternativeService alternative_service2(kProtoQUIC, "mail.google.com",
                                                 1234);
-  alternative_service_info_vector.push_back(
-      AlternativeServiceInfo(alternative_service2, one_day_from_now_));
+  alternative_service_info_vector.push_back(AlternativeServiceInfo(
+      alternative_service2, one_day_from_now_, advertised_versions_));
   http_server_props_manager_->SetAlternativeServices(
       spdy_server_mail, alternative_service_info_vector);
   // ExpectScheduleUpdatePrefsOnNetworkThread() should be called only once.
   http_server_props_manager_->SetAlternativeServices(
       spdy_server_mail, alternative_service_info_vector);
 
   // Run the task.
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
@@ skipping 38 matching lines @@
   {
     TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_);
 
     spdy_server_mail = url::SchemeHostPort("http", "mail.google.com", 80);
     EXPECT_FALSE(HasAlternativeService(spdy_server_mail));
     alternative_service =
         AlternativeService(kProtoHTTP2, "mail.google.com", 443);
 
     ExpectScheduleUpdatePrefsOnNetworkThread();
     http_server_props_manager_->SetAlternativeService(
-        spdy_server_mail, alternative_service, one_day_from_now_);
+        spdy_server_mail, alternative_service, one_day_from_now_,
+        advertised_versions_);
 
     EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken(
         alternative_service));
     EXPECT_FALSE(
         http_server_props_manager_->WasAlternativeServiceRecentlyBroken(
             alternative_service));
 
     ExpectScheduleUpdatePrefsOnNetworkThread();
     http_server_props_manager_->MarkAlternativeServiceBroken(
         alternative_service);
@@ skipping 152 matching lines @@
   const QuicServerId mail_quic_server_id("mail.google.com", 80);
   const std::string quic_server_info1("quic_server_info1");
 
   {
     TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_);
 
     http_server_props_manager_->SetSupportsSpdy(spdy_server, true);
     AlternativeService alternative_service(kProtoHTTP2, "mail.google.com",
                                            1234);
     http_server_props_manager_->SetAlternativeService(
-        spdy_server, alternative_service, one_day_from_now_);
+        spdy_server, alternative_service, one_day_from_now_,
+        advertised_versions_);
     http_server_props_manager_->SetSupportsQuic(true, actual_address);
     ServerNetworkStats stats;
     stats.srtt = base::TimeDelta::FromMicroseconds(10);
     http_server_props_manager_->SetServerNetworkStats(spdy_server, stats);
 
     http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id,
                                                   quic_server_info1);
   }
 
   // Run the task.
@@ skipping 148 matching lines @@
   ExpectScheduleUpdatePrefsOnNetworkThreadRepeatedly(5);
 
   const url::SchemeHostPort server_www("https", "www.google.com", 80);
   const url::SchemeHostPort server_mail("https", "mail.google.com", 80);
 
   // #1 & #2: Set alternate protocol.
   AlternativeServiceInfoVector alternative_service_info_vector;
   AlternativeService www_alternative_service1(kProtoHTTP2, "", 443);
   base::Time expiration1;
   ASSERT_TRUE(base::Time::FromUTCString("2036-12-01 10:00:00", &expiration1));
-  alternative_service_info_vector.push_back(
-      AlternativeServiceInfo(www_alternative_service1, expiration1));
+  alternative_service_info_vector.push_back(AlternativeServiceInfo(
+      www_alternative_service1, expiration1, advertised_versions_));
   AlternativeService www_alternative_service2(kProtoHTTP2, "www.google.com",
                                               1234);
   base::Time expiration2;
   ASSERT_TRUE(base::Time::FromUTCString("2036-12-31 10:00:00", &expiration2));
-  alternative_service_info_vector.push_back(
-      AlternativeServiceInfo(www_alternative_service2, expiration2));
+  alternative_service_info_vector.push_back(AlternativeServiceInfo(
+      www_alternative_service2, expiration2, advertised_versions_));
   ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices(
       server_www, alternative_service_info_vector));
 
   AlternativeService mail_alternative_service(kProtoHTTP2, "foo.google.com",
                                               444);
   base::Time expiration3 = base::Time::Max();
   ASSERT_TRUE(http_server_props_manager_->SetAlternativeService(
-      server_mail, mail_alternative_service, expiration3));
+      server_mail, mail_alternative_service, expiration3,
+      advertised_versions_));
 
   // #3: Set ServerNetworkStats.
   ServerNetworkStats stats;
   stats.srtt = base::TimeDelta::FromInternalValue(42);
   http_server_props_manager_->SetServerNetworkStats(server_mail, stats);
 
   // #4: Set quic_server_info string.
   QuicServerId mail_quic_server_id("mail.google.com", 80);
   std::string quic_server_info1("quic_server_info1");
   http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id,
@@ skipping 150 matching lines @@
 
   {
     TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_);
 
     AlternativeServiceInfoVector alternative_service_info_vector;
 
     const AlternativeService broken_alternative_service(
         kProtoHTTP2, "broken.example.com", 443);
     const base::Time time_one_day_later =
         base::Time::Now() + base::TimeDelta::FromDays(1);
-    alternative_service_info_vector.push_back(
-        AlternativeServiceInfo(broken_alternative_service, time_one_day_later));
+    alternative_service_info_vector.push_back(AlternativeServiceInfo(
+        broken_alternative_service, time_one_day_later, advertised_versions_));
     // #1: MarkAlternativeServiceBroken().
     http_server_props_manager_->MarkAlternativeServiceBroken(
         broken_alternative_service);
 
     const AlternativeService expired_alternative_service(
         kProtoHTTP2, "expired.example.com", 443);
     const base::Time time_one_day_ago =
         base::Time::Now() - base::TimeDelta::FromDays(1);
-    alternative_service_info_vector.push_back(
-        AlternativeServiceInfo(expired_alternative_service, time_one_day_ago));
+    alternative_service_info_vector.push_back(AlternativeServiceInfo(
+        expired_alternative_service, time_one_day_ago, advertised_versions_));
 
     const AlternativeService valid_alternative_service(
         kProtoHTTP2, "valid.example.com", 443);
-    alternative_service_info_vector.push_back(
-        AlternativeServiceInfo(valid_alternative_service, time_one_day_later));
+    alternative_service_info_vector.push_back(AlternativeServiceInfo(
+        valid_alternative_service, time_one_day_later, advertised_versions_));
 
     const url::SchemeHostPort server("https", "www.example.com", 443);
     // #2: SetAlternativeService().
     ASSERT_TRUE(http_server_props_manager_->SetAlternativeServices(
         server, alternative_service_info_vector));
   }
 
   // Update cache.
   ExpectPrefsUpdate(1);
 
@@ skipping 178 matching lines @@
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
   http_server_props_manager_.reset();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 }
 
 }  // namespace net