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

net/http/http_server_properties_manager.cc

 // Copyright 2014 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_manager.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
@@ skipping 246 matching lines @@
   http_server_properties_impl_->ClearAllSpdySettings();
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 const SpdySettingsMap& HttpServerPropertiesManager::spdy_settings_map()
     const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->spdy_settings_map();
 }
 
+net::SupportsQuic
+HttpServerPropertiesManager::GetSupportsQuic(
+    const net::HostPortPair& host_port_pair) const {
+  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  return http_server_properties_impl_->GetSupportsQuic(host_port_pair);
+}
+
+void HttpServerPropertiesManager::SetSupportsQuic(
+    const net::HostPortPair& host_port_pair,
+    bool used_quic,
+    const std::string& address) {
+  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  http_server_properties_impl_->SetSupportsQuic(
+      host_port_pair, used_quic, address);
+  ScheduleUpdatePrefsOnNetworkThread();
+}
+
+const SupportsQuicMap& HttpServerPropertiesManager::supports_quic_map()
+    const {
+  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  return http_server_properties_impl_->supports_quic_map();
+}
+
 void HttpServerPropertiesManager::SetServerNetworkStats(
     const net::HostPortPair& host_port_pair,
     NetworkStats stats) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->SetServerNetworkStats(host_port_pair, stats);
 }
 
 const HttpServerPropertiesManager::NetworkStats*
 HttpServerPropertiesManager::GetServerNetworkStats(
     const net::HostPortPair& host_port_pair) const {
@@ skipping 48 matching lines @@
     DVLOG(1) << "Malformed http_server_properties for servers.";
     return;
   }
 
   // String is host/port pair of spdy server.
   scoped_ptr<StringVector> spdy_servers(new StringVector);
   scoped_ptr<net::SpdySettingsMap> spdy_settings_map(
       new net::SpdySettingsMap(kMaxSpdySettingsHostsToPersist));
   scoped_ptr<net::AlternateProtocolMap> alternate_protocol_map(
       new net::AlternateProtocolMap(kMaxAlternateProtocolHostsToPersist));
+  scoped_ptr<net::SupportsQuicMap> supports_quic_map(
+      new net::SupportsQuicMap());
   // TODO(rtenneti): Delete the following code after the experiment.
   int alternate_protocols_to_load = k200AlternateProtocolHostsToLoad;
   net::AlternateProtocolExperiment alternate_protocol_experiment =
       net::ALTERNATE_PROTOCOL_NOT_PART_OF_EXPERIMENT;
   if (version == kVersionNumber) {
     if (base::RandInt(0, 99) == 0) {
       alternate_protocol_experiment =
           net::ALTERNATE_PROTOCOL_TRUNCATED_200_SERVERS;
     } else {
       alternate_protocols_to_load = k1000AlternateProtocolHostsToLoad;
@@ skipping 103 matching lines @@
         detected_corrupted_prefs = true;
         continue;
       }
 
       net::AlternateProtocolInfo port_alternate_protocol(port,
                                                          protocol,
                                                          probability);
       alternate_protocol_map->Put(server, port_alternate_protocol);
       ++count;
     } while (false);
+
+    // Get SupportsQuic.
+    DCHECK(supports_quic_map->find(server) == supports_quic_map->end());
+    const base::DictionaryValue* supports_quic_dict = NULL;
+    if (!server_pref_dict->GetDictionaryWithoutPathExpansion(
+            "supports_quic", &supports_quic_dict)) {
+      continue;
+    }
+    do {
+      bool used_quic = 0;
+      if (!supports_quic_dict->GetBooleanWithoutPathExpansion(
+              "used_quic", &used_quic)) {
+        DVLOG(1) << "Malformed SupportsQuic server: " << server_str;
+        detected_corrupted_prefs = true;
+        continue;
+      }
+      std::string address;
+      if (!supports_quic_dict->GetStringWithoutPathExpansion(
+              "address", &address)) {
+        DVLOG(1) << "Malformed SupportsQuic server: " << server_str;
+        detected_corrupted_prefs = true;
+        continue;
+      }
+      net::SupportsQuic supports_quic(used_quic, address);
+      supports_quic_map->insert(std::make_pair(server, supports_quic));
+    } while (false);
   }
 
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkThread,
           base::Unretained(this),
           base::Owned(spdy_servers.release()),
           base::Owned(spdy_settings_map.release()),
           base::Owned(alternate_protocol_map.release()),
           alternate_protocol_experiment,
