SPDY - persist SPDY settings.

chrome/browser/net/http_server_properties_manager.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 "chrome/browser/net/http_server_properties_manager.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 122 matching lines @@
   http_server_properties_impl_->SetBrokenAlternateProtocol(server);
   ScheduleUpdatePrefsOnIO();
 }
 
 const net::AlternateProtocolMap&
 HttpServerPropertiesManager::alternate_protocol_map() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->alternate_protocol_map();
 }
 
-const net::SpdySettings&
+const net::SettingsMap&
 HttpServerPropertiesManager::GetSpdySettings(
     const net::HostPortPair& host_port_pair) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->GetSpdySettings(host_port_pair);
 }
 
-// Saves settings for a host.
-bool HttpServerPropertiesManager::SetSpdySettings(
+bool HttpServerPropertiesManager::SetSpdySetting(
     const net::HostPortPair& host_port_pair,
-    const net::SpdySettings& settings) {
+    net::SpdySettingsIds id,
+    net::SpdySettingsFlags flags,
+    uint32 value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  bool persist = http_server_properties_impl_->SetSpdySettings(
-      host_port_pair, settings);
+  bool persist = http_server_properties_impl_->SetSpdySetting(
+      host_port_pair, id, flags, value);
   if (persist)
     ScheduleUpdatePrefsOnIO();
   return persist;
-}
-
-bool HttpServerPropertiesManager::SetSpdySetting(
-    const net::HostPortPair& host_port_pair,
-    const net::SpdySetting& setting) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  bool persist = http_server_properties_impl_->SetSpdySetting(
-      host_port_pair, setting);
-  if (persist)
-    ScheduleUpdatePrefsOnIO();
-  return persist;
 }
 
 void HttpServerPropertiesManager::ClearSpdySettings() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   http_server_properties_impl_->ClearSpdySettings();
   ScheduleUpdatePrefsOnIO();
 }
 
 const net::SpdySettingsMap&
 HttpServerPropertiesManager::spdy_settings_map() const {
@@ skipping 90 matching lines @@
       continue;
     }
 
     // Get if server supports Spdy.
     bool supports_spdy = false;
     if ((server_pref_dict->GetBoolean(
          "supports_spdy", &supports_spdy)) && supports_spdy) {
       spdy_servers->push_back(server_str);
     }
 
-    // TODO(rtenneti): Implement reading of SpdySettings.
+    // Get SpdySettings.
     DCHECK(!ContainsKey(*spdy_settings_map, server));
+    base::ListValue* spdy_settings_list = NULL;
+    if (server_pref_dict->GetListWithoutPathExpansion(
+        "settings", &spdy_settings_list)) {
+      net::SettingsMap settings_map;
+
+      for (base::ListValue::const_iterator list_it =
+           spdy_settings_list->begin();
+           list_it != spdy_settings_list->end(); ++list_it) {
+        if ((*list_it)->GetType() != Value::TYPE_DICTIONARY) {
+          DVLOG(1) << "Malformed SpdySettingsList for server: " << server_str;
+          NOTREACHED();
+          continue;
+        }
+
+        const base::DictionaryValue* spdy_setting_dict =
+            static_cast<const base::DictionaryValue*>(*list_it);
+
+        int id = 0;
+        if (!spdy_setting_dict->GetIntegerWithoutPathExpansion("id", &id)) {
+          DVLOG(1) << "Malformed id in SpdySettings for server: " << server_str;
+          NOTREACHED();
+          continue;
+        }
+
+        int value = 0;
+        if (!spdy_setting_dict->GetIntegerWithoutPathExpansion("value",
+                                                               &value)) {
+          DVLOG(1) << "Malformed value in SpdySettings for server: " <<
+              server_str;
+          NOTREACHED();
+          continue;
+        }
+
+        net::SettingsFlagsAndValue flags_and_value(
+            net::SETTINGS_FLAG_PERSISTED, value);
+        settings_map[static_cast<net::SpdySettingsIds>(id)] = flags_and_value;
+      }
+
+      (*spdy_settings_map)[server] = settings_map;
+    }
 
     int pipeline_capability = net::PIPELINE_UNKNOWN;
     if ((server_pref_dict->GetInteger(
          "pipeline_capability", &pipeline_capability)) &&
         pipeline_capability != net::PIPELINE_UNKNOWN) {
       (*pipeline_capability_map)[server] =
           static_cast<net::HttpPipelinedHostCapability>(pipeline_capability);
     }
 
     // Get alternate_protocol server.
