Update HttpServerProperties::*AlternateProtocol* interface.

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 @@
         // 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);
     }
   }
 
   scoped_ptr<Job> job(new Job(this, host_resolver_, host_port_pair, is_https,
-                              WasAlternateProtocolRecentlyBroken(server_id),
-                              privacy_mode, method == "POST" /* is_post */,
-                              quic_server_info, net_log));
+                              WasQuicRecentlyBroken(server_id), privacy_mode,
+                              method == "POST" /* is_post */, 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] = server_id;
     job_requests_map_[server_id].insert(request);
     active_jobs_[server_id].insert(job.release());
     return rv;
   }
   if (rv == OK) {
     DCHECK(HasActiveSession(server_id));
     request->set_stream(CreateIfSessionExists(server_id, net_log));
   }
   return rv;
 }
 
 void QuicStreamFactory::CreateAuxilaryJob(const QuicServerId server_id,
                                           bool is_post,
                                           const BoundNetLog& net_log) {
   Job* aux_job = new Job(this, host_resolver_, server_id.host_port_pair(),
-                         server_id.is_https(),
-                         WasAlternateProtocolRecentlyBroken(server_id),
+                         server_id.is_https(), WasQuicRecentlyBroken(server_id),
                          server_id.privacy_mode(), is_post, nullptr, net_log);
   active_jobs_[server_id].insert(aux_job);
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&QuicStreamFactory::Job::RunAuxilaryJob,
                                     aux_job->GetWeakPtr()));
 }
 
 bool QuicStreamFactory::OnResolution(
     const QuicServerId& server_id,
     const AddressList& address_list) {
@@ skipping 373 matching lines @@
   if (!http_server_properties_)
     return 0;
   const ServerNetworkStats* stats =
       http_server_properties_->GetServerNetworkStats(
           server_id.host_port_pair());
   if (stats == nullptr)
     return 0;
   return stats->srtt.InMicroseconds();
 }
 
-bool QuicStreamFactory::WasAlternateProtocolRecentlyBroken(
+bool QuicStreamFactory::WasQuicRecentlyBroken(
     const QuicServerId& server_id) const {
-  return http_server_properties_ &&
-         http_server_properties_->WasAlternateProtocolRecentlyBroken(
-             server_id.host_port_pair());
+  if (!http_server_properties_)
+    return false;
+  const AlternativeService alternative_service(QUIC,
+                                               server_id.host_port_pair());
+  return http_server_properties_->WasAlternativeServiceRecentlyBroken(
+      alternative_service);
 }
 
 bool QuicStreamFactory::CryptoConfigCacheIsEmpty(
     const QuicServerId& server_id) {
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_.LookupOrCreate(server_id);
   return cached->IsEmpty();
 }
 
 void QuicStreamFactory::InitializeCachedStateInCryptoConfig(
@@ skipping 77 matching lines @@
   // 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.
   const HostPortPair& server = server_id.host_port_pair();
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       AlternativeService(QUIC, server.host(), server.port()));
 }
 
 }  // namespace net