+          base::Owned(supports_quic_map.release()),
           detected_corrupted_prefs));
 }
 
 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkThread(
     StringVector* spdy_servers,
     net::SpdySettingsMap* spdy_settings_map,
     net::AlternateProtocolMap* alternate_protocol_map,
     net::AlternateProtocolExperiment alternate_protocol_experiment,
+    net::SupportsQuicMap* supports_quic_map,
     bool detected_corrupted_prefs) {
   // Preferences have the master data because admins might have pushed new
   // preferences. Update the cached data with new data from preferences.
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
   UMA_HISTOGRAM_COUNTS("Net.CountOfSpdyServers", spdy_servers->size());
   http_server_properties_impl_->InitializeSpdyServers(spdy_servers, true);
 
   // Update the cached data and use the new spdy_settings from preferences.
   UMA_HISTOGRAM_COUNTS("Net.CountOfSpdySettings", spdy_settings_map->size());
   http_server_properties_impl_->InitializeSpdySettingsServers(
       spdy_settings_map);
 
   // Update the cached data and use the new Alternate-Protocol server list from
   // preferences.
   UMA_HISTOGRAM_COUNTS("Net.CountOfAlternateProtocolServers",
                        alternate_protocol_map->size());
   http_server_properties_impl_->InitializeAlternateProtocolServers(
       alternate_protocol_map);
   http_server_properties_impl_->SetAlternateProtocolExperiment(
       alternate_protocol_experiment);
 
+  http_server_properties_impl_->InitializeSupportsQuic(supports_quic_map);
+
   // Update the prefs with what we have read (delete all corrupted prefs).
   if (detected_corrupted_prefs)
     ScheduleUpdatePrefsOnNetworkThread();
 }
 
 //
 // Update Preferences with data from the cached data.
 //
 void HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkThread() {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 53 matching lines @@
         http_server_properties_impl_->GetCanonicalSuffix(server);
     if (!canonical_suffix.empty()) {
       if (persisted_map.find(canonical_suffix) != persisted_map.end())
         continue;
       persisted_map[canonical_suffix] = true;
     }
     alternate_protocol_map->Put(server, it->second);
     ++count;
   }
 
+  net::SupportsQuicMap* supports_quic_map = new net::SupportsQuicMap();
+  const net::SupportsQuicMap& main_supports_quic_map =
+      http_server_properties_impl_->supports_quic_map();
+  for (net::SupportsQuicMap::const_iterator it = main_supports_quic_map.begin();
+       it != main_supports_quic_map.end(); ++it) {
+    supports_quic_map->insert(std::make_pair(it->first, it->second));
+  }
+
   // Update the preferences on the pref thread.
   pref_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::UpdatePrefsOnPrefThread,
                  pref_weak_ptr_,
                  base::Owned(spdy_server_list),
                  base::Owned(spdy_settings_map),
                  base::Owned(alternate_protocol_map),
+                 base::Owned(supports_quic_map),
                  completion));
 }
 
 // A local or temporary data structure to hold |supports_spdy|, SpdySettings,
-// and AlternateProtocolInfo preferences for a server. This is used only in
-// UpdatePrefsOnPrefThread.
+// AlternateProtocolInfo and SupportsQuic preferences for a server. This is used
+// only in UpdatePrefsOnPrefThread.
 struct ServerPref {
-  ServerPref()
-      : supports_spdy(false), settings_map(NULL), alternate_protocol(NULL) {}
+  ServerPref() : supports_spdy(false),
+                 settings_map(NULL),
+                 alternate_protocol(NULL),
+                 supports_quic(NULL) {}
   ServerPref(bool supports_spdy,
              const net::SettingsMap* settings_map,
-             const net::AlternateProtocolInfo* alternate_protocol)
+             const net::AlternateProtocolInfo* alternate_protocol,
+             const net::SupportsQuic* supports_quic)
       : supports_spdy(supports_spdy),
         settings_map(settings_map),
-        alternate_protocol(alternate_protocol) {}
+        alternate_protocol(alternate_protocol),
+        supports_quic(supports_quic) {}
   bool supports_spdy;
   const net::SettingsMap* settings_map;
   const net::AlternateProtocolInfo* alternate_protocol;
