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

net/http/http_server_properties_manager.h

Index: net/http/http_server_properties_manager.h
diff --git a/chrome/browser/net/http_server_properties_manager.h b/net/http/http_server_properties_manager.h
similarity index 78%
rename from chrome/browser/net/http_server_properties_manager.h
rename to net/http/http_server_properties_manager.h
index 71de395dc514cce6c8fa2789d795c25cef890449..9529749b6b398f72b2a954c0185c7e071b2b01cc 100644
--- a/chrome/browser/net/http_server_properties_manager.h
+++ b/net/http/http_server_properties_manager.h
@@ -20,11 +20,11 @@
 
 class PrefService;
 
-namespace user_prefs {
-class PrefRegistrySyncable;
+namespace base {
+class SingleThreadTaskRunner;
 }
 
-namespace chrome_browser_net {
+namespace net {
 
 ////////////////////////////////////////////////////////////////////////////////
 //  HttpServerPropertiesManager
@@ -48,13 +48,17 @@ namespace chrome_browser_net {
 // 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 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(
+      PrefService* pref_service,
+      const char* path,

[mmenke, 2014/07/08 15:05:48]

I don't think it's clear that path is the preference path, as opposed to a file
path of a preference file.

[mef, 2014/07/08 18:04:32]

Done.

+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);

[mmenke, 2014/07/08 15:05:48]

net/ shouldn't know (or care) what a UI thread is.  Suggest calling it the
profile_task_runner.

Hrm...We're also requiring it be the current thread.  Could even just grab the
current message loop proxy.

[mef, 2014/07/08 18:04:32]

Done. As we don't want this class to know about profile I've called it pref_xyz.

   virtual ~HttpServerPropertiesManager();
 
   // Initialize |http_server_properties_impl_| and |io_method_factory_| on IO
@@ -65,9 +69,6 @@ class HttpServerPropertiesManager
   // 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);
-
   // Helper function for unit tests to set the version in the dictionary.
   static void SetVersion(base::DictionaryValue* http_server_properties_dict,
                          int version_number);
@@ -77,90 +78,90 @@ class HttpServerPropertiesManager
   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::PortAlternateProtocolPair GetAlternateProtocol(
-      const net::HostPortPair& server) OVERRIDE;
+  virtual PortAlternateProtocolPair 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) OVERRIDE;
+      AlternateProtocol alternate_protocol) OVERRIDE;
 
   // Sets the Alternate-Protocol for |server| to be BROKEN.
   virtual void SetBrokenAlternateProtocol(
-      const net::HostPortPair& server) OVERRIDE;
+      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;
+      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&
+  virtual const AlternateProtocolMap&
       alternate_protocol_map() const OVERRIDE;
 
   virtual void SetAlternateProtocolExperiment(
-      net::AlternateProtocolExperiment experiment) OVERRIDE;
+      AlternateProtocolExperiment experiment) 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;
+      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:
   // --------------------
@@ -184,9 +185,9 @@ class HttpServerPropertiesManager
   // IO thread. Protected for testing.
   void UpdateCacheFromPrefsOnIO(
       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
@@ -211,8 +212,8 @@ class HttpServerPropertiesManager
   // 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,
+      SpdySettingsMap* spdy_settings_map,
+      AlternateProtocolMap* alternate_protocol_map,
       const base::Closure& completion);
 
  private:
@@ -222,6 +223,8 @@ class HttpServerPropertiesManager
   // UI thread
   // ---------
 
+  const scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
+
   // Used to get |weak_ptr_| to self on the UI thread.
   scoped_ptr<base::WeakPtrFactory<HttpServerPropertiesManager> >
       ui_weak_ptr_factory_;
@@ -236,11 +239,14 @@ class HttpServerPropertiesManager
   PrefChangeRegistrar pref_change_registrar_;
   PrefService* pref_service_;  // Weak.
   bool setting_prefs_;
+  const char* path_;
 
   // ---------
   // IO thread
   // ---------
 
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+
   // Used to get |weak_ptr_| to self on the IO thread.
   scoped_ptr<base::WeakPtrFactory<HttpServerPropertiesManager> >
       io_weak_ptr_factory_;
@@ -249,7 +255,7 @@ class HttpServerPropertiesManager
   scoped_ptr<base::OneShotTimer<HttpServerPropertiesManager> >
       io_prefs_update_timer_;
 
-  scoped_ptr<net::HttpServerPropertiesImpl> http_server_properties_impl_;
+  scoped_ptr<HttpServerPropertiesImpl> http_server_properties_impl_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManager);
 };