Remove |parse_alternative_service| flag.

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 312 matching lines @@
   const char* GetAlternateProtocolFromParam() {
     return AlternateProtocolToString(
         AlternateProtocolFromNextProto(GetProtocol()));
   }
 
   std::string GetAlternativeServiceHttpHeader() {
     return std::string("Alt-Svc: ") + GetAlternateProtocolFromParam() +
            "=\"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
   // other argument should be NULL.
   void KeepAliveConnectionResendRequestTest(const MockWrite* write_failure,
                                             const MockRead* read_failure);
 
   // 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
@@ skipping 8506 matching lines @@
        true,
       },
       {
        "",  // unused
        "http://host.with.alternate/direct",
        "ssl/host.with.alternate:443",
        true,
       },
   };
 
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     session_deps_.proxy_service =
         ProxyService::CreateFixed(tests[i].proxy_server);
     std::unique_ptr<HttpNetworkSession> session(
         SetupSessionForGroupNameTests(GetProtocol(), &session_deps_));
 
     HttpNetworkSessionPeer peer(session.get());
     CaptureGroupNameTransportSocketPool* transport_conn_pool =
@@ skipping 42 matching lines @@
       },
 
       {
        "http_proxy",
        "ftp://ftp.google.com/http_proxy_normal",
        "ftp/ftp.google.com:21",
        false,
       },
   };
 
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     session_deps_.proxy_service =
         ProxyService::CreateFixed(tests[i].proxy_server);
     std::unique_ptr<HttpNetworkSession> session(
         SetupSessionForGroupNameTests(GetProtocol(), &session_deps_));
 
     HttpNetworkSessionPeer peer(session.get());
 
@@ skipping 50 matching lines @@
       },
 
       {
        "socks4://socks_proxy:1080",
        "http://host.with.alternate/direct",
        "socks4/ssl/host.with.alternate:443",
        true,
       },
   };
 
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     session_deps_.proxy_service =
         ProxyService::CreateFixed(tests[i].proxy_server);
     std::unique_ptr<HttpNetworkSession> session(
         SetupSessionForGroupNameTests(GetProtocol(), &session_deps_));
 
     HttpNetworkSessionPeer peer(session.get());
 
@@ skipping 641 matching lines @@
       AuthCredentials(kFirst, kBar), callback4.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback4.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   EXPECT_FALSE(response->auth_challenge);
 }
 
 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 =
       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"),
@@ skipping 41 matching lines @@
   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);
 }
 
 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.
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   HttpServerProperties& http_server_properties =
       *session->http_server_properties();
   url::SchemeHostPort test_server("http", "www.example.org", 80);
   AlternativeService alternative_service(QUIC, "", 80);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties.SetAlternativeService(test_server, alternative_service,
@@ skipping 35 matching lines @@
 
   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());
 }
 
-// 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[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
       MockRead("Alt-Svc: "),
       MockRead(GetAlternateProtocolFromParam()),
       MockRead("=\"www.example.com:443\";p=\"1.0\","),
       MockRead(GetAlternateProtocolFromParam()),
       MockRead("=\":1234\"\r\n\r\n"),
       MockRead("hello world"),
@@ skipping 44 matching lines @@
   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);
   EXPECT_EQ(AlternateProtocolFromNextProto(GetProtocol()),
             alternative_service_vector[1].protocol);
   EXPECT_EQ("www.example.org", alternative_service_vector[1].host);
   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;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   request.load_flags = 0;
 
   MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
@@ skipping 55 matching lines @@
   };
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      http_writes, arraysize(http_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&http_data);
 
   StaticSocketDataProvider data_refused;
   data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
   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 =
       session->http_server_properties();
   AlternativeService alternative_service(QUIC, alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(server, alternative_service,
                                                 expiration);
   // Mark the QUIC alternative service as broken.
   http_server_properties->MarkAlternativeServiceBroken(alternative_service);
@@ skipping 40 matching lines @@
                "first HTTP/1.1 response from alternative1"),
   };
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      http_writes, arraysize(http_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&http_data);
 
   StaticSocketDataProvider data_refused;
   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 =
       session->http_server_properties();
 
   // Set up two QUIC alternative services for server.
   AlternativeServiceInfoVector alternative_service_info_vector;
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
 
   AlternativeService alternative_service1(QUIC, alternative1);
@@ skipping 24 matching lines @@
   NetErrorDetails details;
   EXPECT_FALSE(details.quic_broken);
 
   trans->Start(&request, callback.callback(), BoundNetLog());
   trans->PopulateNetErrorDetails(&details);
   EXPECT_FALSE(details.quic_broken);
 }
 
 TEST_P(HttpNetworkTransactionTest,
        MarkBrokenAlternateProtocolAndFallback) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   request.load_flags = 0;
 
   MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
@@ skipping 46 matching lines @@
   EXPECT_TRUE(http_server_properties->IsAlternativeServiceBroken(
       alternative_service_vector[0]));
 }
 
 // Ensure that we are not allowed to redirect traffic via an alternate protocol
 // to an unrestricted (port >= 1024) when the original traffic was on a
 // restricted port (port < 1024).  Ensure that we can redirect in all other
 // cases.
 TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortRestrictedBlocked) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo restricted_port_request;
   restricted_port_request.method = "GET";
   restricted_port_request.url = GURL("http://www.example.org:1023/");
   restricted_port_request.load_flags = 0;
 
   MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
