QUIC - Code to persist if we had talked QUIC to a server and if so what

net/http/http_server_properties_impl.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/http/http_server_properties_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 85 matching lines @@
 }
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
     SpdySettingsMap* spdy_settings_map) {
   for (SpdySettingsMap::reverse_iterator it = spdy_settings_map->rbegin();
        it != spdy_settings_map->rend(); ++it) {
     spdy_settings_map_.Put(it->first, it->second);
   }
 }
 
+void HttpServerPropertiesImpl::InitializeSupportsQuic(
+    SupportsQuicMap* supports_quic_map) {
+  for (SupportsQuicMap::reverse_iterator it = supports_quic_map->rbegin();
+       it != supports_quic_map->rend();
+       ++it) {
+    supports_quic_map_.insert(std::make_pair(it->first, it->second));
+  }
+}
+
 void HttpServerPropertiesImpl::GetSpdyServerList(
     base::ListValue* spdy_server_list,
     size_t max_size) const {
   DCHECK(CalledOnValidThread());
   DCHECK(spdy_server_list);
   spdy_server_list->Clear();
   size_t count = 0;
   // Get the list of servers (host/port) that support SPDY.
   for (SpdyServerHostPortMap::const_iterator it = spdy_servers_map_.begin();
        it != spdy_servers_map_.end() && count < max_size; ++it) {
@@ skipping 35 matching lines @@
 base::WeakPtr<HttpServerProperties> HttpServerPropertiesImpl::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void HttpServerPropertiesImpl::Clear() {
   DCHECK(CalledOnValidThread());
   spdy_servers_map_.Clear();
   alternate_protocol_map_.Clear();
   canonical_host_to_origin_map_.clear();
   spdy_settings_map_.Clear();
+  supports_quic_map_.clear();
 }
 
 bool HttpServerPropertiesImpl::SupportsSpdy(
     const net::HostPortPair& host_port_pair) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return false;
   std::string spdy_server = GetFlattenedSpdyServer(host_port_pair);
 
   SpdyServerHostPortMap::iterator spdy_host_port =
@@ skipping 228 matching lines @@
 
 void HttpServerPropertiesImpl::ClearAllSpdySettings() {
   spdy_settings_map_.Clear();
 }
 
 const SpdySettingsMap&
 HttpServerPropertiesImpl::spdy_settings_map() const {
   return spdy_settings_map_;
 }
 
+SupportsQuic HttpServerPropertiesImpl::GetSupportsQuic(
+    const HostPortPair& host_port_pair) const {
+  SupportsQuicMap::const_iterator it = supports_quic_map_.find(host_port_pair);
+  if (it == supports_quic_map_.end()) {
+    CR_DEFINE_STATIC_LOCAL(SupportsQuic, kEmptySupportsQuic, ());
+    return kEmptySupportsQuic;
+  }
+  return it->second;
+}
+
+void HttpServerPropertiesImpl::SetSupportsQuic(
+    const HostPortPair& host_port_pair,
+    bool used_quic,
+    const std::string& address) {
+  SupportsQuic supports_quic(used_quic, address);
+  supports_quic_map_.insert(std::make_pair(host_port_pair, supports_quic));
+}
+
+const SupportsQuicMap&
+HttpServerPropertiesImpl::supports_quic_map() const {
+  return supports_quic_map_;
+}
+
 void HttpServerPropertiesImpl::SetServerNetworkStats(
     const HostPortPair& host_port_pair,
     NetworkStats stats) {
   server_network_stats_map_[host_port_pair] = stats;
 }
 
 const HttpServerProperties::NetworkStats*
 HttpServerPropertiesImpl::GetServerNetworkStats(
     const HostPortPair& host_port_pair) const {
   ServerNetworkStatsMap::const_iterator it =
@@ skipping 59 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net