Move http_server_properties_manager from chrome/browser/net to net/http.

net/http/http_server_properties_manager.h

 // 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.
 
-#ifndef CHROME_BROWSER_NET_HTTP_SERVER_PROPERTIES_MANAGER_H_
-#define CHROME_BROWSER_NET_HTTP_SERVER_PROPERTIES_MANAGER_H_
+#ifndef NET_HTTP_HTTP_SERVER_PROPERTIES_MANAGER_H_
+#define NET_HTTP_HTTP_SERVER_PROPERTIES_MANAGER_H_
 
 #include <string>
 #include <vector>
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "net/base/host_port_pair.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_server_properties_impl.h"
 
 class PrefService;
 
-namespace user_prefs {
-class PrefRegistrySyncable;
+namespace base {
+class SequencedTaskRunner;
 }
 
-namespace chrome_browser_net {
+namespace net {
 
 ////////////////////////////////////////////////////////////////////////////////
-//  HttpServerPropertiesManager
+// HttpServerPropertiesManager
 
 // The manager for creating and updating an HttpServerProperties (for example it
 // tracks if a server supports SPDY or not).
 //
-// This class interacts with both the UI thread, where notifications of pref
-// changes are received from, and the IO thread, which owns it (in the
-// ProfileIOData) and it persists the changes from network stack that if a
-// server supports SPDY or not.
+// This class interacts with both the pref thread, where notifications of pref
+// changes are received from, and the network thread, which owns it, and it
+// persists the changes from network stack whether server supports SPDY or not.
 //
-// It must be constructed on the UI thread, to set up |ui_method_factory_| and
+// It must be constructed on the pref thread, to set up |pref_task_runner_| and
 // the prefs listeners.
 //
-// ShutdownOnUIThread must be called from UI before destruction, to release
-// the prefs listeners on the UI thread. This is done from ProfileIOData.
+// ShutdownOnPrefThread must be called from pref thread before destruction, to
+// release the prefs listeners on the pref thread.
 //
-// Update tasks from the UI thread can post safely to the IO thread, since the
-// destruction order of Profile and ProfileIOData guarantees that if this
-// exists in UI, then a potential destruction on IO will come after any task
-// posted to IO from that method on UI. This is used to go through IO before
-// the actual update starts, and grab a WeakPtr.
-class HttpServerPropertiesManager
-    : public net::HttpServerProperties {
+// Class requires that update tasks from the Pref thread can post safely to the
+// network thread, so the destruction order must guarantee that if |this|
+// exists in pref thread, then a potential destruction on network thread will
+// come after any task posted to network thread from that method on pref thread.
+// This is used to go through network thread before the actual update starts,
+// and grab a WeakPtr.
+class NET_EXPORT HttpServerPropertiesManager : public HttpServerProperties {
  public:
   // Create an instance of the HttpServerPropertiesManager. The lifetime of the
   // PrefService objects must be longer than that of the
-  // HttpServerPropertiesManager object. Must be constructed on the UI thread.
-  explicit HttpServerPropertiesManager(PrefService* pref_service);
+  // HttpServerPropertiesManager object. Must be constructed on the Pref thread.
+  HttpServerPropertiesManager(
+      PrefService* pref_service,
+      const char* pref_path,
+      scoped_refptr<base::SequencedTaskRunner> network_task_runner);
   virtual ~HttpServerPropertiesManager();
 
-  // Initialize |http_server_properties_impl_| and |io_method_factory_| on IO
-  // thread. It also posts a task to UI thread to get SPDY Server preferences
-  // from |pref_service_|.
-  void InitializeOnIOThread();
+  // Initialize on Network thread.
+  void InitializeOnNetworkThread();
 
-  // Prepare for shutdown. Must be called on the UI thread, before destruction.
-  void ShutdownOnUIThread();
-
-  // Register |prefs| for properties managed here.
-  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
+  // Prepare for shutdown. Must be called on the Pref thread before destruction.
+  void ShutdownOnPrefThread();
 
   // Helper function for unit tests to set the version in the dictionary.
   static void SetVersion(base::DictionaryValue* http_server_properties_dict,
                          int version_number);
 
   // Deletes all data. Works asynchronously, but if a |completion| callback is
-  // provided, it will be fired on the UI thread when everything is done.
+  // provided, it will be fired on the pref thread when everything is done.
   void Clear(const base::Closure& completion);
 
   // ----------------------------------
-  // net::HttpServerProperties methods:
+  // HttpServerProperties methods:
   // ----------------------------------
 
   // Gets a weak pointer for this object.
-  virtual base::WeakPtr<net::HttpServerProperties> GetWeakPtr() OVERRIDE;
+  virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() OVERRIDE;
 
   // Deletes all data. Works asynchronously.
   virtual void Clear() OVERRIDE;
 
   // Returns true if |server| supports SPDY. Should only be called from IO
   // thread.
-  virtual bool SupportsSpdy(const net::HostPortPair& server) OVERRIDE;
+  virtual bool SupportsSpdy(const HostPortPair& server) OVERRIDE;
 
   // Add |server| as the SPDY server which supports SPDY protocol into the
   // persisitent store. Should only be called from IO thread.
-  virtual void SetSupportsSpdy(const net::HostPortPair& server,
+  virtual void SetSupportsSpdy(const HostPortPair& server,
                                bool support_spdy) OVERRIDE;
 
   // Returns true if |server| has an Alternate-Protocol header.
-  virtual bool HasAlternateProtocol(const net::HostPortPair& server) OVERRIDE;
+  virtual bool HasAlternateProtocol(const HostPortPair& server) OVERRIDE;
 
   // Returns the Alternate-Protocol and port for |server|.
   // HasAlternateProtocol(server) must be true.
-  virtual net::AlternateProtocolInfo GetAlternateProtocol(
-      const net::HostPortPair& server) OVERRIDE;
+  virtual AlternateProtocolInfo GetAlternateProtocol(
+      const HostPortPair& server) OVERRIDE;
 
   // Sets the Alternate-Protocol for |server|.
   virtual void SetAlternateProtocol(
-      const net::HostPortPair& server,
+      const HostPortPair& server,
       uint16 alternate_port,
-      net::AlternateProtocol alternate_protocol,
+      AlternateProtocol alternate_protocol,
       double alternate_probability) OVERRIDE;
 
   // Sets the Alternate-Protocol for |server| to be BROKEN.
-  virtual void SetBrokenAlternateProtocol(
-      const net::HostPortPair& server) OVERRIDE;
+  virtual void SetBrokenAlternateProtocol(const HostPortPair& server) OVERRIDE;
 
   // Returns true if Alternate-Protocol for |server| was recently BROKEN.
   virtual bool WasAlternateProtocolRecentlyBroken(
-      const net::HostPortPair& server) OVERRIDE;
+      const HostPortPair& server) OVERRIDE;
 
   // Confirms that Alternate-Protocol for |server| is working.
-  virtual void ConfirmAlternateProtocol(
-      const net::HostPortPair& server) OVERRIDE;
+  virtual void ConfirmAlternateProtocol(const HostPortPair& server) OVERRIDE;
 
   // Clears the Alternate-Protocol for |server|.
-  virtual void ClearAlternateProtocol(const net::HostPortPair& server) OVERRIDE;
+  virtual void ClearAlternateProtocol(const HostPortPair& server) OVERRIDE;
 
   // Returns all Alternate-Protocol mappings.
-  virtual const net::AlternateProtocolMap&
-      alternate_protocol_map() const OVERRIDE;
+  virtual const AlternateProtocolMap& alternate_protocol_map() const OVERRIDE;
 
   virtual void SetAlternateProtocolExperiment(
-      net::AlternateProtocolExperiment experiment) OVERRIDE;
+      AlternateProtocolExperiment experiment) OVERRIDE;
 
   virtual void SetAlternateProtocolProbabilityThreshold(
       double threshold) OVERRIDE;
 
-  virtual net::AlternateProtocolExperiment GetAlternateProtocolExperiment()
+  virtual AlternateProtocolExperiment GetAlternateProtocolExperiment()
       const OVERRIDE;
 
   // Gets a reference to the SettingsMap stored for a host.
   // If no settings are stored, returns an empty SettingsMap.
-  virtual const net::SettingsMap& GetSpdySettings(
-      const net::HostPortPair& host_port_pair) OVERRIDE;
+  virtual const SettingsMap& GetSpdySettings(
+      const HostPortPair& host_port_pair) OVERRIDE;
 
   // Saves an individual SPDY setting for a host. Returns true if SPDY setting
   // is to be persisted.
-  virtual bool SetSpdySetting(const net::HostPortPair& host_port_pair,
-                              net::SpdySettingsIds id,
-                              net::SpdySettingsFlags flags,
+  virtual bool SetSpdySetting(const HostPortPair& host_port_pair,
+                              SpdySettingsIds id,
+                              SpdySettingsFlags flags,
                               uint32 value) OVERRIDE;
 
   // Clears all SPDY settings for a host.
-  virtual void ClearSpdySettings(
-      const net::HostPortPair& host_port_pair) OVERRIDE;
+  virtual void ClearSpdySettings(const HostPortPair& host_port_pair) OVERRIDE;
 
   // Clears all SPDY settings for all hosts.
   virtual void ClearAllSpdySettings() OVERRIDE;
 
   // Returns all SPDY persistent settings.
-  virtual const net::SpdySettingsMap& spdy_settings_map() const OVERRIDE;
+  virtual const SpdySettingsMap& spdy_settings_map() const OVERRIDE;
 
-  virtual void SetServerNetworkStats(const net::HostPortPair& host_port_pair,
+  virtual void SetServerNetworkStats(const HostPortPair& host_port_pair,
                                      NetworkStats stats) OVERRIDE;
 
   virtual const NetworkStats* GetServerNetworkStats(
-      const net::HostPortPair& host_port_pair) const OVERRIDE;
+      const HostPortPair& host_port_pair) const OVERRIDE;
 
  protected:
   // --------------------
   // SPDY related methods
 
   // These are used to delay updating of the cached data in
   // |http_server_properties_impl_| while the preferences are changing, and
   // execute only one update per simultaneous prefs changes.
-  void ScheduleUpdateCacheOnUI();
+  void ScheduleUpdateCacheOnPrefThread();
 
   // Starts the timers to update the cached prefs. This are overridden in tests
   // to prevent the delay.
-  virtual void StartCacheUpdateTimerOnUI(base::TimeDelta delay);
+  virtual void StartCacheUpdateTimerOnPrefThread(base::TimeDelta delay);
 
   // Update cached prefs in |http_server_properties_impl_| with data from
-  // preferences. It gets the data on UI thread and calls
-  // UpdateSpdyServersFromPrefsOnIO() to perform the update on IO thread.
-  virtual void UpdateCacheFromPrefsOnUI();
+  // preferences. It gets the data on pref thread and calls
+  // UpdateSpdyServersFromPrefsOnNetworkThread() to perform the update on
+  // network thread.
+  virtual void UpdateCacheFromPrefsOnPrefThread();
 
   // Starts the update of cached prefs in |http_server_properties_impl_| on the
-  // IO thread. Protected for testing.
-  void UpdateCacheFromPrefsOnIO(
+  // network thread. Protected for testing.
+  void UpdateCacheFromPrefsOnNetworkThread(
       std::vector<std::string>* spdy_servers,
-      net::SpdySettingsMap* spdy_settings_map,
-      net::AlternateProtocolMap* alternate_protocol_map,
-      net::AlternateProtocolExperiment alternate_protocol_experiment,
+      SpdySettingsMap* spdy_settings_map,
+      AlternateProtocolMap* alternate_protocol_map,
+      AlternateProtocolExperiment alternate_protocol_experiment,
       bool detected_corrupted_prefs);
 
   // These are used to delay updating the preferences when cached data in
   // |http_server_properties_impl_| is changing, and execute only one update per
   // simultaneous spdy_servers or spdy_settings or alternate_protocol changes.
-  void ScheduleUpdatePrefsOnIO();
+  void ScheduleUpdatePrefsOnNetworkThread();
 
   // Starts the timers to update the prefs from cache. This are overridden in
   // tests to prevent the delay.
-  virtual void StartPrefsUpdateTimerOnIO(base::TimeDelta delay);
+  virtual void StartPrefsUpdateTimerOnNetworkThread(base::TimeDelta delay);
 
   // Update prefs::kHttpServerProperties in preferences with the cached data
-  // from |http_server_properties_impl_|. This gets the data on IO thread and
-  // posts a task (UpdatePrefsOnUI) to update the preferences UI thread.
-  void UpdatePrefsFromCacheOnIO();
+  // from |http_server_properties_impl_|. This gets the data on network thread
+  // and posts a task (UpdatePrefsOnPrefThread) to update preferences on pref
+  // thread.
+  void UpdatePrefsFromCacheOnNetworkThread();
 
-  // Same as above, but fires an optional |completion| callback on the UI thread
+  // Same as above, but fires an optional |completion| callback on pref thread
   // when finished. Virtual for testing.
-  virtual void UpdatePrefsFromCacheOnIO(const base::Closure& completion);
+  virtual void UpdatePrefsFromCacheOnNetworkThread(
+      const base::Closure& completion);
 
-  // Update prefs::kHttpServerProperties preferences on UI thread. Executes an
+  // Update prefs::kHttpServerProperties preferences on pref thread. Executes an
   // optional |completion| callback when finished. Protected for testing.
-  void UpdatePrefsOnUI(
-      base::ListValue* spdy_server_list,
-      net::SpdySettingsMap* spdy_settings_map,
-      net::AlternateProtocolMap* alternate_protocol_map,
-      const base::Closure& completion);
+  void UpdatePrefsOnPrefThread(base::ListValue* spdy_server_list,
+                               SpdySettingsMap* spdy_settings_map,
+                               AlternateProtocolMap* alternate_protocol_map,
+                               const base::Closure& completion);
 
  private:
   void OnHttpServerPropertiesChanged();
 
-  // ---------
-  // UI thread
-  // ---------
+  // -----------
+  // Pref thread
+  // -----------
 
-  // Used to get |weak_ptr_| to self on the UI thread.
+  const scoped_refptr<base::SequencedTaskRunner> pref_task_runner_;
+
+  // Used to get |weak_ptr_| to self on the pref thread.
   scoped_ptr<base::WeakPtrFactory<HttpServerPropertiesManager> >
-      ui_weak_ptr_factory_;
+      pref_weak_ptr_factory_;
 
-  base::WeakPtr<HttpServerPropertiesManager> ui_weak_ptr_;
+  base::WeakPtr<HttpServerPropertiesManager> pref_weak_ptr_;
 
   // Used to post cache update tasks.
   scoped_ptr<base::OneShotTimer<HttpServerPropertiesManager> >
-      ui_cache_update_timer_;
+      pref_cache_update_timer_;
 
   // Used to track the spdy servers changes.
   PrefChangeRegistrar pref_change_registrar_;
   PrefService* pref_service_;  // Weak.
   bool setting_prefs_;
+  const char* path_;
 
-  // ---------
-  // IO thread
-  // ---------
+  // --------------
+  // Network thread
+  // --------------
 
-  // Used to get |weak_ptr_| to self on the IO thread.
+  const scoped_refptr<base::SequencedTaskRunner> network_task_runner_;
+
+  // Used to get |weak_ptr_| to self on the network thread.
   scoped_ptr<base::WeakPtrFactory<HttpServerPropertiesManager> >
-      io_weak_ptr_factory_;
+      network_weak_ptr_factory_;
 
   // Used to post |prefs::kHttpServerProperties| pref update tasks.
   scoped_ptr<base::OneShotTimer<HttpServerPropertiesManager> >
-      io_prefs_update_timer_;
+      network_prefs_update_timer_;
 
-  scoped_ptr<net::HttpServerPropertiesImpl> http_server_properties_impl_;
+  scoped_ptr<HttpServerPropertiesImpl> http_server_properties_impl_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManager);
 };
 
-}  // namespace chrome_browser_net
+}  // namespace net
 
-#endif  // CHROME_BROWSER_NET_HTTP_SERVER_PROPERTIES_MANAGER_H_
+#endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_MANAGER_H_