@@ skipping 31 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Invalid change to unrestricted port should fail.
   EXPECT_EQ(ERR_CONNECTION_REFUSED, callback.WaitForResult());
 }
 
 // Ensure that we are allowed to redirect traffic via an alternate protocol to
 // an unrestricted (port >= 1024) when the original traffic was on a restricted
 // 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;
 
   HttpRequestInfo restricted_port_request;
   restricted_port_request.method = "GET";
   restricted_port_request.url = GURL("http://www.example.org:1023/");
   restricted_port_request.load_flags = 0;
 
   MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
@@ skipping 32 matching lines @@
   // Change to unrestricted port should succeed.
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Ensure that we are not allowed to redirect traffic via an alternate protocol
 // to an unrestricted (port >= 1024) when the original traffic was on a
 // restricted port (port < 1024).  Ensure that we can redirect in all other
 // cases.
 TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortRestrictedAllowed) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo restricted_port_request;
   restricted_port_request.method = "GET";
   restricted_port_request.url = GURL("http://www.example.org:1023/");
   restricted_port_request.load_flags = 0;
 
   MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
@@ skipping 32 matching lines @@
   // Valid change to restricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Ensure that we are not allowed to redirect traffic via an alternate protocol
 // to an unrestricted (port >= 1024) when the original traffic was on a
 // restricted port (port < 1024).  Ensure that we can redirect in all other
 // cases.
 TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortUnrestrictedAllowed1) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo unrestricted_port_request;
   unrestricted_port_request.method = "GET";
   unrestricted_port_request.url = GURL("http://www.example.org:1024/");
   unrestricted_port_request.load_flags = 0;
 
   MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
@@ skipping 31 matching lines @@
   // Valid change to restricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Ensure that we are not allowed to redirect traffic via an alternate protocol
 // to an unrestricted (port >= 1024) when the original traffic was on a
 // restricted port (port < 1024).  Ensure that we can redirect in all other
 // cases.
 TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortUnrestrictedAllowed2) {
-  session_deps_.parse_alternative_services = true;
   session_deps_.enable_alternative_service_with_different_host = false;
 
   HttpRequestInfo unrestricted_port_request;
   unrestricted_port_request.method = "GET";
   unrestricted_port_request.url = GURL("http://www.example.org:1024/");
   unrestricted_port_request.load_flags = 0;
 
   MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
   first_data.set_connect_data(mock_connect);
@@ skipping 29 matching lines @@
       &unrestricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Valid change to an unrestricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Ensure that we are not allowed to redirect traffic via an alternate protocol
 // 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;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   request.load_flags = 0;
 
   // The alternate protocol request will error out before we attempt to connect,
   // so only the standard HTTP request will try to connect.
   MockRead data_reads[] = {
@@ skipping 30 matching lines @@
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 }
 
 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),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
@@ skipping 56 matching lines @@
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
 }
 
 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),
       MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   // Socket 1 is the HTTP transaction with the Alternate-Protocol header.
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
@@ skipping 90 matching lines @@
   response = trans3.GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans3, &response_data));
   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),
       MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
 
@@ skipping 93 matching lines @@
       const net::CompletionCallback& callback,
       std::unique_ptr<Request>* request) override {
     resolver->reset(new ForwardingProxyResolver(resolver_));
     return OK;
   }
 
  private:
   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);
   proxy_config.set_pac_url(GURL("http://fooproxyurl"));
 
   CapturingProxyResolver capturing_proxy_resolver;
   session_deps_.proxy_service.reset(new ProxyService(
       base::WrapUnique(new ProxyConfigServiceFixed(proxy_config)),
       base::WrapUnique(
           new CapturingProxyResolverFactory(&capturing_proxy_resolver)),
       NULL));
   TestNetLog net_log;
   session_deps_.net_log = &net_log;
 
   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),
       MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(GetProtocol());
   ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
   ASSERT_TRUE(ssl.cert);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   std::unique_ptr<SpdySerializedFrame> req(
       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),
   };
 
   const char kCONNECTResponse[] = "HTTP/1.1 200 Connected\r\n\r\n";
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> data(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
@@ skipping 56 matching lines @@
   EXPECT_EQ("https://www.example.org/",
             capturing_proxy_resolver.resolved()[1].spec());
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReusedWithPac(load_timing_info,
                                  CONNECT_TIMING_HAS_SSL_TIMES);
 }
 
 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),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
@@ skipping 32 matching lines @@
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   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 =
       CreateSecureSpdySession(session.get(), key, BoundNetLog());
 
   trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
