Update from https://crrev.com/311076

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.
 
 // This file contains the SdchManager class and two nested classes
 // (Dictionary, DictionarySet). SdchManager::Dictionary contains all
 // of the information about an SDCH dictionary. The manager is
 // responsible for storing those dictionaries, and provides access to
 // them through DictionarySet objects. A DictionarySet is an object
 // whose lifetime is under the control of the consumer. It is a
@@ skipping 41 matching lines @@
 // module) to decompress data.
 //
 // A dictionary held by the manager may nonetheless outlive the manager if
 // a DictionarySet object refers to it; see below.
 class NET_EXPORT SdchManager {
  public:
   class Dictionary;
   typedef std::map<std::string, scoped_refptr<base::RefCountedData<Dictionary>>>
       DictionaryMap;
 
-  // 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;
-
   class NET_EXPORT_PRIVATE Dictionary {
    public:
     // 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 std::string& server_hash,
                const GURL& url,
                const std::string& domain,
                const std::string& path,
                const base::Time& expiration,
                const std::set<int>& ports);
 
     ~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_; }
+    const std::string& server_hash() const { return server_hash_; }
     const std::string& domain() const { return domain_; }
     const std::string& path() const { return path_; }
     const base::Time& expiration() const { return expiration_; }
     const std::set<int>& ports() const { return ports_; }
 
     // 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 SdchProblemCode CanSet(const std::string& domain,
                                   const std::string& path,
                                   const std::set<int>& ports,
@@ skipping 23 matching lines @@
     // CopyConstructible
     Dictionary(const Dictionary& rhs);
 
     // 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_;
 
+    // Part of the hash of text_ that the server uses to identify the
+    // dictionary it wants used for decoding.
+    std::string server_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.
@@ skipping 85 matching lines @@
   // 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.
   SdchProblemCode IsInSupportedDomain(const GURL& url);
 
   // Send out appropriate events notifying observers that a Get-Dictionary
   // header has been seen.
   SdchProblemCode OnGetDictionary(const GURL& request_url,
                                   const GURL& dictionary_url);
 
+  // Send out appropriate events notifying observers that a dictionary
+  // was successfully used to decode a request.
+  void OnDictionaryUsed(const std::string& server_hash);
+
   // 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 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.
@@ skipping 17 matching lines @@
   bool AllowLatencyExperiment(const GURL& url) const;
 
   void SetAllowLatencyExperiment(const GURL& url, bool enable);
 
   base::Value* SdchInfoToValue() const;
 
   // 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.).
+  // If |server_hash| is non-null, returns the server hash that may be
+  // used as an argument to GetDictionarySetByHash.
   // Returns SDCH_OK if the addition was successfull, and corresponding error
   // code otherwise.
   SdchProblemCode AddSdchDictionary(const std::string& dictionary_text,
-                                    const GURL& dictionary_url);
+                                    const GURL& dictionary_url,
+                                    std::string* server_hash_p);
+
+  // Remove an SDCH dictionary
+  SdchProblemCode RemoveSdchDictionary(const std::string& server_hash);
 
   // Registration for events generated by the SDCH subsystem.
   void AddObserver(SdchObserver* observer);
   void RemoveObserver(SdchObserver* observer);
 
   static scoped_ptr<DictionarySet> CreateEmptyDictionarySetForTesting();
 
  private:
   struct BlacklistInfo {
     BlacklistInfo() : count(0), exponential_count(0), reason(SDCH_OK) {}
@@ skipping 39 matching lines @@
   ObserverList<SdchObserver, true> observers_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(SdchManager);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_SDCH_MANAGER_H_