Make SdchManager per-profile.

net/base/sdch_manager.h

 // Copyright (c) 2011 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.
 
 // Provides global database of differential decompression dictionaries for the
 // SDCH filter (processes sdch enconded content).
 
 // Exactly one instance of SdchManager is built, and all references are made
 // into that collection.
 //
@@ skipping 216 matching lines @@
     const std::string path_;
     const base::Time expiration_;  // Implied by max-age.
     const std::set<int> ports_;
 
     DISALLOW_COPY_AND_ASSIGN(Dictionary);
   };
 
   SdchManager();
   ~SdchManager();
 
-  // Discontinue fetching of dictionaries, as we're now shutting down.
-  static void Shutdown();
-
-  // Provide access to the single instance of this class.
-  static SdchManager* Global();
-
   // Record stats on various errors.
   static void SdchErrorRecovery(ProblemCodes problem);
 
   // Register a fetcher that this class can use to obtain dictionaries.
   void set_sdch_fetcher(SdchFetcher* fetcher);
 
   // Enables or disables SDCH compression.
   static void EnableSdchSupport(bool enabled);
 
   static bool sdch_enabled() { return g_sdch_enabled_; }
 
   // Enables or disables SDCH compression over secure connection.
   static void EnableSecureSchemeSupport(bool enabled);
 
   static bool secure_scheme_supported() { return g_secure_scheme_supported_; }
 
   // Briefly prevent further advertising of SDCH on this domain (if SDCH is
   // enabled). After enough calls to IsInSupportedDomain() the blacklisting
   // will be removed.  Additional blacklists take exponentially more calls
   // to IsInSupportedDomain() before the blacklisting is undone.
   // Used when filter errors are found from a given domain, but it is plausible
   // that the cause is temporary (such as application startup, where cached
   // entries are used, but a dictionary is not yet loaded).
-  static void BlacklistDomain(const GURL& url);
+  void BlacklistDomain(const GURL& url);
 
   // Used when SEVERE filter errors are found from a given domain, to prevent
   // further use of SDCH on that domain.
-  static void BlacklistDomainForever(const GURL& url);
+  void BlacklistDomainForever(const GURL& url);
 
   // Unit test only, this function resets enabling of sdch, and clears the
   // blacklist.
-  static void ClearBlacklistings();
+  void ClearBlacklistings();
 
   // Unit test only, this function resets the blacklisting count for a domain.
-  static void ClearDomainBlacklisting(const std::string& domain);
+  void ClearDomainBlacklisting(const std::string& domain);
 
   // Unit test only: indicate how many more times a domain will be blacklisted.
-  static int BlackListDomainCount(const std::string& domain);
+  int BlackListDomainCount(const std::string& domain);
 
   // Unit test only: Indicate what current blacklist increment is for a domain.
-  static int BlacklistDomainExponential(const std::string& domain);
+  int BlacklistDomainExponential(const std::string& domain);
 
   // Check to see if SDCH is enabled (globally), and the given URL is in a
   // supported domain (i.e., not blacklisted, and either the specific supported
   // domain, or all domains were assumed supported).  If it is blacklist, reduce
   // by 1 the number of times it will be reported as blacklisted.
   bool IsInSupportedDomain(const GURL& url);
 
   // Schedule the URL fetching to load a dictionary. This will always return
   // before the dictionary is actually loaded and added.
   // After the implied task does completes, the dictionary will have been
@@ skipping 42 matching lines @@
 
   void SetAllowLatencyExperiment(const GURL& url, bool enable);
 
  private:
   typedef std::map<std::string, int> DomainCounter;
   typedef std::set<std::string> ExperimentSet;
 
   // A map of dictionaries info indexed by the hash that the server provides.
   typedef std::map<std::string, Dictionary*> DictionaryMap;
 
-  // The one global instance of that holds all the data.
-  static SdchManager* global_;
-
   // Support SDCH compression, by advertising in headers.
   static bool g_sdch_enabled_;
 
   // Support SDCH compression for HTTPS requests and responses. When supported,
   // HTTPS applicable dictionaries MUST have been acquired securely via HTTPS.
   static bool g_secure_scheme_supported_;
 
   // A simple implementation of a RFC 3548 "URL safe" base64 encoder.
   static void UrlSafeBase64Encode(const std::string& input,
                                   std::string* output);
@@ skipping 13 matching lines @@
   // List of hostnames for which a latency experiment is allowed (because a
   // round trip test has recently passed).
   ExperimentSet allow_latency_experiment_;
 
   DISALLOW_COPY_AND_ASSIGN(SdchManager);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_SDCH_MANAGER_H_