Change the AlternativeServiceMap with SchemeOriginPair key.

net/quic/quic_network_transaction_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 515 matching lines @@
   void SendRequestAndExpectQuicResponseFromProxyOnPort(
       const std::string& expected,
       uint16_t port) {
     SendRequestAndExpectQuicResponseMaybeFromProxy(expected, true, port);
   }
 
   void AddQuicAlternateProtocolMapping(
       MockCryptoClientStream::HandshakeMode handshake_mode) {
     crypto_client_stream_factory_.set_handshake_mode(handshake_mode);
     HostPortPair host_port_pair = HostPortPair::FromURL(request_.url);
+    SchemeOriginPair scheme_origin_pair =
+        SchemeOriginPair::FromURL(request_.url);
     AlternativeService alternative_service(QUIC, host_port_pair.host(), 443);
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     http_server_properties_.SetAlternativeService(
-        host_port_pair, alternative_service, 1.0, expiration);
+        scheme_origin_pair, alternative_service, 1.0, expiration);
   }
 
   void AddQuicRemoteAlternativeServiceMapping(
       MockCryptoClientStream::HandshakeMode handshake_mode,
       const HostPortPair& alternative) {
     crypto_client_stream_factory_.set_handshake_mode(handshake_mode);
     HostPortPair host_port_pair = HostPortPair::FromURL(request_.url);
+    SchemeOriginPair scheme_origin_pair =
+        SchemeOriginPair::FromURL(request_.url);
     AlternativeService alternative_service(QUIC, alternative.host(),
                                            alternative.port());
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     http_server_properties_.SetAlternativeService(
-        host_port_pair, alternative_service, 1.0, expiration);
+        scheme_origin_pair, alternative_service, 1.0, expiration);
   }
 
   void ExpectBrokenAlternateProtocolMapping() {
-    const HostPortPair origin = HostPortPair::FromURL(request_.url);
+    SchemeOriginPair scheme_origin = SchemeOriginPair::FromURL(request_.url);
     const AlternativeServiceVector alternative_service_vector =
-        http_server_properties_.GetAlternativeServices(origin);
+        http_server_properties_.GetAlternativeServices(scheme_origin);
     EXPECT_EQ(1u, alternative_service_vector.size());
     EXPECT_TRUE(http_server_properties_.IsAlternativeServiceBroken(
         alternative_service_vector[0]));
   }
 
   void ExpectQuicAlternateProtocolMapping() {
-    const HostPortPair origin = HostPortPair::FromURL(request_.url);
+    SchemeOriginPair scheme_origin = SchemeOriginPair::FromURL(request_.url);
     const AlternativeServiceVector alternative_service_vector =
-        http_server_properties_.GetAlternativeServices(origin);
+        http_server_properties_.GetAlternativeServices(scheme_origin);
     EXPECT_EQ(1u, alternative_service_vector.size());
     EXPECT_EQ(QUIC, alternative_service_vector[0].protocol);
   }
 
   void AddHangingNonAlternateProtocolSocketData() {
     scoped_ptr<StaticSocketDataProvider> hanging_data;
     hanging_data.reset(new StaticSocketDataProvider());
     MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
     hanging_data->set_connect_data(hanging_connect);
     hanging_data_.push_back(std::move(hanging_data));
@@ skipping 315 matching lines @@
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
 
   SendRequestAndExpectHttpResponse("hello world");
   SendRequestAndExpectQuicResponse("hello!");
 }
 
+TEST_P(QuicNetworkTransactionTest, SetAlternativeServiceForOriginWithScheme) {
+  MockRead http_reads[] = {
+      MockRead("HTTP/1.1 200 OK\r\n"),
+      MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"),
+      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_);
+
+  CreateSession();
+  // Send http request, ignore alternative service advertising if response
+  // header advertises alternative service for mail.example.org.
+  request_.url = GURL("http://mail.example.org:443");
+  SendRequestAndExpectHttpResponse("hello world");
+  base::WeakPtr<HttpServerProperties> http_server_properties =
+      session_->http_server_properties();
+  SchemeOriginPair http_origin = SchemeOriginPair::FromURL(request_.url);
+  SchemeOriginPair https_origin("https", HostPortPair::FromURL(request_.url));
+  // Check alternative service is set for the correct origin.
+  EXPECT_EQ(2u,
+            http_server_properties->GetAlternativeServices(http_origin).size());
+  EXPECT_EQ(
+      0u, http_server_properties->GetAlternativeServices(https_origin).size());
+}
+
+TEST_P(QuicNetworkTransactionTest, DoNotGetAltSvcForDifferentOrigin) {
+  MockRead http_reads[] = {
+      MockRead("HTTP/1.1 200 OK\r\n"),
+      MockRead("Alt-Svc: quic=\"foo.example.org:443\", quic=\":444\"\r\n\r\n"),
+      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_);
+  socket_factory_.AddSocketDataProvider(&http_data);
+  socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
+  CreateSession();
+
+  // Send https request and set alternative services if response header
+  // advertises alternative service for mail.example.org.
+  request_.url = GURL("https://mail.example.org:443");
+  SendRequestAndExpectHttpResponse("hello world");
+  base::WeakPtr<HttpServerProperties> http_server_properties =
+      session_->http_server_properties();
+
+  const SchemeOriginPair https_origin = SchemeOriginPair::FromURL(request_.url);
+  // Check alternative service is set.
+  AlternativeServiceVector alternative_service_vector =
+      http_server_properties->GetAlternativeServices(https_origin);
+  EXPECT_EQ(2u, alternative_service_vector.size());
+
+  // Send http request to the same origin, should not use QUIC.
+  request_.url = GURL("http://mail.example.org:443");
+  SendRequestAndExpectHttpResponse("hello world");
+}
+
 TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceQuicSupportedVersion) {
   std::string altsvc_header = base::StringPrintf(
       "Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", GetParam());
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()),
       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,
@@ skipping 918 matching lines @@
     // connection to |alternate| only.
     MockConnect refused_connect(ASYNC, ERR_CONNECTION_REFUSED);
     StaticSocketDataProvider refused_data;
     refused_data.set_connect_data(refused_connect);
     socket_factory_.AddSocketDataProvider(&refused_data);
 
     CreateSession();
     AlternativeService alternative_service(QUIC, alternative);
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     session_->http_server_properties()->SetAlternativeService(
-        origin, alternative_service, 1.0, expiration);
+        SchemeOriginPair("https", origin), alternative_service, 1.0,
+        expiration);
     scoped_ptr<HttpNetworkTransaction> trans(
         new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
     TestCompletionCallback callback;
     int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     rv = callback.WaitForResult();
     if (valid) {
       EXPECT_EQ(OK, rv);
       CheckWasQuicResponse(trans);
       CheckResponsePort(trans, 443);
@@ skipping 576 matching lines @@
   scoped_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_NE(OK, callback.WaitForResult());
 }
 
 }  // namespace test
 }  // namespace net