Implement multiple alternative services per origin.

net/quic/quic_stream_factory.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_stream_factory.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/cpu.h"
@@ skipping 657 matching lines @@
   // in the constructor after WebRequestActionWithThreadsTest.* tests are fixed.
   if (!task_runner_)
     task_runner_ = base::ThreadTaskRunnerHandle::Get().get();
 
   QuicServerInfo* quic_server_info = nullptr;
   if (quic_server_info_factory_) {
     bool load_from_disk_cache = !disable_disk_cache_;
     if (http_server_properties_) {
       const AlternativeServiceMap& alternative_service_map =
           http_server_properties_->alternative_service_map();
-      AlternativeServiceMap::const_iterator it =
+      AlternativeServiceMap::const_iterator map_it =
           alternative_service_map.Peek(server_id.host_port_pair());
-      if (it == alternative_service_map.end() ||
-          it->second.alternative_service.protocol != QUIC) {
+      if (map_it != alternative_service_map.end()) {
+        const AlternativeServiceInfoVector& alternative_service_info_vector =
+            map_it->second;
+        AlternativeServiceInfoVector::const_iterator it;
+        for (it = alternative_service_info_vector.begin();
+             it != alternative_service_info_vector.end(); ++it) {
+          if (it->alternative_service.protocol == QUIC)
+            break;
+        }
         // If there is no entry for QUIC, consider that as a new server and
         // don't wait for Cache thread to load the data for that server.
-        load_from_disk_cache = false;
+        if (it == alternative_service_info_vector.end())
+          load_from_disk_cache = false;
       }
     }
     if (load_from_disk_cache && CryptoConfigCacheIsEmpty(server_id)) {
       quic_server_info = quic_server_info_factory_->GetForServer(server_id);
     }
   }
 
   bool server_and_origin_have_same_host = host_port_pair.host() == origin_host;
   scoped_ptr<Job> job(new Job(this, host_resolver_, host_port_pair,
                               server_and_origin_have_same_host, is_https,
@@ skipping 501 matching lines @@
   if (!server_info)
     return;
 
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_.LookupOrCreate(server_id);
   if (!cached->IsEmpty())
     return;
 
   if (http_server_properties_) {
     if (quic_supported_servers_at_startup_.empty()) {
-      for (const std::pair<const HostPortPair, AlternativeServiceInfo>&
+      for (const std::pair<const HostPortPair, AlternativeServiceInfoVector>&
                key_value : http_server_properties_->alternative_service_map()) {
-        if (key_value.second.alternative_service.protocol == QUIC) {
-          quic_supported_servers_at_startup_.insert(key_value.first);
+        for (const AlternativeServiceInfo& alternative_service_info :
+             key_value.second) {
+          if (alternative_service_info.alternative_service.protocol == QUIC) {
+            quic_supported_servers_at_startup_.insert(key_value.first);
+            break;
+          }
         }
       }
     }
 
     // TODO(rtenneti): Delete the following histogram after collecting stats.
     // If the AlternativeServiceMap contained an entry for this host, check if
     // the disk cache contained an entry for it.
     if (ContainsKey(quic_supported_servers_at_startup_,
                     server_id.host_port_pair())) {
       UMA_HISTOGRAM_BOOLEAN(
@@ skipping 51 matching lines @@
   // Since the session was active, there's no longer an
   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the TCP
   // job also fails. So to avoid not using QUIC when we otherwise could, we mark
   // it as recently broken, which means that 0-RTT will be disabled but we'll
   // still race.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 }  // namespace net