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 628 matching lines @@
     return OK;
   }
 
   if (HasActiveJob(server_id)) {
     Job* job = active_jobs_[server_id];
     active_requests_[request] = job;
     job_requests_map_[job].insert(request);
     return ERR_IO_PENDING;
   }
 
+  bool was_alternate_protocol_recently_broken = false;
+  AlternateProtocolInfo alternate_protocol;
+  if (http_server_properties_) {
+    alternate_protocol =
+        http_server_properties_->GetAlternateProtocol(host_port_pair);
+    if (alternate_protocol.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) {
+      was_alternate_protocol_recently_broken =
+          http_server_properties_->WasAlternateProtocolRecentlyBroken(
+              host_port_pair, alternate_protocol);
+    }
+  }
+
   QuicServerInfo* quic_server_info = nullptr;
   if (quic_server_info_factory_) {
-    bool load_from_disk_cache = true;
-    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) {
-        // 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 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.
+    const bool load_from_disk_cache =
+        !http_server_properties_ || alternate_protocol.protocol == QUIC;
     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());
   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 488 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 (const std::pair<const HostPortPair, AlternateProtocols>& key_value :
+           http_server_properties_->alternate_protocol_map()) {
+        for (const AlternateProtocolInfo& 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 39 matching lines @@
 
   UMA_HISTOGRAM_COUNTS("Net.QuicHandshakeNotConfirmedNumPacketsReceived",
                        stats.packets_received);
 
   if (!session_was_active)
     return;
 
   const HostPortPair& server = server_id.host_port_pair();
   // Don't try to change the alternate-protocol state, if the
   // alternate-protocol state is unknown.
-  if (!http_server_properties_->HasAlternateProtocol(server))
+  const AlternateProtocolInfo alternate =
+      http_server_properties_->GetAlternateProtocol(server);
+  if (alternate.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     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);
 
   // 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.0);
   DCHECK(http_server_properties_->WasAlternateProtocolRecentlyBroken(
-      server));
+      server, alternate));
 }
 
 }  // namespace net