Remove unused HttpServerProperites::ClearAlternativeServices

net/http/http_server_properties_impl_unittest.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/http/http_server_properties_impl.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
@@ skipping 758 matching lines @@
   // Check Alt-Svc list should not be set for |https_server|.
   url::SchemeHostPort https_server("https", "foo", 80);
   EXPECT_EQ(0u, impl_.GetAlternativeServices(https_server).size());
 
   // Set Alt-Svc list for |https_server|.
   impl_.SetAlternativeServices(https_server, alternative_service_info_vector);
   EXPECT_EQ(2u, impl_.GetAlternativeServices(https_server).size());
   EXPECT_EQ(2u, impl_.GetAlternativeServices(http_server).size());
 
   // Clear Alt-Svc list for |http_server|.
-  impl_.ClearAlternativeServices(http_server);
+  impl_.SetAlternativeServices(http_server, AlternativeServiceInfoVector());
+
   EXPECT_EQ(0u, impl_.GetAlternativeServices(http_server).size());
   EXPECT_EQ(2u, impl_.GetAlternativeServices(https_server).size());
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, ClearAlternativeServices) {
   AlternativeServiceInfoVector alternative_service_info_vector;
   const AlternativeService alternative_service1(NPN_SPDY_3_1, "foo", 443);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service1, expiration));
   const AlternativeService alternative_service2(NPN_HTTP_2, "bar", 1234);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service2, expiration));
   url::SchemeHostPort test_server("http", "foo", 80);
   impl_.SetAlternativeServices(test_server, alternative_service_info_vector);
 
   const net::AlternativeServiceMap& map = impl_.alternative_service_map();
   net::AlternativeServiceMap::const_iterator it = map.begin();
   EXPECT_TRUE(it->first.Equals(test_server));
   ASSERT_EQ(2u, it->second.size());
   EXPECT_EQ(alternative_service1, it->second[0].alternative_service);
   EXPECT_EQ(alternative_service2, it->second[1].alternative_service);
 
-  impl_.ClearAlternativeServices(test_server);
+  impl_.SetAlternativeServices(test_server, AlternativeServiceInfoVector());
   EXPECT_TRUE(map.empty());
 }
 
 // A broken alternative service in the mapping carries meaningful information,
 // therefore it should not be ignored by SetAlternativeService().  In
 // particular, an alternative service mapped to an origin shadows alternative
 // services of canonical hosts.
 TEST_F(AlternateProtocolServerPropertiesTest, BrokenShadowsCanonical) {
   url::SchemeHostPort test_server("https", "foo.c.youtube.com", 443);
   url::SchemeHostPort canonical_server("https", "bar.c.youtube.com", 443);
@@ skipping 16 matching lines @@
   EXPECT_TRUE(impl_.IsAlternativeServiceBroken(broken_alternative_service));
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, ClearBroken) {
   url::SchemeHostPort test_server("http", "foo", 80);
   const AlternativeService alternative_service(NPN_HTTP_2, "foo", 443);
   SetAlternativeService(test_server, alternative_service);
   impl_.MarkAlternativeServiceBroken(alternative_service);
   ASSERT_TRUE(HasAlternativeService(test_server));
   EXPECT_TRUE(impl_.IsAlternativeServiceBroken(alternative_service));
-  // ClearAlternativeServices should leave a broken alternative service marked
+  // SetAlternativeServices should leave a broken alternative service marked
   // as such.
-  impl_.ClearAlternativeServices(test_server);
+  impl_.SetAlternativeServices(test_server, AlternativeServiceInfoVector());
   EXPECT_TRUE(impl_.IsAlternativeServiceBroken(alternative_service));
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, MarkRecentlyBroken) {
   url::SchemeHostPort server("http", "foo", 80);
   const AlternativeService alternative_service(NPN_HTTP_2, "foo", 443);
   SetAlternativeService(server, alternative_service);
 
   EXPECT_FALSE(impl_.IsAlternativeServiceBroken(alternative_service));
   EXPECT_FALSE(impl_.WasAlternativeServiceRecentlyBroken(alternative_service));
@@ skipping 48 matching lines @@
             impl_.GetCanonicalSuffix(canonical_server.host()));
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, ClearCanonical) {
   url::SchemeHostPort test_server("https", "foo.c.youtube.com", 443);
   url::SchemeHostPort canonical_server("https", "bar.c.youtube.com", 443);
   AlternativeService canonical_alternative_service(QUIC, "bar.c.youtube.com",
                                                    1234);
 
   SetAlternativeService(canonical_server, canonical_alternative_service);
-  impl_.ClearAlternativeServices(canonical_server);
+  impl_.SetAlternativeServices(canonical_server,
+                               AlternativeServiceInfoVector());
   EXPECT_FALSE(HasAlternativeService(test_server));
 }
 
 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalBroken) {
   url::SchemeHostPort test_server("https", "foo.c.youtube.com", 443);
   url::SchemeHostPort canonical_server("https", "bar.c.youtube.com", 443);
   AlternativeService canonical_alternative_service(QUIC, "bar.c.youtube.com",
                                                    1234);
 
   SetAlternativeService(canonical_server, canonical_alternative_service);
@@ skipping 602 matching lines @@
   EXPECT_EQ(quic_server_info1, *(impl_.GetQuicServerInfo(quic_server_id)));
 
   impl_.Clear();
   EXPECT_EQ(0u, impl_.quic_server_info_map().size());
   EXPECT_EQ(nullptr, impl_.GetQuicServerInfo(quic_server_id));
 }
 
 }  // namespace
 
 }  // namespace net