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 585 matching lines @@
     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_->GetAlternateProtocol(
+            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 414 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 =
+
+  const AlternateProtocols alternate_protocols =
       http_server_properties_->GetAlternateProtocol(server);
-  DCHECK_EQ(QUIC, alternate.protocol);
+  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