ABANDONED Handle multiple AlternateProtocols for each HostPortPair.

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 639 matching lines @@
   }
 
   QuicServerInfo* quic_server_info = nullptr;
   if (quic_server_info_factory_) {
     bool load_from_disk_cache = true;
     if (disable_loading_server_info_for_new_servers_) {
       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) {
-        // 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.
+      // 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.
+      if (it == alternate_protocol_map.end()) {
         load_from_disk_cache = false;
+      } else {
+        AlternateProtocols alternate_protocols = it->second;
+        AlternateProtocols::iterator alternate;
+        for (alternate = alternate_protocols.begin();
+             alternate != alternate_protocols.end(); ++alternate) {
+          if (alternate->protocol == QUIC) {
+            break;
+          }
+        }
+        if (alternate == alternate_protocols.end()) {
+          load_from_disk_cache = false;
+        }
       }
     }
     if (load_from_disk_cache) {
       QuicCryptoClientConfig::CachedState* cached =
           crypto_config_.LookupOrCreate(server_id);
       DCHECK(cached);
       if (cached->IsEmpty()) {
         quic_server_info = quic_server_info_factory_->GetForServer(server_id);
       }
     }
   }
   // TODO(rtenneti): Initialize task_runner_ in the constructor after
   // WebRequestActionWithThreadsTest.* tests are fixed.
   if (!task_runner_)
     task_runner_ = base::MessageLoop::current()->message_loop_proxy().get();
 
-  bool was_alternate_protocol_recently_broken =
-      http_server_properties_ &&
-      http_server_properties_->WasAlternateProtocolRecentlyBroken(
-          server_id.host_port_pair());
+  bool was_alternate_protocol_recently_broken = false;
+  if (http_server_properties_ &&
+      http_server_properties_->HasAlternateProtocol(
+          server_id.host_port_pair())) {
+    AlternateProtocols alternate_protocols =
+        http_server_properties_->GetAlternateProtocols(
+            server_id.host_port_pair());
+    AlternateProtocolInfo alternate_protocol = alternate_protocols[0];
+    was_alternate_protocol_recently_broken =
+        http_server_properties_->WasAlternateProtocolRecentlyBroken(
+            server_id.host_port_pair(), alternate_protocol);
+  }
   scoped_ptr<Job> job(new Job(this, host_resolver_, host_port_pair, is_https,
                               was_alternate_protocol_recently_broken,
                               privacy_mode, method, quic_server_info, net_log));
   int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete,
                                base::Unretained(this), job.get()));
 
   if (rv == ERR_IO_PENDING) {
     active_requests_[request] = job.get();
     job_requests_map_[job.get()].insert(request);
     active_jobs_[server_id] = job.release();
@@ skipping 445 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 net::HostPortPair, net::AlternateProtocolInfo>&
-               key_value : http_server_properties_->alternate_protocol_map()) {
-        if (key_value.second.protocol == QUIC) {
-          quic_supported_servers_at_startup_.insert(key_value.first);
+      for (auto key_value : http_server_properties_->alternate_protocol_map()) {
+        for (auto alternate_protocol : key_value.second) {
+          if (alternate_protocol.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
     // the disk cache contained an entry for it.
     if (ContainsKey(quic_supported_servers_at_startup_,
                     server_id.host_port_pair())) {
       UMA_HISTOGRAM_BOOLEAN(
@@ skipping 48 matching lines @@
   // alternate-protocol state is unknown.
   if (!http_server_properties_->HasAlternateProtocol(server))
     return;
 
   // TODO(rch):  In the special case where the session has received no
   // packets from the peer, we should consider blacklisting this
   // differently so that we still race TCP but we don't consider the
   // session connected until the handshake has been confirmed.
   HistogramBrokenAlternateProtocolLocation(
       BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_STREAM_FACTORY);
-  AlternateProtocolInfo alternate =
-      http_server_properties_->GetAlternateProtocol(server);
-  DCHECK_EQ(QUIC, alternate.protocol);
+
+  const AlternateProtocols alternate_protocols =
+      http_server_properties_->GetAlternateProtocols(server);
+  AlternateProtocols::const_iterator alternate;
+  for (alternate = alternate_protocols.begin();
+       alternate != alternate_protocols.end(); ++alternate) {
+    if (alternate->protocol == QUIC) {
+      break;
+    }
+  }
+  // Do not use DCHECK_NE as operator<<(ostream, iterator) is not defined.
+  DCHECK(alternate != alternate_protocols.end())
+      << "No QUIC alternate protocol found";
 
   // 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 broken, and then immediately re-enable it. This leaves
   // QUIC as "recently broken" which means that 0-RTT will be disabled but
   // we'll still race.
-  http_server_properties_->SetBrokenAlternateProtocol(server);
-  http_server_properties_->ClearAlternateProtocol(server);
-  http_server_properties_->SetAlternateProtocol(
-      server, alternate.port, alternate.protocol, 1);
-  DCHECK_EQ(QUIC,
-            http_server_properties_->GetAlternateProtocol(server).protocol);
+  http_server_properties_->SetBrokenAlternateProtocol(server, *alternate);
+  http_server_properties_->RemoveAlternateProtocol(server, *alternate);
+  http_server_properties_->AddAlternateProtocol(server, alternate->port,
+                                                alternate->protocol, 1);
   DCHECK(http_server_properties_->WasAlternateProtocolRecentlyBroken(
-      server));
+      server, *alternate));
 }
 
 }  // namespace net