Change SDCHDictionaryFetcher to use URLRequest instead of URLFetcher.

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.
 //
-// The SdchManager maintains a collection of memory resident dictionaries.  It
+// The SdchManager maintains a collection of memory resident dictionaries. It
 // can find a dictionary (based on a server specification of a hash), store a
 // dictionary, and make judgements about what URLs can use, set, etc. a
 // dictionary.
 
 // These dictionaries are acquired over the net, and include a header
 // (containing metadata) as well as a VCDIFF dictionary (for use by a VCDIFF
 // module) to decompress data.
 
 #ifndef NET_BASE_SDCH_MANAGER_H_
 #define NET_BASE_SDCH_MANAGER_H_
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "url/gurl.h"
 
 namespace net {
 
 //------------------------------------------------------------------------------
 // Create a public interface to help us load SDCH dictionaries.
 // The SdchManager class allows registration to support this interface.
 // A browser may register a fetcher that is used by the dictionary managers to
-// get data from a specified URL.  This allows us to use very high level browser
-// functionality in this base (when the functionaity can be provided).
+// get data from a specified URL. This allows us to use very high level browser
+// functionality in this base (when the functionality can be provided).
 class NET_EXPORT SdchFetcher {
  public:
+  class Delegate {
+   public:
+    virtual ~Delegate() {}
+
+    // Deliver the fetched dictionary back to the consumer.

[Ryan Sleevi, 2014/09/08 19:29:54]

Documentation:

// Called whenever the SdchFetcher has successfully retrieved a
// dictionary. |dictionary_text| contains the body of the dictionary
// retrieved from |dictionary_url|.


That is, in the case of a Delegate interface, you're trying to document either
when an implementation can expect the call, or what a caller expects of the
implementation.

[Randy Smith (Not in Mondays), 2014/09/08 20:03:29]

Good point.  Done.

+    virtual void AddSdchDictionary(const std::string& dictionary_text,
+                                   const GURL& dictionary_url) = 0;
+  };
+
   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.
+  // from a server. The callee is responsible for getting that dictionary_text,
+  // and then calling back to AddSdchDictionary() in the Delegate 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) {
+class NET_EXPORT SdchManager
+    : public SdchFetcher::Delegate,
+      public NON_EXPORTED_BASE(base::NonThreadSafe) {
  public:
   // A list of errors that appeared and were either resolved, or used to turn
   // off sdch encoding.
   enum ProblemCodes {
     MIN_PROBLEM_CODE,
 
     // Content-encoding correction problems.
     ADDED_CONTENT_ENCODING = 1,
     FIXED_CONTENT_ENCODING = 2,
     FIXED_CONTENT_ENCODINGS = 3,
@@ skipping 97 matching lines @@
    public:
     // Sdch filters can get our text to use in decoding compressed data.
     const std::string& text() const { return text_; }
 
    private:
     friend class base::RefCounted<Dictionary>;
     friend class SdchManager;  // Only manager can construct an instance.
     FRIEND_TEST_ALL_PREFIXES(SdchManagerTest, PathMatch);
 
     // Construct a vc-diff usable dictionary from the dictionary_text starting
-    // at the given offset.  The supplied client_hash should be used to
+    // at the given offset. The supplied client_hash should be used to
     // advertise the dictionary's availability relative to the suppplied URL.
     Dictionary(const std::string& dictionary_text,
                size_t offset,
                const std::string& client_hash,
                const GURL& url,
                const std::string& domain,
                const std::string& path,
                const base::Time& expiration,
                const std::set<int>& ports);
-    ~Dictionary();
+    virtual ~Dictionary();
 
     const GURL& url() const { return url_; }
     const std::string& client_hash() const { return client_hash_; }
 
     // Security method to check if we can advertise this dictionary for use
     // if the |target_url| returns SDCH compressed data.
     bool CanAdvertise(const GURL& target_url);
 
     // Security methods to check if we can establish a new dictionary with the
     // given data, that arrived in response to get of dictionary_url.
@@ skipping 18 matching lines @@
     // Part of the hash of text_ that the client uses to advertise the fact that
     // it has a specific dictionary pre-cached.
     std::string client_hash_;
 
     // The GURL that arrived with the text_ in a URL request to specify where
     // this dictionary may be used.
     const GURL url_;
 
     // Metadate "headers" in before dictionary text contained the following:
     // Each dictionary payload consists of several headers, followed by the text
-    // of the dictionary.  The following are the known headers.
+    // of the dictionary. The following are the known headers.
     const std::string domain_;
     const std::string path_;
     const base::Time expiration_;  // Implied by max-age.
     const std::set<int> ports_;
 
     DISALLOW_COPY_AND_ASSIGN(Dictionary);
   };
 
   SdchManager();
-  ~SdchManager();
+  virtual ~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(scoped_ptr<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
+  // 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).
   void BlacklistDomain(const GURL& url, ProblemCodes blacklist_reason);
 
   // Used when SEVERE filter errors are found from a given domain, to prevent
   // further use of SDCH on that domain.
   void BlacklistDomainForever(const GURL& url, ProblemCodes blacklist_reason);
 
   // Unit test only, this function resets enabling of sdch, and clears the
   // blacklist.
   void ClearBlacklistings();
 
   // Unit test only, this function resets the blacklisting count for a domain.
   void ClearDomainBlacklisting(const std::string& domain);
 
   // Unit test only: indicate how many more times a domain will be blacklisted.
   int BlackListDomainCount(const std::string& domain);
 
   // Unit test only: Indicate what current blacklist increment is for a 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
+  // 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
   // cached in memory.
   void FetchDictionary(const GURL& request_url, const GURL& dictionary_url);
 
   // Security test function used before initiating a FetchDictionary.
   // Return true if fetch is legal.
   bool CanFetchDictionary(const GURL& referring_url,
                           const GURL& dictionary_url) const;
 
-  // Add an SDCH dictionary to our list of availible dictionaries. This addition
-  // 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
+  // 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|.
   // Return null in |dictionary| if there is no matching legal dictionary.
   void GetVcdiffDictionary(const std::string& server_hash,
                            const GURL& referring_url,
                            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
+  // 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
+  // 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
+  // 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);
 
   int GetFetchesCountForTesting() const {
     return fetches_count_for_testing_;
   }
 
+  // Implementation of SdchFetcher::Delegate.
+
+  // Add an SDCH dictionary to our list of availible
+  // dictionaries. This addition will fail if addition is illegal
+  // (data in the dictionary is not acceptable from the
+  // dictionary_url; dictionary already added, etc.).
+  virtual void AddSdchDictionary(const std::string& dictionary_text,
+                                 const GURL& dictionary_url) OVERRIDE;
+
  private:
   struct BlacklistInfo {
     BlacklistInfo()
         : count(0),
           exponential_count(0),
           reason(MIN_PROBLEM_CODE) {}
 
     int count;                   // # of times to refuse SDCH advertisement.
     int exponential_count;       // Current exponential backoff ratchet.
     ProblemCodes reason;         // Why domain was blacklisted.
@@ skipping 28 matching lines @@
   ExperimentSet allow_latency_experiment_;
 
   int fetches_count_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(SdchManager);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_SDCH_MANAGER_H_