+  const net::SupportsQuic* supports_quic;
 };
 
 void HttpServerPropertiesManager::UpdatePrefsOnPrefThread(
     base::ListValue* spdy_server_list,
     net::SpdySettingsMap* spdy_settings_map,
     net::AlternateProtocolMap* alternate_protocol_map,
+    net::SupportsQuicMap* supports_quic_map,
     const base::Closure& completion) {
   typedef std::map<net::HostPortPair, ServerPref> ServerPrefMap;
   ServerPrefMap server_pref_map;
 
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
 
   // Add servers that support spdy to server_pref_map.
   std::string s;
   for (base::ListValue::const_iterator list_it = spdy_server_list->begin();
        list_it != spdy_server_list->end();
        ++list_it) {
     if ((*list_it)->GetAsString(&s)) {
       net::HostPortPair server = net::HostPortPair::FromString(s);
 
       ServerPrefMap::iterator it = server_pref_map.find(server);
       if (it == server_pref_map.end()) {
-        ServerPref server_pref(true, NULL, NULL);
+        ServerPref server_pref(true, NULL, NULL, NULL);
         server_pref_map[server] = server_pref;
       } else {
         it->second.supports_spdy = true;
       }
     }
   }
 
   // Add servers that have SpdySettings to server_pref_map.
   for (net::SpdySettingsMap::iterator map_it = spdy_settings_map->begin();
        map_it != spdy_settings_map->end();
        ++map_it) {
     const net::HostPortPair& server = map_it->first;
 
     ServerPrefMap::iterator it = server_pref_map.find(server);
     if (it == server_pref_map.end()) {
-      ServerPref server_pref(false, &map_it->second, NULL);
+      ServerPref server_pref(false, &map_it->second, NULL, NULL);
       server_pref_map[server] = server_pref;
     } else {
       it->second.settings_map = &map_it->second;
     }
   }
 
   // Add AlternateProtocol servers to server_pref_map.
   for (net::AlternateProtocolMap::const_iterator map_it =
            alternate_protocol_map->begin();
        map_it != alternate_protocol_map->end();
        ++map_it) {
     const net::HostPortPair& server = map_it->first;
     const net::AlternateProtocolInfo& port_alternate_protocol =
         map_it->second;
     if (!net::IsAlternateProtocolValid(port_alternate_protocol.protocol)) {
       continue;
     }
 
     ServerPrefMap::iterator it = server_pref_map.find(server);
     if (it == server_pref_map.end()) {
-      ServerPref server_pref(false, NULL, &map_it->second);
+      ServerPref server_pref(false, NULL, &map_it->second, NULL);
       server_pref_map[server] = server_pref;
     } else {
       it->second.alternate_protocol = &map_it->second;
     }
   }
 
+  // Add SupportsQuic servers to server_pref_map.
+  for (net::SupportsQuicMap::const_iterator map_it = supports_quic_map->begin();
+       map_it != supports_quic_map->end(); ++map_it) {
+    const net::HostPortPair& server = map_it->first;
+
+    ServerPrefMap::iterator it = server_pref_map.find(server);
+    if (it == server_pref_map.end()) {
+      ServerPref server_pref(false, NULL, NULL, &map_it->second);
+      server_pref_map[server] = server_pref;
+    } else {
+      it->second.supports_quic = &map_it->second;
+    }
+  }
+
   // Persist properties to the |path_|.
   base::DictionaryValue http_server_properties_dict;
   base::DictionaryValue* servers_dict = new base::DictionaryValue;
   for (ServerPrefMap::const_iterator map_it = server_pref_map.begin();
        map_it != server_pref_map.end();
        ++map_it) {
     const net::HostPortPair& server = map_it->first;
     const ServerPref& server_pref = map_it->second;
 
     base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
@@ skipping 27 matching lines @@
                                                port_alternate_protocol->port);
       const char* protocol_str =
           net::AlternateProtocolToString(port_alternate_protocol->protocol);
       port_alternate_protocol_dict->SetString("protocol_str", protocol_str);
       port_alternate_protocol_dict->SetDouble(
           "probability", port_alternate_protocol->probability);
       server_pref_dict->SetWithoutPathExpansion(
           "alternate_protocol", port_alternate_protocol_dict);
     }
 
+    // Save supports_quic.
+    if (server_pref.supports_quic) {
+      base::DictionaryValue* supports_quic_dict = new base::DictionaryValue;
+      const net::SupportsQuic* supports_quic = server_pref.supports_quic;
+      supports_quic_dict->SetBoolean("used_quic", supports_quic->used_quic);
+      supports_quic_dict->SetString("address", supports_quic->address);
+      server_pref_dict->SetWithoutPathExpansion(
+          "supports_quic", supports_quic_dict);
+    }
+
     servers_dict->SetWithoutPathExpansion(server.ToString(), server_pref_dict);
   }
 
   http_server_properties_dict.SetWithoutPathExpansion("servers", servers_dict);
   SetVersion(&http_server_properties_dict, kVersionNumber);
   setting_prefs_ = true;
   pref_service_->Set(path_, http_server_properties_dict);
   setting_prefs_ = false;
 
   // Note that |completion| will be fired after we have written everything to
   // the Preferences, but likely before these changes are serialized to disk.
   // This is not a problem though, as JSONPrefStore guarantees that this will
   // happen, pretty soon, and even in the case we shut down immediately.
   if (!completion.is_null())
     completion.Run();
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net