Clear SDCH information on "Clear browsing data" path.

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 31 matching lines @@
 // functionality in this base (when the functionaity can be provided).
 class SdchFetcher {
  public:
   SdchFetcher() {}
   virtual ~SdchFetcher() {}
 
   // The Schedule() method is called when there is a need to get a dictionary
   // from a server.  The callee is responsible for getting that dictionary_text,
   // and then calling back to AddSdchDictionary() to the SdchManager instance.
   virtual void Schedule(const GURL& dictionary_url) = 0;
+
+  // The Cancel() method is called to cancel all pending dictionary fetches.
+  // This is used for implementation of ClearData() below.
+  virtual void Cancel() = 0;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(SdchFetcher);
 };
 
 //------------------------------------------------------------------------------
 
 class NET_EXPORT SdchManager : public NON_EXPORTED_BASE(base::NonThreadSafe) {
  public:
   // A list of errors that appeared and were either resolved, or used to turn
   // off sdch encoding.
@@ skipping 165 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();
 
+  // Clear data (for browser data removal).
+  void ClearData();
+
   // 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_; }
@@ skipping 50 matching lines @@
   // will fail (return false) if addition is illegal (data in the dictionary is
   // not acceptable from the dictionary_url; dictionary already added, etc.).
   bool AddSdchDictionary(const std::string& dictionary_text,
                          const GURL& dictionary_url);
 
   // Find the vcdiff dictionary (the body of the sdch dictionary that appears
   // after the meta-data headers like Domain:...) with the given |server_hash|
   // to use to decompreses data that arrived as SDCH encoded content.  Check to
   // be sure the returned |dictionary| can be used for decoding content supplied
   // in response to a request for |referring_url|.
-  // Caller is responsible for AddRef()ing the dictionary, and Release()ing it
-  // when done.
   // Return null in |dictionary| if there is no matching legal dictionary.
   void GetVcdiffDictionary(const std::string& server_hash,
                            const GURL& referring_url,
-                           Dictionary** dictionary);
+                           scoped_refptr<Dictionary>* dictionary);
 
   // Get list of available (pre-cached) dictionaries that we have already loaded
   // into memory.  The list is a comma separated list of (client) hashes per
   // the SDCH spec.
   void GetAvailDictionaryList(const GURL& target_url, std::string* list);
 
   // Construct the pair of hashes for client and server to identify an SDCH
   // dictionary.  This is only made public to facilitate unit testing, but is
   // otherwise private
   static void GenerateHash(const std::string& dictionary_text,
                            std::string* client_hash, std::string* server_hash);
 
   // For Latency testing only, we need to know if we've succeeded in doing a
   // round trip before starting our comparative tests.  If ever we encounter
   // problems with SDCH, we opt-out of the test unless/until we perform a
   // complete SDCH decoding.
   bool AllowLatencyExperiment(const GURL& url) const;
 
   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;
+  typedef std::map<std::string, scoped_refptr<Dictionary> > DictionaryMap;
 
   // 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);
   DictionaryMap dictionaries_;
 
   // An instance that can fetch a dictionary given a URL.
   scoped_ptr<SdchFetcher> fetcher_;
 
   // List domains where decode failures have required disabling sdch, along with
   // count of how many additonal uses should be blacklisted.
   DomainCounter blacklisted_domains_;
 
   // Support exponential backoff in number of domain accesses before
   // blacklisting expires.
-  DomainCounter exponential_blacklist_count;
+  DomainCounter exponential_blacklist_count_;
 
   // 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_