1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_NET_HTTP_SERVER_PROPERTIES_MANAGER_H_ 6 #define CHROME_BROWSER_NET_HTTP_SERVER_PROPERTIES_MANAGER_H_ 7 8 #include <string> 9 #include <vector> 10 #include "base/basictypes.h" 11 #include "base/compiler_specific.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/memory/weak_ptr.h" 14 #include "base/prefs/pref_change_registrar.h" 15 #include "base/timer/timer.h" 16 #include "base/values.h" 17 #include "net/base/host_port_pair.h" 18 #include "net/http/http_pipelined_host_capability.h" 19 #include "net/http/http_server_properties.h" 20 #include "net/http/http_server_properties_impl.h" 21 22 class PrefService; 23 24 namespace user_prefs { 25 class PrefRegistrySyncable; 26 } 27 28 namespace chrome_browser_net { 29 30 //////////////////////////////////////////////////////////////////////////////// 31 // HttpServerPropertiesManager 32 33 // The manager for creating and updating an HttpServerProperties (for example it 34 // tracks if a server supports SPDY or not). 35 // 36 // This class interacts with both the UI thread, where notifications of pref 37 // changes are received from, and the IO thread, which owns it (in the 38 // ProfileIOData) and it persists the changes from network stack that if a 39 // server supports SPDY or not. 40 // 41 // It must be constructed on the UI thread, to set up |ui_method_factory_| and 42 // the prefs listeners. 43 // 44 // ShutdownOnUIThread must be called from UI before destruction, to release 45 // the prefs listeners on the UI thread. This is done from ProfileIOData. 46 // 47 // Update tasks from the UI thread can post safely to the IO thread, since the 48 // destruction order of Profile and ProfileIOData guarantees that if this 49 // exists in UI, then a potential destruction on IO will come after any task 50 // posted to IO from that method on UI. This is used to go through IO before 51 // the actual update starts, and grab a WeakPtr. 52 class HttpServerPropertiesManager 53 : public net::HttpServerProperties { 54 public: 55 // Create an instance of the HttpServerPropertiesManager. The lifetime of the 56 // PrefService objects must be longer than that of the 57 // HttpServerPropertiesManager object. Must be constructed on the UI thread. 58 explicit HttpServerPropertiesManager(PrefService* pref_service); 59 virtual ~HttpServerPropertiesManager(); 60 61 // Initialize |http_server_properties_impl_| and |io_method_factory_| on IO 62 // thread. It also posts a task to UI thread to get SPDY Server preferences 63 // from |pref_service_|. 64 void InitializeOnIOThread(); 65 66 // Prepare for shutdown. Must be called on the UI thread, before destruction. 67 void ShutdownOnUIThread(); 68 69 // Register |prefs| for properties managed here. 70 static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry); 71 72 // Helper function for unit tests to set the version in the dictionary. 73 static void SetVersion(base::DictionaryValue* http_server_properties_dict, 74 int version_number); 75 76 // Deletes all data. Works asynchronously, but if a |completion| callback is 77 // provided, it will be fired on the UI thread when everything is done. 78 void Clear(const base::Closure& completion); 79 80 // ---------------------------------- 81 // net::HttpServerProperties methods: 82 // ---------------------------------- 83 84 // Gets a weak pointer for this object. 85 virtual base::WeakPtr<net::HttpServerProperties> GetWeakPtr() OVERRIDE; 86 87 // Deletes all data. Works asynchronously. 88 virtual void Clear() OVERRIDE; 89 90 // Returns true if |server| supports SPDY. Should only be called from IO 91 // thread. 92 virtual bool SupportsSpdy(const net::HostPortPair& server) const OVERRIDE; 93 94 // Add |server| as the SPDY server which supports SPDY protocol into the 95 // persisitent store. Should only be called from IO thread. 96 virtual void SetSupportsSpdy(const net::HostPortPair& server, 97 bool support_spdy) OVERRIDE; 98 99 // Returns true if |server| has an Alternate-Protocol header. 100 virtual bool HasAlternateProtocol( 101 const net::HostPortPair& server) const OVERRIDE; 102 103 // Returns the Alternate-Protocol and port for |server|. 104 // HasAlternateProtocol(server) must be true. 105 virtual net::PortAlternateProtocolPair GetAlternateProtocol( 106 const net::HostPortPair& server) const OVERRIDE; 107 108 // Sets the Alternate-Protocol for |server|. 109 virtual void SetAlternateProtocol( 110 const net::HostPortPair& server, 111 uint16 alternate_port, 112 net::AlternateProtocol alternate_protocol) OVERRIDE; 113 114 // Sets the Alternate-Protocol for |server| to be BROKEN. 115 virtual void SetBrokenAlternateProtocol( 116 const net::HostPortPair& server) OVERRIDE; 117 118 // Returns all Alternate-Protocol mappings. 119 virtual const net::AlternateProtocolMap& 120 alternate_protocol_map() const OVERRIDE; 121 122 // Gets a reference to the SettingsMap stored for a host. 123 // If no settings are stored, returns an empty SettingsMap. 124 virtual const net::SettingsMap& GetSpdySettings( 125 const net::HostPortPair& host_port_pair) const OVERRIDE; 126 127 // Saves an individual SPDY setting for a host. Returns true if SPDY setting 128 // is to be persisted. 129 virtual bool SetSpdySetting(const net::HostPortPair& host_port_pair, 130 net::SpdySettingsIds id, 131 net::SpdySettingsFlags flags, 132 uint32 value) OVERRIDE; 133 134 // Clears all SPDY settings for a host. 135 virtual void ClearSpdySettings( 136 const net::HostPortPair& host_port_pair) OVERRIDE; 137 138 // Clears all SPDY settings for all hosts. 139 virtual void ClearAllSpdySettings() OVERRIDE; 140 141 // Returns all SPDY persistent settings. 142 virtual const net::SpdySettingsMap& spdy_settings_map() const OVERRIDE; 143 144 virtual net::HttpPipelinedHostCapability GetPipelineCapability( 145 const net::HostPortPair& origin) OVERRIDE; 146 147 virtual void SetPipelineCapability( 148 const net::HostPortPair& origin, 149 net::HttpPipelinedHostCapability capability) OVERRIDE; 150 151 virtual void ClearPipelineCapabilities() OVERRIDE; 152 153 virtual net::PipelineCapabilityMap GetPipelineCapabilityMap() const OVERRIDE; 154 155 protected: 156 // -------------------- 157 // SPDY related methods 158 159 // These are used to delay updating of the cached data in 160 // |http_server_properties_impl_| while the preferences are changing, and 161 // execute only one update per simultaneous prefs changes. 162 void ScheduleUpdateCacheOnUI(); 163 164 // Starts the timers to update the cached prefs. This are overridden in tests 165 // to prevent the delay. 166 virtual void StartCacheUpdateTimerOnUI(base::TimeDelta delay); 167 168 // Update cached prefs in |http_server_properties_impl_| with data from 169 // preferences. It gets the data on UI thread and calls 170 // UpdateSpdyServersFromPrefsOnIO() to perform the update on IO thread. 171 virtual void UpdateCacheFromPrefsOnUI(); 172 173 // Starts the update of cached prefs in |http_server_properties_impl_| on the 174 // IO thread. Protected for testing. 175 void UpdateCacheFromPrefsOnIO( 176 std::vector<std::string>* spdy_servers, 177 net::SpdySettingsMap* spdy_settings_map, 178 net::AlternateProtocolMap* alternate_protocol_map, 179 net::PipelineCapabilityMap* pipeline_capability_map, 180 bool detected_corrupted_prefs); 181 182 // These are used to delay updating the preferences when cached data in 183 // |http_server_properties_impl_| is changing, and execute only one update per 184 // simultaneous spdy_servers or spdy_settings or alternate_protocol changes. 185 void ScheduleUpdatePrefsOnIO(); 186 187 // Starts the timers to update the prefs from cache. This are overridden in 188 // tests to prevent the delay. 189 virtual void StartPrefsUpdateTimerOnIO(base::TimeDelta delay); 190 191 // Update prefs::kHttpServerProperties in preferences with the cached data 192 // from |http_server_properties_impl_|. This gets the data on IO thread and 193 // posts a task (UpdatePrefsOnUI) to update the preferences UI thread. 194 void UpdatePrefsFromCacheOnIO(); 195 196 // Same as above, but fires an optional |completion| callback on the UI thread 197 // when finished. Virtual for testing. 198 virtual void UpdatePrefsFromCacheOnIO(const base::Closure& completion); 199 200 // Update prefs::kHttpServerProperties preferences on UI thread. Executes an 201 // optional |completion| callback when finished. Protected for testing. 202 void UpdatePrefsOnUI( 203 base::ListValue* spdy_server_list, 204 net::SpdySettingsMap* spdy_settings_map, 205 net::AlternateProtocolMap* alternate_protocol_map, 206 net::PipelineCapabilityMap* pipeline_capability_map, 207 const base::Closure& completion); 208 209 private: 210 void OnHttpServerPropertiesChanged(); 211 212 // --------- 213 // UI thread 214 // --------- 215 216 // Used to get |weak_ptr_| to self on the UI thread. 217 scoped_ptr<base::WeakPtrFactory<HttpServerPropertiesManager> > 218 ui_weak_ptr_factory_; 219 220 base::WeakPtr<HttpServerPropertiesManager> ui_weak_ptr_; 221 222 // Used to post cache update tasks. 223 scoped_ptr<base::OneShotTimer<HttpServerPropertiesManager> > 224 ui_cache_update_timer_; 225 226 // Used to track the spdy servers changes. 227 PrefChangeRegistrar pref_change_registrar_; 228 PrefService* pref_service_; // Weak. 229 bool setting_prefs_; 230 231 // --------- 232 // IO thread 233 // --------- 234 235 // Used to get |weak_ptr_| to self on the IO thread. 236 scoped_ptr<base::WeakPtrFactory<HttpServerPropertiesManager> > 237 io_weak_ptr_factory_; 238 239 // Used to post |prefs::kHttpServerProperties| pref update tasks. 240 scoped_ptr<base::OneShotTimer<HttpServerPropertiesManager> > 241 io_prefs_update_timer_; 242 243 scoped_ptr<net::HttpServerPropertiesImpl> http_server_properties_impl_; 244 245 DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManager); 246 }; 247 248 } // namespace chrome_browser_net 249 250 #endif // CHROME_BROWSER_NET_HTTP_SERVER_PROPERTIES_MANAGER_H_ 251