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