@@ skipping 123 matching lines @@
                  base::Owned(alternate_protocol_map),
                  base::Owned(pipeline_capability_map)));
 }
 
 // A local or temporary data structure to hold |supports_spdy|, SpdySettings,
 // PortAlternateProtocolPair, and |pipeline_capability| preferences for a
 // server. This is used only in UpdatePrefsOnUI.
 struct ServerPref {
   ServerPref()
       : supports_spdy(false),
-        settings(NULL),
+        settings_map(NULL),
         alternate_protocol(NULL),
         pipeline_capability(net::PIPELINE_UNKNOWN) {
   }
   ServerPref(bool supports_spdy,
-             const net::SpdySettings* settings,
+             const net::SettingsMap* settings_map,
              const net::PortAlternateProtocolPair* alternate_protocol)
       : supports_spdy(supports_spdy),
-        settings(settings),
+        settings_map(settings_map),
         alternate_protocol(alternate_protocol),
         pipeline_capability(net::PIPELINE_UNKNOWN) {
   }
   bool supports_spdy;
-  const net::SpdySettings* settings;
+  const net::SettingsMap* settings_map;
   const net::PortAlternateProtocolPair* alternate_protocol;
   net::HttpPipelinedHostCapability pipeline_capability;
 };
 
 void HttpServerPropertiesManager::UpdatePrefsOnUI(
     base::ListValue* spdy_server_list,
     net::SpdySettingsMap* spdy_settings_map,
     net::AlternateProtocolMap* alternate_protocol_map,
     net::PipelineCapabilityMap* pipeline_capability_map) {
 
@@ skipping 23 matching lines @@
   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);
       server_pref_map[server] = server_pref;
     } else {
-      it->second.settings = &map_it->second;
+      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::PortAlternateProtocolPair& port_alternate_protocol =
         map_it->second;
@@ skipping 34 matching lines @@
        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;
 
     // Save supports_spdy.
     server_pref_dict->SetBoolean("supports_spdy", server_pref.supports_spdy);
 
-    // TODO(rtenneti): Implement save SpdySettings.
+    // Save SPDY settings.
+    if (server_pref.settings_map) {
+      base::ListValue* spdy_settings_list = new ListValue();
+      for (net::SettingsMap::const_iterator it =
+           server_pref.settings_map->begin();
+           it != server_pref.settings_map->end(); ++it) {
+        net::SpdySettingsIds id = it->first;
+        uint32 value = it->second.second;
+        base::DictionaryValue* spdy_setting_dict = new base::DictionaryValue;
+        spdy_setting_dict->SetInteger("id", id);
+        spdy_setting_dict->SetInteger("value", value);
+        spdy_settings_list->Append(spdy_setting_dict);
+      }
+      server_pref_dict->Set("settings", spdy_settings_list);
+    }
 
     // Save alternate_protocol.
     if (server_pref.alternate_protocol) {
       base::DictionaryValue* port_alternate_protocol_dict =
           new base::DictionaryValue;
       const net::PortAlternateProtocolPair* port_alternate_protocol =
           server_pref.alternate_protocol;
       port_alternate_protocol_dict->SetInteger(
           "port", port_alternate_protocol->port);
       port_alternate_protocol_dict->SetInteger(
@@ skipping 28 matching lines @@
   std::string* pref_name = content::Details<std::string>(details).ptr();
   if (*pref_name == prefs::kHttpServerProperties) {
     if (!setting_prefs_)
       ScheduleUpdateCacheOnUI();
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace chrome_browser_net