Introduce AlternativeServiceInfo.

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 <set>
 
 #include "base/cpu.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 617 matching lines @@
 
   // TODO(rtenneti): |task_runner_| is used by the Job. Initialize task_runner_
   // in the constructor after WebRequestActionWithThreadsTest.* tests are fixed.
   if (!task_runner_)
     task_runner_ = base::MessageLoop::current()->message_loop_proxy().get();
 
   QuicServerInfo* quic_server_info = nullptr;
   if (quic_server_info_factory_) {
     bool load_from_disk_cache = !disable_disk_cache_;
     if (http_server_properties_) {
-      const AlternateProtocolMap& alternate_protocol_map =
-          http_server_properties_->alternate_protocol_map();
-      AlternateProtocolMap::const_iterator it =
-          alternate_protocol_map.Peek(server_id.host_port_pair());
-      if (it == alternate_protocol_map.end() || it->second.protocol != QUIC) {
+      const AlternativeServiceMap& alternative_service_map =
+          http_server_properties_->alternative_service_map();
+      AlternativeServiceMap::const_iterator it =
+          alternative_service_map.Peek(server_id.host_port_pair());
+      if (it == alternative_service_map.end() ||
+          it->second.alternative_service.protocol != QUIC) {
         // 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 (load_from_disk_cache && CryptoConfigCacheIsEmpty(server_id)) {
       quic_server_info = quic_server_info_factory_->GetForServer(server_id);
     }
   }
 
@@ skipping 476 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, AlternateProtocolInfo>&
-               key_value : http_server_properties_->alternate_protocol_map()) {
-        if (key_value.second.protocol == QUIC) {
+      for (const std::pair<const HostPortPair, AlternativeServiceInfo>&
+               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);
         }
       }
     }
 
     // TODO(rtenneti): Delete the following histogram after collecting stats.
-    // If the AlternateProtocolMap contained an entry for this host, check if
+    // 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(
           "Net.QuicServerInfo.ExpectConfigMissingFromDiskCache",
           server_info->state().server_config.empty());
     }
   }
 
   if (!cached->Initialize(server_info->state().server_config,
@@ skipping 45 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