diff --git a/components/cronet/ios/cronet_environment.cc b/components/cronet/ios/cronet_environment.cc
index a9f9ebeaf17d4a..8f6fd6779f98eb 100644
--- a/components/cronet/ios/cronet_environment.cc
+++ b/components/cronet/ios/cronet_environment.cc
@@ -322,7 +322,6 @@ void CronetEnvironment::InitializeOnNetworkThread() {
   params.http_server_properties = main_context_->http_server_properties();
   params.net_log = main_context_->net_log();
   params.enable_http2 = http2_enabled();
-  params.parse_alternative_services = true;
   params.enable_quic = quic_enabled();
 
   for (const auto& quic_hint : quic_hints_) {
diff --git a/components/data_reduction_proxy/core/browser/data_reduction_proxy_io_data_unittest.cc b/components/data_reduction_proxy/core/browser/data_reduction_proxy_io_data_unittest.cc
index a0b95a3c5a5fae..1df67186845ff9 100644
--- a/components/data_reduction_proxy/core/browser/data_reduction_proxy_io_data_unittest.cc
+++ b/components/data_reduction_proxy/core/browser/data_reduction_proxy_io_data_unittest.cc
@@ -109,7 +109,6 @@ TEST_F(DataReductionProxyIODataTest, TestConstruction) {
       request_context->GetNetworkSessionParams();
   EXPECT_FALSE(http_params->enable_spdy31);
   EXPECT_FALSE(http_params->enable_http2);
-  EXPECT_TRUE(http_params->parse_alternative_services);
   EXPECT_TRUE(http_params->enable_alternative_service_with_different_host);
   EXPECT_FALSE(http_params->enable_quic);
 
diff --git a/components/network_session_configurator/network_session_configurator.cc b/components/network_session_configurator/network_session_configurator.cc
index 4e344e4fd3ab2c..f2736932faec63 100644
--- a/components/network_session_configurator/network_session_configurator.cc
+++ b/components/network_session_configurator/network_session_configurator.cc
@@ -45,20 +45,6 @@ const char kSpdyFieldTrialSpdy31GroupNamePrefix[] = "Spdy31Enabled";
 const char kSpdyFieldTrialSpdy4GroupNamePrefix[] = "Spdy4Enabled";
 const char kSpdyFieldTrialParametrizedPrefix[] = "Parametrized";
 
-// The AltSvc trial controls whether Alt-Svc headers are parsed.
-// Disabled:
-//     Alt-Svc headers are not parsed.
-//     Alternate-Protocol headers are parsed.
-// Enabled:
-//     Alt-Svc headers are parsed, but only same-host entries are used by
-//     default.  (Use "enable_alternative_service_with_different_host" QUIC
-//     parameter to enable entries with different hosts.)
-//     Alternate-Protocol headers are ignored for responses that have an Alt-Svc
-//     header.
-const char kAltSvcFieldTrialName[] = "ParseAltSvc";
-const char kAltSvcFieldTrialDisabledPrefix[] = "AltSvcDisabled";
-const char kAltSvcFieldTrialEnabledPrefix[] = "AltSvcEnabled";
-
 // Field trial for NPN.
 const char kNpnTrialName[] = "NPN";
 const char kNpnTrialEnabledGroupNamePrefix[] = "Enable";
@@ -154,18 +140,6 @@ void ConfigureSpdyParams(const base::CommandLine& command_line,
   }
 }
 
-void ConfigureAltSvcParams(const base::CommandLine& command_line,
-                           base::StringPiece altsvc_trial_group,
-                           net::HttpNetworkSession::Params* params) {
-  if (altsvc_trial_group.starts_with(kAltSvcFieldTrialEnabledPrefix)) {
-    params->parse_alternative_services = true;
-    return;
-  }
-  if (altsvc_trial_group.starts_with(kAltSvcFieldTrialDisabledPrefix)) {
-    params->parse_alternative_services = false;
-  }
-}
-
 void ConfigureNPNParams(const base::CommandLine& command_line,
                         base::StringPiece npn_trial_group,
                         net::HttpNetworkSession::Params* params) {
@@ -547,10 +521,6 @@ void ParseFieldTrialsAndCommandLineInternal(
   // The command line flags will be associated with a group that is reported so
   // long as trial is actually queried.
 
-  std::string altsvc_trial_group =
-      base::FieldTrialList::FindFullName(kAltSvcFieldTrialName);
-  ConfigureAltSvcParams(command_line, altsvc_trial_group, params);
-
   std::string quic_trial_group =
       base::FieldTrialList::FindFullName(kQuicFieldTrialName);
   VariationParameters quic_trial_params;
diff --git a/components/network_session_configurator/network_session_configurator_unittest.cc b/components/network_session_configurator/network_session_configurator_unittest.cc
index 4156c50dd9369d..c1e5fdfc72af38 100644
--- a/components/network_session_configurator/network_session_configurator_unittest.cc
+++ b/components/network_session_configurator/network_session_configurator_unittest.cc
@@ -57,7 +57,6 @@ TEST_F(NetworkSessionConfiguratorTest, Defaults) {
   EXPECT_FALSE(params_.enable_spdy31);
   EXPECT_TRUE(params_.enable_http2);
   EXPECT_FALSE(params_.enable_tcp_fast_open_for_ssl);
-  EXPECT_TRUE(params_.parse_alternative_services);
   EXPECT_TRUE(params_.enable_alternative_service_with_different_host);
   EXPECT_FALSE(params_.enable_npn);
   EXPECT_TRUE(params_.enable_priority_dependencies);
@@ -85,24 +84,6 @@ TEST_F(NetworkSessionConfiguratorTest, TestingFixedPort) {
   EXPECT_EQ(1234u, params_.testing_fixed_https_port);
 }
 
-TEST_F(NetworkSessionConfiguratorTest, AltSvcFieldTrialEnabled) {
-  base::FieldTrialList::CreateFieldTrial("ParseAltSvc", "AltSvcEnabled");
-
-  ParseFieldTrials();
-
-  EXPECT_TRUE(params_.parse_alternative_services);
-  EXPECT_TRUE(params_.enable_alternative_service_with_different_host);
-}
-
-TEST_F(NetworkSessionConfiguratorTest, AltSvcFieldTrialDisabled) {
-  base::FieldTrialList::CreateFieldTrial("ParseAltSvc", "AltSvcDisabled");
-
-  ParseFieldTrials();
-
-  EXPECT_FALSE(params_.parse_alternative_services);
-  EXPECT_TRUE(params_.enable_alternative_service_with_different_host);
-}
-
 TEST_F(NetworkSessionConfiguratorTest, SpdyFieldTrialHoldbackEnabled) {
   net::HttpStreamFactory::set_spdy_enabled(true);
   base::FieldTrialList::CreateFieldTrial("SPDY", "SpdyDisabled");
@@ -214,7 +195,6 @@ TEST_F(NetworkSessionConfiguratorTest, EnableQuicFromFieldTrialGroup) {
   EXPECT_FALSE(params_.quic_enable_non_blocking_io);
   EXPECT_FALSE(params_.quic_disable_disk_cache);
   EXPECT_FALSE(params_.quic_prefer_aes);
-  EXPECT_TRUE(params_.parse_alternative_services);
   EXPECT_TRUE(params_.enable_alternative_service_with_different_host);
   EXPECT_EQ(0, params_.quic_max_number_of_lossy_connections);
   EXPECT_EQ(1.0f, params_.quic_packet_loss_threshold);
@@ -279,7 +259,6 @@ TEST_F(NetworkSessionConfiguratorTest,
   ParseFieldTrialsAndCommandLine();
 
   EXPECT_FALSE(params_.enable_quic);
-  EXPECT_TRUE(params_.parse_alternative_services);
   EXPECT_TRUE(params_.enable_alternative_service_with_different_host);
 }
 
@@ -292,7 +271,6 @@ TEST_F(NetworkSessionConfiguratorTest,
   ParseFieldTrialsAndCommandLine();
 
   EXPECT_TRUE(params_.enable_quic);
-  EXPECT_TRUE(params_.parse_alternative_services);
   EXPECT_TRUE(params_.enable_alternative_service_with_different_host);
 }
 
@@ -524,8 +502,6 @@ TEST_F(NetworkSessionConfiguratorTest,
   ParseFieldTrials();
 
   EXPECT_TRUE(params_.enable_alternative_service_with_different_host);
-  // QUIC AltSvc pooling parameter should also enable AltSvc parsing.
-  EXPECT_TRUE(params_.parse_alternative_services);
 }
 
 TEST_F(NetworkSessionConfiguratorTest,
diff --git a/ios/crnet/crnet_environment.mm b/ios/crnet/crnet_environment.mm
index ead0435f727b89..9c4686dfc94a13 100644
--- a/ios/crnet/crnet_environment.mm
+++ b/ios/crnet/crnet_environment.mm
@@ -430,7 +430,6 @@ bool IsRequestSupported(NSURLRequest* request) override {
   params.net_log = main_context_->net_log();
   params.enable_spdy31 = spdy_enabled();
   params.enable_http2 = spdy_enabled();
-  params.parse_alternative_services = true;
   params.enable_quic = quic_enabled();
 
   if (!params.channel_id_service) {
diff --git a/jingle/glue/proxy_resolving_client_socket.cc b/jingle/glue/proxy_resolving_client_socket.cc
index c546cf97a201ac..9e3e61350608f2 100644
--- a/jingle/glue/proxy_resolving_client_socket.cc
+++ b/jingle/glue/proxy_resolving_client_socket.cc
@@ -86,8 +86,6 @@ ProxyResolvingClientSocket::ProxyResolvingClientSocket(
         reference_params->testing_fixed_https_port;
     session_params.enable_spdy31 = reference_params->enable_spdy31;
     session_params.enable_http2 = reference_params->enable_http2;
-    session_params.parse_alternative_services =
-        reference_params->parse_alternative_services;
     session_params.enable_alternative_service_with_different_host =
         reference_params->enable_alternative_service_with_different_host;
   }
diff --git a/net/http/bidirectional_stream_unittest.cc b/net/http/bidirectional_stream_unittest.cc
index 9fa41cf62a693e..8fe24c853070de 100644
--- a/net/http/bidirectional_stream_unittest.cc
+++ b/net/http/bidirectional_stream_unittest.cc
@@ -1467,7 +1467,6 @@ TEST_F(BidirectionalStreamTest, TestHonorAlternativeServiceHeader) {
   url::SchemeHostPort server("https", "www.example.org", 443);
   SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
                      PRIVACY_MODE_DISABLED);
-  session_deps_.parse_alternative_services = true;
   // Enable QUIC so that the alternative service header can be added to
   // HttpServerProperties.
   session_deps_.enable_quic = true;
diff --git a/net/http/http_network_session.cc b/net/http/http_network_session.cc
index a8259c6d07dbe0..48acec9e4ac13b 100644
--- a/net/http/http_network_session.cc
+++ b/net/http/http_network_session.cc
@@ -96,7 +96,6 @@ HttpNetworkSession::Params::Params()
       spdy_session_max_recv_window_size(kSpdySessionMaxRecvWindowSize),
       spdy_stream_max_recv_window_size(kSpdyStreamMaxRecvWindowSize),
       time_func(&base::TimeTicks::Now),
-      parse_alternative_services(true),
       enable_alternative_service_with_different_host(true),
       enable_npn(false),
       enable_priority_dependencies(true),
diff --git a/net/http/http_network_session.h b/net/http/http_network_session.h
index 41e172bedb7c8b..c44de945c0dd0a 100644
--- a/net/http/http_network_session.h
+++ b/net/http/http_network_session.h
@@ -94,8 +94,6 @@ class NET_EXPORT HttpNetworkSession
     size_t spdy_stream_max_recv_window_size;
     // Source of time for SPDY connections.
     SpdySessionPool::TimeFunc time_func;
-    // Whether to parse Alt-Svc headers.
-    bool parse_alternative_services;
     // Whether to enable Alt-Svc entries with hostname different than that of
     // the origin.
     bool enable_alternative_service_with_different_host;
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index 170b2ecf874230..6ff5d0bfd42bae 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -330,11 +330,6 @@ class HttpNetworkTransactionTest
            "=\"www.example.com:443\"\r\n";
   }
 
-  std::string GetAlternateProtocolHttpHeader() {
-    return std::string("Alternate-Protocol: 443:") +
-           GetAlternateProtocolFromParam() + "\r\n";
-  }
-
   // Either |write_failure| specifies a write failure or |read_failure|
   // specifies a read failure when using a reused socket.  In either case, the
   // failure should cause the network transaction to resend the request, and the
@@ -8861,7 +8856,6 @@ TEST_P(HttpNetworkTransactionTest, GroupNameForDirectConnections) {
       },
   };
 
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
@@ -8924,7 +8918,6 @@ TEST_P(HttpNetworkTransactionTest, GroupNameForHTTPProxyConnections) {
       },
   };
 
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
@@ -8995,7 +8988,6 @@ TEST_P(HttpNetworkTransactionTest, GroupNameForSOCKSConnections) {
       },
   };
 
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
@@ -9657,7 +9649,6 @@ TEST_P(HttpNetworkTransactionTest, ChangeAuthRealms) {
 }
 
 TEST_P(HttpNetworkTransactionTest, HonorAlternativeServiceHeader) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   std::string alternative_service_http_header =
@@ -9719,7 +9710,6 @@ TEST_P(HttpNetworkTransactionTest, HonorAlternativeServiceHeader) {
 }
 
 TEST_P(HttpNetworkTransactionTest, ClearAlternativeServices) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   // Set an alternative service for origin.
@@ -9775,67 +9765,7 @@ TEST_P(HttpNetworkTransactionTest, ClearAlternativeServices) {
   EXPECT_TRUE(alternative_service_vector.empty());
 }
 
-// Alternative Service headers must be ignored when
-// |parse_alternative_services| is false.
-TEST_P(HttpNetworkTransactionTest, DoNotHonorAlternativeServiceHeader) {
-  session_deps_.parse_alternative_services = false;
-
-  std::string alternative_service_http_header =
-      GetAlternativeServiceHttpHeader();
-
-  MockRead data_reads[] = {
-      MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternative_service_http_header.c_str()),
-      MockRead("\r\n"),
-      MockRead("hello world"),
-      MockRead(SYNCHRONOUS, OK),
-  };
-
-  HttpRequestInfo request;
-  request.method = "GET";
-  request.url = GURL("http://www.example.org/");
-  request.load_flags = 0;
-
-  StaticSocketDataProvider data(data_reads, arraysize(data_reads), nullptr, 0);
-
-  session_deps_.socket_factory->AddSocketDataProvider(&data);
-
-  TestCompletionCallback callback;
-
-  std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_);
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
-
-  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-
-  url::SchemeHostPort test_server("http", "www.example.org", 80);
-  HttpServerProperties& http_server_properties =
-      *session->http_server_properties();
-  AlternativeServiceVector alternative_service_vector =
-      http_server_properties.GetAlternativeServices(test_server);
-  EXPECT_TRUE(alternative_service_vector.empty());
-
-  EXPECT_EQ(OK, callback.WaitForResult());
-
-  const HttpResponseInfo* response = trans->GetResponseInfo();
-  ASSERT_TRUE(response);
-  ASSERT_TRUE(response->headers);
-  EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
-  EXPECT_FALSE(response->was_fetched_via_spdy);
-  EXPECT_FALSE(response->was_npn_negotiated);
-
-  std::string response_data;
-  ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
-  EXPECT_EQ("hello world", response_data);
-
-  alternative_service_vector =
-      http_server_properties.GetAlternativeServices(test_server);
-  EXPECT_TRUE(alternative_service_vector.empty());
-}
-
 TEST_P(HttpNetworkTransactionTest, HonorMultipleAlternativeServiceHeader) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   MockRead data_reads[] = {
@@ -9900,199 +9830,9 @@ TEST_P(HttpNetworkTransactionTest, HonorMultipleAlternativeServiceHeader) {
   EXPECT_EQ(1234, alternative_service_vector[1].port);
 }
 
-// Alternate Protocol headers must be honored even if
-// |parse_alternative_services| is false.
-TEST_P(HttpNetworkTransactionTest, HonorAlternateProtocolHeader) {
-  session_deps_.parse_alternative_services = false;
-
-  std::string alternate_protocol_http_header =
-      GetAlternateProtocolHttpHeader();
-
-  MockRead data_reads[] = {
-      MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternate_protocol_http_header.c_str()),
-      MockRead("\r\n"),
-      MockRead("hello world"),
-      MockRead(SYNCHRONOUS, OK),
-  };
-
-  HttpRequestInfo request;
-  request.method = "GET";
-  request.url = GURL("http://www.example.org/");
-  request.load_flags = 0;
-
-  StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
-
-  session_deps_.socket_factory->AddSocketDataProvider(&data);
-
-  TestCompletionCallback callback;
-
-  std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
-
-  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-
-  url::SchemeHostPort test_server("http", "www.example.org", 80);
-  HttpServerProperties& http_server_properties =
-      *session->http_server_properties();
-  AlternativeServiceVector alternative_service_vector =
-      http_server_properties.GetAlternativeServices(test_server);
-  EXPECT_TRUE(alternative_service_vector.empty());
-
-  EXPECT_EQ(OK, callback.WaitForResult());
-
-  const HttpResponseInfo* response = trans->GetResponseInfo();
-  ASSERT_TRUE(response);
-  ASSERT_TRUE(response->headers);
-  EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
-  EXPECT_FALSE(response->was_fetched_via_spdy);
-  EXPECT_FALSE(response->was_npn_negotiated);
-
-  std::string response_data;
-  ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
-  EXPECT_EQ("hello world", response_data);
-
-  alternative_service_vector =
-      http_server_properties.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(443, alternative_service_vector[0].port);
-  EXPECT_EQ(AlternateProtocolFromNextProto(GetProtocol()),
-            alternative_service_vector[0].protocol);
-}
-
-TEST_P(HttpNetworkTransactionTest, EmptyAlternateProtocolHeader) {
-  session_deps_.parse_alternative_services = false;
-  session_deps_.enable_alternative_service_with_different_host = false;
-
-  MockRead data_reads[] = {
-      MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead("Alternate-Protocol: \r\n\r\n"),
-      MockRead("hello world"),
-      MockRead(SYNCHRONOUS, OK),
-  };
-
-  HttpRequestInfo request;
-  request.method = "GET";
-  request.url = GURL("http://www.example.org/");
-  request.load_flags = 0;
-
-  StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
-
-  session_deps_.socket_factory->AddSocketDataProvider(&data);
-
-  TestCompletionCallback callback;
-
-  std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-
-  url::SchemeHostPort test_server("http", "www.example.org", 80);
-  HttpServerProperties& http_server_properties =
-      *session->http_server_properties();
-  AlternativeService alternative_service(QUIC, "", 80);
-  base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
-  http_server_properties.SetAlternativeService(test_server, alternative_service,
-                                               expiration);
-
-  AlternativeServiceVector alternative_service_vector =
-      http_server_properties.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(QUIC, alternative_service_vector[0].protocol);
-
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
-
-  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-
-  EXPECT_EQ(OK, callback.WaitForResult());
-
-  const HttpResponseInfo* response = trans->GetResponseInfo();
-  ASSERT_TRUE(response);
-  ASSERT_TRUE(response->headers);
-  EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
-  EXPECT_FALSE(response->was_fetched_via_spdy);
-  EXPECT_FALSE(response->was_npn_negotiated);
-
-  std::string response_data;
-  ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
-  EXPECT_EQ("hello world", response_data);
-
-  alternative_service_vector =
-      http_server_properties.GetAlternativeServices(test_server);
-  EXPECT_TRUE(alternative_service_vector.empty());
-}
-
-// When |session_deps_.parse_alternative_services = true| and the response has
-// an Alt-Svc header, then the Alternate-Protocol header is not parsed.
-TEST_P(HttpNetworkTransactionTest, AltSvcOverwritesAlternateProtocol) {
-  session_deps_.parse_alternative_services = true;
-  session_deps_.enable_alternative_service_with_different_host = false;
-
-  std::string alternative_service_http_header =
-      GetAlternativeServiceHttpHeader();
-  std::string alternate_protocol_http_header = GetAlternateProtocolHttpHeader();
-
-  MockRead data_reads[] = {
-      MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternative_service_http_header.c_str()),
-      MockRead(alternate_protocol_http_header.c_str()),
-      MockRead("\r\n"),
-      MockRead("hello world"),
-      MockRead(SYNCHRONOUS, OK),
-  };
-
-  HttpRequestInfo request;
-  request.method = "GET";
-  request.url = GURL("http://www.example.org/");
-  request.load_flags = 0;
-
-  StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
-
-  session_deps_.socket_factory->AddSocketDataProvider(&data);
-
-  TestCompletionCallback callback;
-
-  std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
-  std::unique_ptr<HttpTransaction> trans(
-      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
-
-  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-
-  url::SchemeHostPort test_server("http", "www.example.org", 80);
-  HttpServerProperties& http_server_properties =
-      *session->http_server_properties();
-  AlternativeServiceVector alternative_service_vector =
-      http_server_properties.GetAlternativeServices(test_server);
-  EXPECT_TRUE(alternative_service_vector.empty());
-
-  EXPECT_EQ(OK, callback.WaitForResult());
-
-  const HttpResponseInfo* response = trans->GetResponseInfo();
-  ASSERT_TRUE(response);
-  ASSERT_TRUE(response->headers);
-  EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
-  EXPECT_FALSE(response->was_fetched_via_spdy);
-  EXPECT_FALSE(response->was_npn_negotiated);
-
-  std::string response_data;
-  ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
-  EXPECT_EQ("hello world", response_data);
-
-  alternative_service_vector =
-      http_server_properties.GetAlternativeServices(test_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  EXPECT_EQ(AlternateProtocolFromNextProto(GetProtocol()),
-            alternative_service_vector[0].protocol);
-  EXPECT_EQ("www.example.com", alternative_service_vector[0].host);
-  EXPECT_EQ(443, alternative_service_vector[0].port);
-}
-
 // When |enable_alternative_service_with_different_host| is false, do not
 // observe alternative service entries that point to a different host.
 TEST_P(HttpNetworkTransactionTest, DisableAlternativeServiceToDifferentHost) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo request;
@@ -10168,7 +9908,6 @@ TEST_P(HttpNetworkTransactionTest, IdentifyQuicBroken) {
   session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
 
   // Set up a QUIC alternative service for server.
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   base::WeakPtr<HttpServerProperties> http_server_properties =
@@ -10229,7 +9968,6 @@ TEST_P(HttpNetworkTransactionTest, IdentifyQuicNotBroken) {
   data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
   session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
 
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = true;
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   base::WeakPtr<HttpServerProperties> http_server_properties =
@@ -10274,7 +10012,6 @@ TEST_P(HttpNetworkTransactionTest, IdentifyQuicNotBroken) {
 
 TEST_P(HttpNetworkTransactionTest,
        MarkBrokenAlternateProtocolAndFallback) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo request;
@@ -10341,7 +10078,6 @@ TEST_P(HttpNetworkTransactionTest,
 // cases.
 TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortRestrictedBlocked) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo restricted_port_request;
@@ -10393,7 +10129,6 @@ TEST_P(HttpNetworkTransactionTest,
 // port (port < 1024) if we set |enable_user_alternate_protocol_ports|.
 TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortRestrictedPermitted) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
   session_deps_.enable_user_alternate_protocol_ports = true;
 
@@ -10446,7 +10181,6 @@ TEST_P(HttpNetworkTransactionTest,
 // cases.
 TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortRestrictedAllowed) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo restricted_port_request;
@@ -10499,7 +10233,6 @@ TEST_P(HttpNetworkTransactionTest,
 // cases.
 TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortUnrestrictedAllowed1) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo unrestricted_port_request;
@@ -10551,7 +10284,6 @@ TEST_P(HttpNetworkTransactionTest,
 // cases.
 TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortUnrestrictedAllowed2) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo unrestricted_port_request;
@@ -10601,7 +10333,6 @@ TEST_P(HttpNetworkTransactionTest,
 // to an unsafe port, and that we resume the second HttpStreamFactoryImpl::Job
 // once the alternate protocol request fails.
 TEST_P(HttpNetworkTransactionTest, AlternateProtocolUnsafeBlocked) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo request;
@@ -10652,20 +10383,19 @@ TEST_P(HttpNetworkTransactionTest, AlternateProtocolUnsafeBlocked) {
 }
 
 TEST_P(HttpNetworkTransactionTest, UseAlternateProtocolForNpnSpdy) {
-  session_deps_.parse_alternative_services = false;
-  session_deps_.enable_alternative_service_with_different_host = false;
+  session_deps_.enable_alternative_service_with_different_host = true;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   request.load_flags = 0;
 
-  std::string alternate_protocol_http_header =
-      GetAlternateProtocolHttpHeader();
+  std::string alternative_service_http_header =
+      GetAlternativeServiceHttpHeader();
 
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternate_protocol_http_header.c_str()),
+      MockRead(alternative_service_http_header.c_str()),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
@@ -10742,20 +10472,19 @@ TEST_P(HttpNetworkTransactionTest, UseAlternateProtocolForNpnSpdy) {
 }
 
 TEST_P(HttpNetworkTransactionTest, AlternateProtocolWithSpdyLateBinding) {
-  session_deps_.parse_alternative_services = false;
-  session_deps_.enable_alternative_service_with_different_host = false;
+  session_deps_.enable_alternative_service_with_different_host = true;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   request.load_flags = 0;
 
-  std::string alternate_protocol_http_header =
-      GetAlternateProtocolHttpHeader();
+  std::string alternative_service_http_header =
+      GetAlternativeServiceHttpHeader();
 
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternate_protocol_http_header.c_str()),
+      MockRead(alternative_service_http_header.c_str()),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
@@ -10866,21 +10595,20 @@ TEST_P(HttpNetworkTransactionTest, AlternateProtocolWithSpdyLateBinding) {
   EXPECT_EQ("hello!", response_data);
 }
 
-TEST_P(HttpNetworkTransactionTest, StallAlternateProtocolForNpnSpdy) {
-  session_deps_.parse_alternative_services = false;
-  session_deps_.enable_alternative_service_with_different_host = false;
+TEST_P(HttpNetworkTransactionTest, StallAlternativeServiceForNpnSpdy) {
+  session_deps_.enable_alternative_service_with_different_host = true;
 
   HttpRequestInfo request;
   request.method = "GET";
-  request.url = GURL("http://www.example.org/");
+  request.url = GURL("http://www.example.com/");
   request.load_flags = 0;
 
-  std::string alternate_protocol_http_header =
-      GetAlternateProtocolHttpHeader();
+  std::string alternative_service_http_header =
+      GetAlternativeServiceHttpHeader();
 
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternate_protocol_http_header.c_str()),
+      MockRead(alternative_service_http_header.c_str()),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
@@ -10994,10 +10722,8 @@ class CapturingProxyResolverFactory : public ProxyResolverFactory {
   ProxyResolver* resolver_;
 };
 
-TEST_P(HttpNetworkTransactionTest,
-       UseAlternateProtocolForTunneledNpnSpdy) {
-  session_deps_.parse_alternative_services = false;
-  session_deps_.enable_alternative_service_with_different_host = false;
+TEST_P(HttpNetworkTransactionTest, UseAlternativeServiceForTunneledNpnSpdy) {
+  session_deps_.enable_alternative_service_with_different_host = true;
 
   ProxyConfig proxy_config;
   proxy_config.set_auto_detect(true);
@@ -11017,12 +10743,12 @@ TEST_P(HttpNetworkTransactionTest,
   request.url = GURL("http://www.example.org/");
   request.load_flags = 0;
 
-  std::string alternate_protocol_http_header =
-      GetAlternateProtocolHttpHeader();
+  std::string alternative_service_http_header =
+      GetAlternativeServiceHttpHeader();
 
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternate_protocol_http_header.c_str()),
+      MockRead(alternative_service_http_header.c_str()),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
@@ -11043,8 +10769,8 @@ TEST_P(HttpNetworkTransactionTest,
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite spdy_writes[] = {
       MockWrite(ASYNC, 0,
-                "CONNECT www.example.org:443 HTTP/1.1\r\n"
-                "Host: www.example.org:443\r\n"
+                "CONNECT www.example.com:443 HTTP/1.1\r\n"
+                "Host: www.example.com:443\r\n"
                 "Proxy-Connection: keep-alive\r\n\r\n"),
       CreateMockWrite(*req, 2),
   };
@@ -11121,21 +10847,20 @@ TEST_P(HttpNetworkTransactionTest,
 }
 
 TEST_P(HttpNetworkTransactionTest,
-       UseAlternateProtocolForNpnSpdyWithExistingSpdySession) {
-  session_deps_.parse_alternative_services = false;
-  session_deps_.enable_alternative_service_with_different_host = false;
+       UseAlternativeServiceForNpnSpdyWithExistingSpdySession) {
+  session_deps_.enable_alternative_service_with_different_host = true;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   request.load_flags = 0;
 
-  std::string alternate_protocol_http_header =
-      GetAlternateProtocolHttpHeader();
+  std::string alternative_service_http_header =
+      GetAlternativeServiceHttpHeader();
 
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternate_protocol_http_header.c_str()),
+      MockRead(alternative_service_http_header.c_str()),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(ASYNC, OK),
@@ -11188,7 +10913,7 @@ TEST_P(HttpNetworkTransactionTest,
   EXPECT_EQ("hello world", response_data);
 
   // Set up an initial SpdySession in the pool to reuse.
-  HostPortPair host_port_pair("www.example.org", 443);
+  HostPortPair host_port_pair("www.example.com", 443);
   SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
                      PRIVACY_MODE_DISABLED);
   base::WeakPtr<SpdySession> spdy_session =
@@ -11825,7 +11550,6 @@ TEST_P(HttpNetworkTransactionTest, MultiRoundAuth) {
 // This tests the case that a request is issued via http instead of spdy after
 // npn is negotiated.
 TEST_P(HttpNetworkTransactionTest, NpnWithHttpOverSSL) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo request;
@@ -11840,12 +11564,12 @@ TEST_P(HttpNetworkTransactionTest, NpnWithHttpOverSSL) {
           "Connection: keep-alive\r\n\r\n"),
   };
 
-  std::string alternate_protocol_http_header =
-      GetAlternateProtocolHttpHeader();
+  std::string alternative_service_http_header =
+      GetAlternativeServiceHttpHeader();
 
   MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(alternate_protocol_http_header.c_str()),
+      MockRead(alternative_service_http_header.c_str()),
       MockRead("\r\n"),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, OK),
@@ -11888,7 +11612,6 @@ TEST_P(HttpNetworkTransactionTest, NpnWithHttpOverSSL) {
 // immediate server closing of the socket.
 // Regression test for https://crbug.com/46369.
 TEST_P(HttpNetworkTransactionTest, SpdyPostNPNServerHangup) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo request;
@@ -11948,8 +11671,7 @@ class UrlRecordingHttpAuthHandlerMock : public HttpAuthHandlerMock {
 
 // This test ensures that the URL passed into the proxy is upgraded to https
 // when doing an Alternate Protocol upgrade.
-TEST_P(HttpNetworkTransactionTest, SpdyAlternateProtocolThroughProxy) {
-  session_deps_.parse_alternative_services = false;
+TEST_P(HttpNetworkTransactionTest, SpdyAlternativeServiceThroughProxy) {
   session_deps_.enable_alternative_service_with_different_host = false;
 
   session_deps_.proxy_service =
@@ -11981,13 +11703,13 @@ TEST_P(HttpNetworkTransactionTest, SpdyAlternateProtocolThroughProxy) {
           "\r\n"),
   };
   MockRead data_reads_1[] = {
-    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-    MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead("Alternate-Protocol: 443:"),
-    MockRead(GetAlternateProtocolFromParam()),
-    MockRead("\r\n"),
-    MockRead("Proxy-Connection: close\r\n"),
-    MockRead("\r\n"),
+      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+      MockRead("HTTP/1.1 200 OK\r\n"),
+      MockRead("Alt-Svc: "),
+      MockRead(GetAlternateProtocolFromParam()),
+      MockRead("=\":443\"\r\n"),
+      MockRead("Proxy-Connection: close\r\n"),
+      MockRead("\r\n"),
   };
   StaticSocketDataProvider data_1(data_reads_1, arraysize(data_reads_1),
                                   data_writes_1, arraysize(data_writes_1));
@@ -12882,7 +12604,6 @@ TEST_P(HttpNetworkTransactionTest, ClientAuthCertCache_Proxy_Fail) {
 }
 
 TEST_P(HttpNetworkTransactionTest, UseIPConnectionPooling) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   // Set up a special HttpNetworkSession with a MockCachingHostResolver.
@@ -12980,7 +12701,6 @@ TEST_P(HttpNetworkTransactionTest, UseIPConnectionPooling) {
 }
 
 TEST_P(HttpNetworkTransactionTest, UseIPConnectionPoolingAfterResolution) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   // Set up a special HttpNetworkSession with a MockCachingHostResolver.
@@ -13106,7 +12826,6 @@ class OneTimeCachingHostResolver : public HostResolver {
 
 TEST_P(HttpNetworkTransactionTest,
        UseIPConnectionPoolingWithHostCacheExpiration) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   // Set up a special HttpNetworkSession with a OneTimeCachingHostResolver.
@@ -13364,7 +13083,6 @@ class AltSvcCertificateVerificationTest : public HttpNetworkTransactionTest {
     data_refused.set_connect_data(mock_connect);
     session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
 
-    session_deps_.parse_alternative_services = true;
     session_deps_.enable_alternative_service_with_different_host = true;
     std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
     base::WeakPtr<HttpServerProperties> http_server_properties =
@@ -13469,7 +13187,6 @@ TEST_P(HttpNetworkTransactionTest, AlternativeServiceNotOnHttp11) {
   session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
 
   // Set up alternative service for server.
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = true;
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   base::WeakPtr<HttpServerProperties> http_server_properties =
@@ -13543,7 +13260,6 @@ TEST_P(HttpNetworkTransactionTest, FailedAlternativeServiceIsNotUserVisible) {
   session_deps_.socket_factory->AddSocketDataProvider(&http_data);
 
   // Set up alternative service for server.
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = true;
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   base::WeakPtr<HttpServerProperties> http_server_properties =
@@ -13653,7 +13369,6 @@ TEST_P(HttpNetworkTransactionTest, AlternativeServiceShouldNotPoolToHttp11) {
   session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
 
   // Set up alternative service for server.
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   base::WeakPtr<HttpServerProperties> http_server_properties =
diff --git a/net/http/http_server_properties.cc b/net/http/http_server_properties.cc
index 850418d0b39ede..cea3032f0d108b 100644
--- a/net/http/http_server_properties.cc
+++ b/net/http/http_server_properties.cc
@@ -12,7 +12,6 @@
 
 namespace net {
 
-const char kAlternateProtocolHeader[] = "Alternate-Protocol";
 const char kAlternativeServiceHeader[] = "Alt-Svc";
 
 namespace {
diff --git a/net/http/http_server_properties.h b/net/http/http_server_properties.h
index fb8aaa405c24fa..d06b9b24856d52 100644
--- a/net/http/http_server_properties.h
+++ b/net/http/http_server_properties.h
@@ -214,7 +214,6 @@ typedef base::MRUCache<QuicServerId, std::string> QuicServerInfoMap;
 // Persist 5 QUIC Servers. This is mainly used by cronet.
 const int kMaxQuicServersToPersist = 5;
 
-extern const char kAlternateProtocolHeader[];
 extern const char kAlternativeServiceHeader[];
 
 // The interface for setting/retrieving the HTTP server properties.
diff --git a/net/http/http_stream_factory.cc b/net/http/http_stream_factory.cc
index b0f1780a762045..e94e5fadc5e952 100644
--- a/net/http/http_stream_factory.cc
+++ b/net/http/http_stream_factory.cc
@@ -38,58 +38,12 @@ void HttpStreamFactory::ProcessAlternativeServices(
     HttpNetworkSession* session,
     const HttpResponseHeaders* headers,
     const url::SchemeHostPort& http_server) {
-  if (session->params().parse_alternative_services) {
-    if (headers->HasHeader(kAlternativeServiceHeader)) {
-      std::string alternative_service_str;
-      headers->GetNormalizedHeader(kAlternativeServiceHeader,
-                                   &alternative_service_str);
-      ProcessAlternativeService(session->http_server_properties(),
-                                alternative_service_str, http_server, *session);
-    }
-    // If "Alt-Svc" is enabled, then ignore "Alternate-Protocol".
-    return;
-  }
-
-  if (!headers->HasHeader(kAlternateProtocolHeader))
+  if (!headers->HasHeader(kAlternativeServiceHeader))
     return;
 
-  std::vector<std::string> alternate_protocol_values;
-  size_t iter = 0;
-  std::string alternate_protocol_str;
-  while (headers->EnumerateHeader(&iter, kAlternateProtocolHeader,
-                                  &alternate_protocol_str)) {
-    base::TrimWhitespaceASCII(alternate_protocol_str, base::TRIM_ALL,
-                              &alternate_protocol_str);
-    if (!alternate_protocol_str.empty()) {
-      alternate_protocol_values.push_back(alternate_protocol_str);
-    }
-  }
-
-  ProcessAlternateProtocol(session->http_server_properties(),
-                           alternate_protocol_values, http_server, *session);
-}
-
-GURL HttpStreamFactory::ApplyHostMappingRules(const GURL& url,
-                                              HostPortPair* endpoint) {
-  const HostMappingRules* mapping_rules = GetHostMappingRules();
-  if (mapping_rules && mapping_rules->RewriteHost(endpoint)) {
-    url::Replacements<char> replacements;
-    const std::string port_str = base::UintToString(endpoint->port());
-    replacements.SetPort(port_str.c_str(), url::Component(0, port_str.size()));
-    replacements.SetHost(endpoint->host().c_str(),
-                         url::Component(0, endpoint->host().size()));
-    return url.ReplaceComponents(replacements);
-  }
-  return url;
-}
-
-HttpStreamFactory::HttpStreamFactory() {}
-
-void HttpStreamFactory::ProcessAlternativeService(
-    const base::WeakPtr<HttpServerProperties>& http_server_properties,
-    base::StringPiece alternative_service_str,
-    const url::SchemeHostPort& http_server,
-    const HttpNetworkSession& session) {
+  std::string alternative_service_str;
+  headers->GetNormalizedHeader(kAlternativeServiceHeader,
+                               &alternative_service_str);
   SpdyAltSvcWireFormat::AlternativeServiceVector alternative_service_vector;
   if (!SpdyAltSvcWireFormat::ParseHeaderFieldValue(
           alternative_service_str, &alternative_service_vector)) {
@@ -104,14 +58,14 @@ void HttpStreamFactory::ProcessAlternativeService(
     AlternateProtocol protocol =
         AlternateProtocolFromString(alternative_service_entry.protocol_id);
     if (!IsAlternateProtocolValid(protocol) ||
-        !session.IsProtocolEnabled(protocol) ||
+        !session->IsProtocolEnabled(protocol) ||
         !IsPortValid(alternative_service_entry.port)) {
       continue;
     }
     // Check if QUIC version is supported.
     if (protocol == QUIC && !alternative_service_entry.version.empty()) {
       bool match_found = false;
-      for (QuicVersion supported : session.params().quic_supported_versions) {
+      for (QuicVersion supported : session->params().quic_supported_versions) {
         for (uint16_t advertised : alternative_service_entry.version) {
           if (supported == advertised) {
             match_found = true;
@@ -137,69 +91,26 @@ void HttpStreamFactory::ProcessAlternativeService(
     alternative_service_info_vector.push_back(alternative_service_info);
   }
 
-  http_server_properties->SetAlternativeServices(
+  session->http_server_properties()->SetAlternativeServices(
       RewriteHost(http_server), alternative_service_info_vector);
 }
 
-void HttpStreamFactory::ProcessAlternateProtocol(
-    const base::WeakPtr<HttpServerProperties>& http_server_properties,
-    const std::vector<std::string>& alternate_protocol_values,
-    const url::SchemeHostPort& http_server,
-    const HttpNetworkSession& session) {
-  AlternateProtocol protocol = UNINITIALIZED_ALTERNATE_PROTOCOL;
-  int port = 0;
-  bool is_valid = true;
-  for (size_t i = 0; i < alternate_protocol_values.size(); ++i) {
-    base::StringPiece alternate_protocol_str = alternate_protocol_values[i];
-    if (base::StartsWith(alternate_protocol_str, "p=",
-                         base::CompareCase::SENSITIVE)) {
-      // Ignore deprecated probability.
-      continue;
-    }
-    std::vector<base::StringPiece> port_protocol_vector =
-        base::SplitStringPiece(alternate_protocol_str, ":",
-                               base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-    if (port_protocol_vector.size() != 2) {
-      DVLOG(1) << kAlternateProtocolHeader
-               << " header has too many tokens: "
-               << alternate_protocol_str;
-      is_valid = false;
-      break;
-    }
-
-    if (!ParseInt32(port_protocol_vector[0], ParseIntFormat::NON_NEGATIVE,
-                    &port) ||
-        port == 0 || !IsPortValid(port)) {
-      DVLOG(1) << kAlternateProtocolHeader
-               << " header has unrecognizable port: "
-               << port_protocol_vector[0];
-      is_valid = false;
-      break;
-    }
-
-    protocol = AlternateProtocolFromString(port_protocol_vector[1].as_string());
-
-    if (IsAlternateProtocolValid(protocol) &&
-        !session.IsProtocolEnabled(protocol)) {
-      DVLOG(1) << kAlternateProtocolHeader
-               << " header has unrecognized protocol: "
-               << port_protocol_vector[1];
-      is_valid = false;
-      break;
-    }
-  }
-
-  if (!is_valid || protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {
-    http_server_properties->ClearAlternativeServices(http_server);
-    return;
+GURL HttpStreamFactory::ApplyHostMappingRules(const GURL& url,
+                                              HostPortPair* endpoint) {
+  const HostMappingRules* mapping_rules = GetHostMappingRules();
+  if (mapping_rules && mapping_rules->RewriteHost(endpoint)) {
+    url::Replacements<char> replacements;
+    const std::string port_str = base::UintToString(endpoint->port());
+    replacements.SetPort(port_str.c_str(), url::Component(0, port_str.size()));
+    replacements.SetHost(endpoint->host().c_str(),
+                         url::Component(0, endpoint->host().size()));
+    return url.ReplaceComponents(replacements);
   }
-
-  http_server_properties->SetAlternativeService(
-      RewriteHost(http_server),
-      AlternativeService(protocol, "", static_cast<uint16_t>(port)),
-      base::Time::Now() + base::TimeDelta::FromDays(30));
+  return url;
 }
 
+HttpStreamFactory::HttpStreamFactory() {}
+
 url::SchemeHostPort HttpStreamFactory::RewriteHost(
     const url::SchemeHostPort& server) {
   HostPortPair host_port_pair(server.host(), server.port());
diff --git a/net/http/http_stream_factory.h b/net/http/http_stream_factory.h
index 6371a6e7359d4e..8dd4b42a1e6903 100644
--- a/net/http/http_stream_factory.h
+++ b/net/http/http_stream_factory.h
@@ -265,18 +265,6 @@ class NET_EXPORT HttpStreamFactory {
   HttpStreamFactory();
 
  private:
-  void ProcessAlternativeService(
-      const base::WeakPtr<HttpServerProperties>& http_server_properties,
-      base::StringPiece alternative_service_str,
-      const url::SchemeHostPort& http_server,
-      const HttpNetworkSession& session);
-
-  void ProcessAlternateProtocol(
-      const base::WeakPtr<HttpServerProperties>& http_server_properties,
-      const std::vector<std::string>& alternate_protocol_values,
-      const url::SchemeHostPort& http_server,
-      const HttpNetworkSession& session);
-
   static bool spdy_enabled_;
 
   url::SchemeHostPort RewriteHost(const url::SchemeHostPort& server);
diff --git a/net/http/http_stream_factory_impl_unittest.cc b/net/http/http_stream_factory_impl_unittest.cc
index 348a94e0264866..488f9209038421 100644
--- a/net/http/http_stream_factory_impl_unittest.cc
+++ b/net/http/http_stream_factory_impl_unittest.cc
@@ -1952,7 +1952,6 @@ TEST_P(HttpStreamFactoryTest, DISABLED_RequestWebSocketSpdyHandshakeStream) {
 TEST_P(HttpStreamFactoryTest, DISABLED_OrphanedWebSocketStream) {
   SpdySessionDependencies session_deps(GetParam(),
                                        ProxyService::CreateDirect());
-  session_deps.parse_alternative_services = true;
   session_deps.enable_alternative_service_with_different_host = false;
 
   MockRead mock_read(ASYNC, OK);
diff --git a/net/log/net_log_util.cc b/net/log/net_log_util.cc
index 15933e49180819..23088691210558 100644
--- a/net/log/net_log_util.cc
+++ b/net/log/net_log_util.cc
@@ -436,9 +436,6 @@ NET_EXPORT std::unique_ptr<base::DictionaryValue> GetNetInfo(
     status_dict->SetBoolean("enable_http2",
                             http_network_session->params().enable_http2 &&
                                 HttpStreamFactory::spdy_enabled());
-    status_dict->SetBoolean(
-        "use_alternative_services",
-        http_network_session->params().parse_alternative_services);
 
     NextProtoVector alpn_protos;
     http_network_session->GetAlpnProtos(&alpn_protos);
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index 19bf8a7786bd12..208fc4e2d95b3f 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -71,12 +71,6 @@ enum DestinationType {
   DIFFERENT,       // different from both.
 };
 
-static const char kQuicAlternateProtocolHeader[] =
-    "Alternate-Protocol: 443:quic\r\n\r\n";
-static const char kQuicAlternateProtocolWithProbabilityHeader[] =
-    "Alternate-Protocol: 443:quic,p=.5\r\n\r\n";
-static const char kQuicAlternateProtocolDifferentPortHeader[] =
-    "Alternate-Protocol: 137:quic\r\n\r\n";
 static const char kQuicAlternativeServiceHeader[] =
     "Alt-Svc: quic=\":443\"\r\n\r\n";
 static const char kQuicAlternativeServiceWithProbabilityHeader[] =
@@ -1585,201 +1579,7 @@ TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceForQuicForHttps) {
   SendRequestAndExpectHttpResponse("hello world");
 }
 
-TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolForQuic) {
-  MockRead http_reads[] = {
-      MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternateProtocolHeader),
-      MockRead("hello world"),
-      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-      MockRead(ASYNC, OK)};
-
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
-                                     0);
-  socket_factory_.AddSocketDataProvider(&http_data);
-  socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
-
-  MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      1, kClientDataStreamId1, true, true,
-      GetRequestHeaders("GET", "https", "/")));
-  mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
-  mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
-  mock_quic_data.AddRead(ASYNC, 0);               // EOF
-
-  mock_quic_data.AddSocketDataToFactory(&socket_factory_);
-
-  // The non-alternate protocol job needs to hang in order to guarantee that
-  // the alternate-protocol job will "win".
-  AddHangingNonAlternateProtocolSocketData();
-
-  params_.parse_alternative_services = false;
-  params_.parse_alternative_services = false;
-  CreateSession();
-
-  SendRequestAndExpectHttpResponse("hello world");
-  SendRequestAndExpectQuicResponse("hello!");
-}
-
-TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolWithProbabilityForQuic) {
-  MockRead http_reads[] = {
-      MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(kQuicAlternateProtocolWithProbabilityHeader),
-      MockRead("hello world"),
-      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-      MockRead(ASYNC, OK)};
-
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
-                                     0);
-  socket_factory_.AddSocketDataProvider(&http_data);
-  socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
-
-  MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      1, kClientDataStreamId1, true, true,
-      GetRequestHeaders("GET", "https", "/")));
-  mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
-  mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
-  mock_quic_data.AddRead(ASYNC, 0);               // EOF
-
-  mock_quic_data.AddSocketDataToFactory(&socket_factory_);
-
-  // The non-alternate protocol job needs to hang in order to guarantee that
-  // the alternate-protocol job will "win".
-  AddHangingNonAlternateProtocolSocketData();
-
-  params_.parse_alternative_services = false;
-  params_.parse_alternative_services = false;
-  CreateSession();
-
-  SendRequestAndExpectHttpResponse("hello world");
-  SendRequestAndExpectQuicResponse("hello!");
-}
-
-TEST_P(QuicNetworkTransactionTest, AlternateProtocolDifferentPort) {
-  MockRead http_reads[] = {
-      MockRead("HTTP/1.1 200 OK\r\n"),
-      MockRead(kQuicAlternateProtocolDifferentPortHeader),
-      MockRead("hello world"),
-      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-      MockRead(ASYNC, OK)};
-
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
-                                     0);
-  socket_factory_.AddSocketDataProvider(&http_data);
-  socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
-
-  // The non-alternate protocol job needs to hang in order to guarantee that
-  // the alternate-protocol job will "win".
-  AddHangingNonAlternateProtocolSocketData();
-
-  params_.parse_alternative_services = false;
-  CreateSession();
-
-  SendRequestAndExpectHttpResponse("hello world");
-
-  url::SchemeHostPort http_server("https", kDefaultServerHostName, 443);
-  AlternativeServiceVector alternative_service_vector =
-      http_server_properties_.GetAlternativeServices(http_server);
-  ASSERT_EQ(1u, alternative_service_vector.size());
-  const AlternativeService alternative_service = alternative_service_vector[0];
-  EXPECT_EQ(QUIC, alternative_service_vector[0].protocol);
-  EXPECT_EQ(kDefaultServerHostName, alternative_service_vector[0].host);
-  EXPECT_EQ(137, alternative_service_vector[0].port);
-}
-
-TEST_P(QuicNetworkTransactionTest, ConfirmAlternateProtocol) {
-  MockRead http_reads[] = {
-      MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternateProtocolHeader),
-      MockRead("hello world"),
-      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-      MockRead(ASYNC, OK)};
-
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
-                                     0);
-  socket_factory_.AddSocketDataProvider(&http_data);
-  socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
-
-  MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      1, kClientDataStreamId1, true, true,
-      GetRequestHeaders("GET", "https", "/")));
-  mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
-  mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
-  mock_quic_data.AddRead(ASYNC, 0);               // EOF
-
-  mock_quic_data.AddSocketDataToFactory(&socket_factory_);
-
-  // The non-alternate protocol job needs to hang in order to guarantee that
-  // the alternate-protocol job will "win".
-  AddHangingNonAlternateProtocolSocketData();
-
-  params_.parse_alternative_services = false;
-  CreateSession();
-
-  AlternativeService alternative_service(QUIC,
-                                         HostPortPair::FromURL(request_.url));
-  http_server_properties_.MarkAlternativeServiceRecentlyBroken(
-      alternative_service);
-  EXPECT_TRUE(http_server_properties_.WasAlternativeServiceRecentlyBroken(
-      alternative_service));
-
-  SendRequestAndExpectHttpResponse("hello world");
-  SendRequestAndExpectQuicResponse("hello!");
-
-  mock_quic_data.Resume();
-
-  EXPECT_FALSE(http_server_properties_.WasAlternativeServiceRecentlyBroken(
-      alternative_service));
-}
-
-TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolForQuicForHttps) {
-  MockRead http_reads[] = {
-      MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternateProtocolHeader),
-      MockRead("hello world"),
-      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-      MockRead(ASYNC, OK)};
-
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
-                                     0);
-  socket_factory_.AddSocketDataProvider(&http_data);
-
-  MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
-      1, kClientDataStreamId1, true, true,
-      GetRequestHeaders("GET", "https", "/")));
-  mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
-      1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK")));
-  mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1,
-                                                   false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1));
-  mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING);  // No more data to read
-  mock_quic_data.AddRead(ASYNC, 0);               // EOF
-
-  mock_quic_data.AddSocketDataToFactory(&socket_factory_);
-
-  // The non-alternate protocol job needs to hang in order to guarantee that
-  // the alternate-protocol job will "win".
-  AddHangingNonAlternateProtocolSocketData();
-
-  CreateSession();
-
-  // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo().
-  SendRequestAndExpectHttpResponse("hello world");
-}
-
-TEST_P(QuicNetworkTransactionTest, HungAlternateProtocol) {
-  params_.parse_alternative_services = false;
+TEST_P(QuicNetworkTransactionTest, HungAlternativeService) {
   crypto_client_stream_factory_.set_handshake_mode(
       MockCryptoClientStream::COLD_START);
 
@@ -1790,7 +1590,7 @@ TEST_P(QuicNetworkTransactionTest, HungAlternateProtocol) {
 
   MockRead http_reads[] = {
       MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
-      MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHeader),
+      MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader),
       MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)};
 
   SequencedSocketData http_data(http_reads, arraysize(http_reads), http_writes,
@@ -1896,7 +1696,7 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithProxy) {
 
   MockRead http_reads[] = {
       MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
-      MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHeader),
+      MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader),
       MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)};
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
@@ -2262,7 +2062,7 @@ TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) {
 
   // When the QUIC connection fails, we will try the request again over HTTP.
   MockRead http_reads[] = {
-      MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternateProtocolHeader),
+      MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader),
       MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
diff --git a/net/spdy/spdy_network_transaction_unittest.cc b/net/spdy/spdy_network_transaction_unittest.cc
index 219af702b47560..fd30f5b8b6e085 100644
--- a/net/spdy/spdy_network_transaction_unittest.cc
+++ b/net/spdy/spdy_network_transaction_unittest.cc
@@ -108,7 +108,6 @@ struct SpdyNetworkTransactionTestParams {
 
 void UpdateSpdySessionDependencies(SpdyNetworkTransactionTestParams test_params,
                                    SpdySessionDependencies* session_deps) {
-  session_deps->parse_alternative_services = true;
   session_deps->enable_alternative_service_with_different_host = true;
   if (test_params.ssl_type == HTTP_SPDY_VIA_ALT_SVC) {
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
diff --git a/net/spdy/spdy_test_util_common.cc b/net/spdy/spdy_test_util_common.cc
index 1a38a7088dab99..3c6bc76adbc731 100644
--- a/net/spdy/spdy_test_util_common.cc
+++ b/net/spdy/spdy_test_util_common.cc
@@ -349,7 +349,6 @@ SpdySessionDependencies::SpdySessionDependencies(NextProto protocol)
       stream_max_recv_window_size(
           SpdySession::GetDefaultInitialWindowSize(protocol)),
       time_func(&base::TimeTicks::Now),
-      parse_alternative_services(true),
       enable_alternative_service_with_different_host(true),
       net_log(NULL) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
@@ -388,7 +387,6 @@ SpdySessionDependencies::SpdySessionDependencies(
       stream_max_recv_window_size(
           SpdySession::GetDefaultInitialWindowSize(protocol)),
       time_func(&base::TimeTicks::Now),
-      parse_alternative_services(true),
       enable_alternative_service_with_different_host(true),
       net_log(NULL) {
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
@@ -441,7 +439,6 @@ HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
       session_deps->stream_max_recv_window_size;
   params.time_func = session_deps->time_func;
   params.proxy_delegate = session_deps->proxy_delegate.get();
-  params.parse_alternative_services = session_deps->parse_alternative_services;
   params.enable_alternative_service_with_different_host =
       session_deps->enable_alternative_service_with_different_host;
   params.net_log = session_deps->net_log;
diff --git a/net/spdy/spdy_test_util_common.h b/net/spdy/spdy_test_util_common.h
index 56146711683ab4..5f8c67afddd407 100644
--- a/net/spdy/spdy_test_util_common.h
+++ b/net/spdy/spdy_test_util_common.h
@@ -206,7 +206,6 @@ struct SpdySessionDependencies {
   size_t stream_max_recv_window_size;
   SpdySession::TimeFunc time_func;
   std::unique_ptr<ProxyDelegate> proxy_delegate;
-  bool parse_alternative_services;
   bool enable_alternative_service_with_different_host;
   NetLog* net_log;
 };
diff --git a/net/url_request/url_request_context_builder.cc b/net/url_request/url_request_context_builder.cc
index 8ec5bedd0cfdfa..edbca15f96b577 100644
--- a/net/url_request/url_request_context_builder.cc
+++ b/net/url_request/url_request_context_builder.cc
@@ -182,7 +182,6 @@ URLRequestContextBuilder::HttpNetworkSessionParams::HttpNetworkSessionParams()
       testing_fixed_https_port(0),
       enable_spdy31(false),
       enable_http2(true),
-      parse_alternative_services(true),
       enable_alternative_service_with_different_host(true),
       enable_quic(false),
       quic_max_server_configs_stored_in_properties(0),
@@ -412,8 +411,6 @@ std::unique_ptr<URLRequestContext> URLRequestContextBuilder::Build() {
       http_network_session_params_.enable_spdy31;
   network_session_params.enable_http2 =
       http_network_session_params_.enable_http2;
-  network_session_params.parse_alternative_services =
-      http_network_session_params_.parse_alternative_services;
   network_session_params.enable_alternative_service_with_different_host =
       http_network_session_params_
           .enable_alternative_service_with_different_host;
diff --git a/net/url_request/url_request_context_builder.h b/net/url_request/url_request_context_builder.h
index 2aa534f5865a68..ccdf5967b6738e 100644
--- a/net/url_request/url_request_context_builder.h
+++ b/net/url_request/url_request_context_builder.h
@@ -91,7 +91,6 @@ class NET_EXPORT URLRequestContextBuilder {
     uint16_t testing_fixed_https_port;
     bool enable_spdy31;
     bool enable_http2;
-    bool parse_alternative_services;
     bool enable_alternative_service_with_different_host;
     bool enable_quic;
     std::string quic_user_agent_id;