Pin dictionaries from being deleted while request is outstanding.

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.
 
 #ifndef NET_BASE_SDCH_MANAGER_H_
 #define NET_BASE_SDCH_MANAGER_H_
 
 #include <map>
 #include <set>
 #include <string>
+#include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "url/gurl.h"
 
 namespace net {
 
 class SdchObserver;
 
 // Provides global database of differential decompression dictionaries for the
 // SDCH filter (processes sdch enconded content).
 //
 // 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.
 class NET_EXPORT SdchManager {
  public:
+  class DictionarySet;
+
   // A list of errors that appeared and were either resolved, or used to turn
   // off sdch encoding.
   enum ProblemCodes {
-    MIN_PROBLEM_CODE,
+    OK,
 
     // Content-encoding correction problems.
     ADDED_CONTENT_ENCODING = 1,
     FIXED_CONTENT_ENCODING = 2,
     FIXED_CONTENT_ENCODINGS = 3,
 
     // Content decoding errors.
     DECODE_HEADER_ERROR = 4,
     DECODE_BODY_ERROR = 5,
 
@@ skipping 30 matching lines @@
     DICTIONARY_SELECTED_FROM_NON_HTTP = 33,
     DICTIONARY_IS_TOO_LARGE= 34,
     DICTIONARY_COUNT_EXCEEDED = 35,
     DICTIONARY_ALREADY_SCHEDULED_TO_DOWNLOAD = 36,
     DICTIONARY_ALREADY_TRIED_TO_DOWNLOAD = 37,
     DICTIONARY_FETCH_READ_FAILED = 38,
 
     // Failsafe hack.
     ATTEMPT_TO_DECODE_NON_HTTP_DATA = 40,
 
-
     // Content-Encoding problems detected, with no action taken.
     MULTIENCODING_FOR_NON_SDCH_REQUEST = 50,
     SDCH_CONTENT_ENCODE_FOR_NON_SDCH_REQUEST = 51,
 
+    // A dictionary that wasn't advertised is being used for decoding.
+    UNADVERTISED_SDCH_DICTIONARY_USED = 52,
+    UNADVERTISED_SDCH_DICTIONARY_USED_CACHED = 52,

[Bence, 2014/11/12 21:46:26]

Last value should be 53 instead of 52.

[Randy Smith (Not in Mondays), 2014/11/13 22:11:02]

Whoops; thanks for the catch.

+
     // Dictionary manager issues.
     DOMAIN_BLACKLIST_INCLUDES_TARGET = 61,
 
     // Problematic decode recovery methods.
     META_REFRESH_RECOVERY = 70,            // Dictionary not found.
     // defunct =  71, // Almost the same as META_REFRESH_UNSUPPORTED.
     // defunct = 72,  // Almost the same as CACHED_META_REFRESH_UNSUPPORTED.
     // defunct = 73,  // PASSING_THROUGH_NON_SDCH plus
                       // RESPONSE_TENTATIVE_SDCH in ../filter/sdch_filter.cc.
     META_REFRESH_UNSUPPORTED = 74,         // Unrecoverable error.
@@ skipping 28 matching lines @@
     MAX_PROBLEM_CODE  // Used to bound histogram.
   };
 
   // Use the following static limits to block DOS attacks until we implement
   // a cached dictionary evicition strategy.
   static const size_t kMaxDictionarySize;
   static const size_t kMaxDictionaryCount;
 
   // There is one instance of |Dictionary| for each memory-cached SDCH
   // dictionary.
-  class NET_EXPORT_PRIVATE Dictionary : public base::RefCounted<Dictionary> {
+  class NET_EXPORT_PRIVATE Dictionary {
    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
     // 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);
     virtual ~Dictionary();
 
+    // Sdch filters can get our text to use in decoding compressed data.
+    const std::string& text() const { return text_; }
+
     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.
     static bool CanSet(const std::string& domain, const std::string& path,
                        const std::set<int>& ports, const GURL& dictionary_url);
 
-    // Security method to check if we can use a dictionary to decompress a
-    // target that arrived with a reference to this dictionary.
-    bool CanUse(const GURL& referring_url);
+    // Security method to check if a dictionary is appropriate to use
+    // with the given URL.  Does not check expiration (it's appropriate to
+    // use dictionaries that were expired while a request is outstanding).
+    SdchManager::ProblemCodes CanUse(const GURL& target_url);
 
     // Compare paths to see if they "match" for dictionary use.
     static bool PathMatch(const std::string& path,
                           const std::string& restriction);
 
     // Compare domains to see if the "match" for dictionary use.
     static bool DomainMatch(const GURL& url, const std::string& restriction);
 
+    // Is this dictionary expired?
+    bool Expired() const;
 
+   private:
     // The actual text of the dictionary.
     std::string text_;
 
     // 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.
     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);
   };
 
+  // Implementation type relevant for the private data members of
+  // DictionarySet and SdchManager.   This class should not be used

[Bence, 2014/11/12 21:46:26]

Two spaces should be enough between two sentences.

[Randy Smith (Not in Mondays), 2014/11/13 22:11:02]

Actually, Ryan's badgered me down to 1 :-}.  Not sure how that happened.  Done.

+  // outside of sdch_manager.*.
+  class DictionaryWrapper : public base::RefCounted<DictionaryWrapper> {
+   public:
+    typedef std::map<std::string, scoped_refptr<DictionaryWrapper> >
+        DictionaryMap;
+
+    explicit DictionaryWrapper(scoped_ptr<Dictionary> dictionary);
+    Dictionary* dictionary() { return dictionary_.get(); }
+
+   private:
+    friend class base::RefCounted<DictionaryWrapper>;
+    ~DictionaryWrapper();
+
+    scoped_ptr<SdchManager::Dictionary> dictionary_;
+
+    DISALLOW_COPY_AND_ASSIGN(DictionaryWrapper);
+  };
+
+  // A handle for one or more dictionaries which will keep the dictionaries
+  // alive and accessible for the handle's lifetime.
+  class DictionarySet {
+   public:
+    ~DictionarySet();
+
+    // Append a comma separated list of client hashes onto the end
+    // of |client_hashes|.
+    void GetDictionaryClientHashList(std::string* client_hashes) const;
+
+    // Lookup a given dictionary based on server hash.  Returned pointer
+    // is guaranteed to be valid for the lifetime of the DictionarySet.
+    // Returns NULL if hash is not a valid server hash for a dictionary
+    // named by DictionarySet.
+    const SdchManager::Dictionary* Dictionary(const std::string& hash) const;
+
+    bool Empty() const;
+
+   private:
+    // A DictionarySet may only be constructed by the SdchManager.
+    friend class SdchManager;
+
+    static const char* kSdchDictionariesHandleDataKey;
+
+    DictionarySet();
+    void AddDictionary(const std::string& server_hash,
+                       scoped_refptr<DictionaryWrapper> dictionary);
+
+    DictionaryWrapper::DictionaryMap dictionaries_;
+
+    DISALLOW_COPY_AND_ASSIGN(DictionarySet);
+  };
+
   SdchManager();
   ~SdchManager();
 
   // Clear data (for browser data removal).
   void ClearData();
 
   // Record stats on various errors.
   static void SdchErrorRecovery(ProblemCodes problem);
 
   // Enables or disables SDCH compression.
@@ skipping 35 matching lines @@
   // 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);
 
   // Send out appropriate events notifying observers that a Get-Dictionary
   // header has been seen.
   void OnGetDictionary(const GURL& request_url, 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|.
-  // 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 a handle to the available dictionaries that might be used
+  // for encoding responses for the given URL.  The return set will not
+  // include expired dictionaries.  If no dictionaries
+  // are appropriate to use with the target_url, NULL is returned.
+  scoped_ptr<DictionarySet> GetDictionarySet(const GURL& target_url);
 
-  // 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);
+  // Get a handle to a specific dictionary, by its server hash, confirming
+  // that that specific dictionary is appropriate to use with |target_url|.
+  // Expired dictionaries will be returned.  If no dictionary with that
+  // hash exists that is usable with |target_url|, NULL is returned.
+  scoped_ptr<DictionarySet> GetDictionarySetByHash(
+      const GURL& target_url,
+      const std::string& server_hash);
 
   // 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);
 
   // 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.).
   void AddSdchDictionary(const std::string& dictionary_text,
                          const GURL& dictionary_url);
 
   // Registration for events generated by the SDCH subsystem.
   void AddObserver(SdchObserver* observer);
   void RemoveObserver(SdchObserver* observer);
 
+  static scoped_ptr<DictionarySet> CreateNullDictionarySetForTesting();
+
  private:
   struct BlacklistInfo {
     BlacklistInfo()
         : count(0),
           exponential_count(0),
-          reason(MIN_PROBLEM_CODE) {}
+          reason(OK) {}
 
     int count;                   // # of times to refuse SDCH advertisement.
     int exponential_count;       // Current exponential backoff ratchet.
     ProblemCodes reason;         // Why domain was blacklisted.
 
   };
+
   typedef std::map<std::string, BlacklistInfo> DomainBlacklistInfo;
   typedef std::set<std::string> ExperimentSet;
 
   // Determines whether a "Get-Dictionary" header is legal (dictionary
   // url has appropriate relationship to referrer url) in the SDCH
   // protocol.  Return true if fetch is legal.
   bool CanFetchDictionary(const GURL& referring_url,
                           const GURL& dictionary_url) const;
 
-  // A map of dictionaries info indexed by the hash that the server provides.
-  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_;
+
+  DictionaryWrapper::DictionaryMap dictionaries_;
 
   // List domains where decode failures have required disabling sdch.
   DomainBlacklistInfo blacklisted_domains_;
 
   // List of hostnames for which a latency experiment is allowed (because a
   // round trip test has recently passed).
   ExperimentSet allow_latency_experiment_;
 
   // Observers that want to be notified of SDCH events.
   // Assert list is empty on destruction since if there is an observer
   // that hasn't removed itself from the list, that observer probably
   // has a reference to the SdchManager.
   ObserverList<SdchObserver, true> observers_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(SdchManager);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_SDCH_MANAGER_H_