@@ skipping 616 matching lines @@
   rv = trans_compete->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
 
   // Finally, the socket is released to the group.
   EXPECT_EQ(1, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 }
 
 // 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;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
   request.load_flags = 0;
 
   MockWrite data_writes[] = {
       MockWrite(
           "GET / HTTP/1.1\r\n"
           "Host: www.example.org\r\n"
           "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),
   };
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(kProtoHTTP11);
 
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
@@ skipping 22 matching lines @@
   EXPECT_EQ("hello world", response_data);
 
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 }
 
 // Simulate the SSL handshake completing with an NPN negotiation followed by an
 // 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;
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
   request.load_flags = 0;
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(GetProtocol());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
@@ skipping 39 matching lines @@
     return HttpAuthHandlerMock::GenerateAuthTokenImpl(
         credentials, request, callback, auth_token);
   }
 
  private:
   GURL* url_;
 };
 
 // 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 =
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70");
   TestNetLog net_log;
   session_deps_.net_log = &net_log;
   GURL request_url;
   {
     HttpAuthHandlerMock::Factory* auth_factory =
         new HttpAuthHandlerMock::Factory();
@@ skipping 11 matching lines @@
 
   // First round goes unauthenticated through the proxy.
   MockWrite data_writes_1[] = {
       MockWrite(
           "GET http://www.example.org/ HTTP/1.1\r\n"
           "Host: www.example.org\r\n"
           "Proxy-Connection: keep-alive\r\n"
           "\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));
 
   // Second round tries to tunnel to www.example.org due to the
   // Alternate-Protocol announcement in the first round. It fails due
   // to a proxy authentication challenge.
   // After the failure, a tunnel is established to www.example.org using
   // Proxy-Authorization headers. There is then a SPDY request round.
   //
@@ skipping 874 matching lines @@
     // certificate was removed from the client auth cache.
     ASSERT_FALSE(session->ssl_client_auth_cache()->Lookup(
         HostPortPair("proxy", 70), &client_cert, &client_private_key));
     ASSERT_FALSE(session->ssl_client_auth_cache()->Lookup(
         HostPortPair("www.example.com", 443), &client_cert,
         &client_private_key));
   }
 }
 
 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.
   session_deps_.host_resolver.reset(new MockCachingHostResolver());
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
   pool_peer.DisableDomainAuthenticationVerification();
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(GetProtocol());
@@ skipping 77 matching lines @@
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers);
   EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans2, &response_data));
   EXPECT_EQ("hello!", response_data);
 }
 
 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.
   session_deps_.host_resolver.reset(new MockCachingHostResolver());
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
   pool_peer.DisableDomainAuthenticationVerification();
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(GetProtocol());
@@ skipping 105 matching lines @@
     return &host_resolver_;
   }
 
  private:
   MockCachingHostResolver host_resolver_;
   const HostPortPair host_port_;
 };
 
 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.
   OneTimeCachingHostResolver host_resolver(HostPortPair("www.gmail.com", 443));
   HttpNetworkSession::Params params =
       SpdySessionDependencies::CreateSessionParams(&session_deps_);
   params.host_resolver = &host_resolver;
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
   pool_peer.DisableDomainAuthenticationVerification();
@@ skipping 237 matching lines @@
     SequencedSocketData data(reads.data(), reads.size(), writes.data(),
                              writes.size());
     session_deps_.socket_factory->AddSocketDataProvider(&data);
 
     // Connection to the server fails.
     MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
     StaticSocketDataProvider data_refused;
     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 =
         session->http_server_properties();
     AlternativeService alternative_service(
         AlternateProtocolFromNextProto(GetProtocol()), alternative);
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     http_server_properties->SetAlternativeService(server, alternative_service,
                                                   expiration);
 
@@ skipping 84 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   // This test documents that an alternate Job should not be used if HTTP/1.1 is
   // negotiated.  In order to test this, a failed connection to the server is
   // mocked.  This way the request relies on the alternate Job.
   StaticSocketDataProvider data_refused;
   data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
   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 =
       session->http_server_properties();
   AlternativeService alternative_service(
       AlternateProtocolFromNextProto(GetProtocol()), alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(server, alternative_service,
                                                 expiration);
 
@@ skipping 53 matching lines @@
       MockRead("HTTP/1.1 200 OK\r\n"),
       MockRead("Content-Type: text/html\r\n"),
       MockRead("Content-Length: 7\r\n\r\n"),
       MockRead("another"),
   };
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      http_writes, arraysize(http_writes));
   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 =
       session->http_server_properties();
   AlternativeService alternative_service(
       AlternateProtocolFromNextProto(GetProtocol()), alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(server, alternative_service,
                                                 expiration);
 
@@ skipping 89 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&http_data);
 
   // This test documents that an alternate Job should not pool to an already
   // existing HTTP/1.1 connection.  In order to test this, a failed connection
   // to the server is mocked.  This way |request2| relies on the alternate Job.
   StaticSocketDataProvider data_refused;
   data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
   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 =
       session->http_server_properties();
   AlternativeService alternative_service(
       AlternateProtocolFromNextProto(GetProtocol()), alternative);
   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
   http_server_properties->SetAlternativeService(server, alternative_service,
                                                 expiration);
 
@@ skipping 2307 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy);
   HttpRequestHeaders headers;
   ASSERT_TRUE(trans.GetFullRequestHeaders(&headers));
   EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding));
 }
 #endif  // !defined(OS_IOS)
 
 }  // namespace net