Implement multiple alternative services per origin.

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/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 307 matching lines @@
       const std::string& expected,
       uint16 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);
     AlternativeService alternative_service(QUIC, host_port_pair.host(), 80);
-    http_server_properties_.SetAlternativeService(host_port_pair,
+    http_server_properties_.AddAlternativeService(host_port_pair,
                                                   alternative_service, 1.0);
   }
 
   void ExpectBrokenAlternateProtocolMapping() {
     const HostPortPair origin = HostPortPair::FromURL(request_.url);
-    const AlternativeService alternative_service =
-        http_server_properties_.GetAlternativeService(origin);
-    EXPECT_NE(UNINITIALIZED_ALTERNATE_PROTOCOL, alternative_service.protocol);
+    const AlternativeServiceVector alternative_service_vector =
+        http_server_properties_.GetAlternativeServices(origin);
+    EXPECT_EQ(1u, alternative_service_vector.size());
     EXPECT_TRUE(http_server_properties_.IsAlternativeServiceBroken(
-        alternative_service));
+        alternative_service_vector[0]));
   }
 
   void ExpectQuicAlternateProtocolMapping() {
-    const AlternativeService alternative_service =
-        http_server_properties_.GetAlternativeService(
-            HostPortPair::FromURL(request_.url));
-    EXPECT_EQ(QUIC, alternative_service.protocol);
+    const HostPortPair origin = HostPortPair::FromURL(request_.url);
+    const AlternativeServiceVector alternative_service_vector =
+        http_server_properties_.GetAlternativeServices(origin);
+    EXPECT_EQ(1u, alternative_service_vector.size());
+    EXPECT_EQ(QUIC, alternative_service_vector[0].protocol);
   }
 
   void AddHangingNonAlternateProtocolSocketData() {
     MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
     hanging_data_.set_connect_data(hanging_connect);
     socket_factory_.AddSocketDataProvider(&hanging_data_);
   }
 
   MockClock* clock_;  // Owned by QuicStreamFactory after CreateSession.
   QuicTestPacketMaker maker_;
@@ skipping 507 matching lines @@
 
     // Connection to |origin| fails, so that success of |request| depends on
     // 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);
 
     CreateSessionWithNextProtos();
     AlternativeService alternative_service(QUIC, alternative);
-    session_->http_server_properties()->SetAlternativeService(
+    session_->http_server_properties()->AddAlternativeService(
         origin, alternative_service, 1.0);
     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);
@@ skipping 498 matching lines @@
 
   request_.url = GURL("https://www.example.org:443");
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 }  // namespace test
 }  // namespace net