Update from https://crrev.com/311076

net/base/sdch_manager_unittest.cc

 // Copyright 2014 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.
 
 #include <limits.h>
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 13 matching lines @@
 //------------------------------------------------------------------------------
 // Provide sample data and compression results with a sample VCDIFF dictionary.
 // Note an SDCH dictionary has extra meta-data before the VCDIFF dictionary.
 static const char kTestVcdiffDictionary[] = "DictionaryFor"
     "SdchCompression1SdchCompression2SdchCompression3SdchCompression\n";
 
 //------------------------------------------------------------------------------
 
 class MockSdchObserver : public SdchObserver {
  public:
-  MockSdchObserver() : get_dictionary_notifications_(0) {}
+  MockSdchObserver()
+      : dictionary_used_notifications_(0),
+        get_dictionary_notifications_(0),
+        clear_dictionaries_notifications_(0) {}
 
-  const GURL& last_dictionary_request_url() {
+  std::string last_server_hash() const { return last_server_hash_; }
+  int dictionary_used_notifications() const {
+    return dictionary_used_notifications_;
+  }
+  const GURL& last_dictionary_request_url() const {
     return last_dictionary_request_url_;
   }
-  const GURL& last_dictionary_url() { return last_dictionary_url_; }
-  int get_dictionary_notifications() { return get_dictionary_notifications_; }
+  const GURL& last_dictionary_url() const { return last_dictionary_url_; }
+  int get_dictionary_notifications() const {
+    return get_dictionary_notifications_;
+  }
+
+  int clear_dictionary_notifications() const {
+    return clear_dictionaries_notifications_;
+  }
 
   // SdchObserver implementation
+  void OnDictionaryUsed(SdchManager* manager,
+                        const std::string& server_hash) override {
+    last_server_hash_ = server_hash;
+    ++dictionary_used_notifications_;
+  }
+
   void OnGetDictionary(SdchManager* manager,
                        const GURL& request_url,
                        const GURL& dictionary_url) override {
     ++get_dictionary_notifications_;
     last_dictionary_request_url_ = request_url;
     last_dictionary_url_ = dictionary_url;
   }
-  void OnClearDictionaries(SdchManager* manager) override {}
+  void OnClearDictionaries(SdchManager* manager) override {
+    ++clear_dictionaries_notifications_;
+  }
 
  private:
+  int dictionary_used_notifications_;
   int get_dictionary_notifications_;
+  int clear_dictionaries_notifications_;
+
+  std::string last_server_hash_;
   GURL last_dictionary_request_url_;
   GURL last_dictionary_url_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockSdchObserver);
 };
 
 class SdchManagerTest : public testing::Test {
  protected:
   SdchManagerTest()
       : sdch_manager_(new SdchManager),
         default_support_(false),
         default_https_support_(false) {
     default_support_ = sdch_manager_->sdch_enabled();
     default_https_support_ = sdch_manager_->secure_scheme_supported();
   }
 
   ~SdchManagerTest() override {}
 
   SdchManager* sdch_manager() { return sdch_manager_.get(); }
 
   // Reset globals back to default state.
   void TearDown() override {
     SdchManager::EnableSdchSupport(default_support_);
     SdchManager::EnableSecureSchemeSupport(default_https_support_);
   }
 
   // Attempt to add a dictionary to the manager and probe for success or
   // failure.
   bool AddSdchDictionary(const std::string& dictionary_text,
                          const GURL& gurl) {
-    return sdch_manager_->AddSdchDictionary(dictionary_text, gurl) == SDCH_OK;
+    return sdch_manager_->AddSdchDictionary(dictionary_text, gurl, nullptr) ==
+           SDCH_OK;
   }
 
  private:
   scoped_ptr<SdchManager> sdch_manager_;
   bool default_support_;
   bool default_https_support_;
 };
 
 static std::string NewSdchDictionary(const std::string& domain) {
   std::string dictionary;
@@ skipping 294 matching lines @@
 // See test CanSetExactMatchDictionary above for first try.
 TEST_F(SdchManagerTest, CanStillSetExactMatchDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Perfect match should *STILL* work.
   EXPECT_TRUE(AddSdchDictionary(dictionary_text,
                                 GURL("http://" + dictionary_domain)));
 }
 
-// Make sure the DOS protection precludes the addition of too many dictionaries.
-TEST_F(SdchManagerTest, TooManyDictionaries) {
-  std::string dictionary_domain(".google.com");
-  std::string dictionary_text(NewSdchDictionary(dictionary_domain));
-
-  for (size_t count = 0; count < SdchManager::kMaxDictionaryCount; ++count) {
-    EXPECT_TRUE(AddSdchDictionary(dictionary_text,
-                                  GURL("http://www.google.com")));
-    dictionary_text += " ";  // Create dictionary with different SHA signature.
-  }
-  EXPECT_FALSE(
-      AddSdchDictionary(dictionary_text, GURL("http://www.google.com")));
-}
-
-TEST_F(SdchManagerTest, DictionaryNotTooLarge) {
-  std::string dictionary_domain(".google.com");
-  std::string dictionary_text(NewSdchDictionary(dictionary_domain));
-
-  dictionary_text.append(
-      SdchManager::kMaxDictionarySize  - dictionary_text.size(), ' ');
-  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
-                                GURL("http://" + dictionary_domain)));
-}
-
-TEST_F(SdchManagerTest, DictionaryTooLarge) {
-  std::string dictionary_domain(".google.com");
-  std::string dictionary_text(NewSdchDictionary(dictionary_domain));
-
-  dictionary_text.append(
-      SdchManager::kMaxDictionarySize + 1 - dictionary_text.size(), ' ');
-  EXPECT_FALSE(AddSdchDictionary(dictionary_text,
-                                 GURL("http://" + dictionary_domain)));
-}
-
 TEST_F(SdchManagerTest, PathMatch) {
   bool (*PathMatch)(const std::string& path, const std::string& restriction) =
       SdchManager::Dictionary::PathMatch;
   // Perfect match is supported.
   EXPECT_TRUE(PathMatch("/search", "/search"));
   EXPECT_TRUE(PathMatch("/search/", "/search/"));
 
   // Prefix only works if last character of restriction is a slash, or first
   // character in path after a match is a slash. Validate each case separately.
 
@@ skipping 80 matching lines @@
 
   SdchProblemCode problem_code;
   dict_set = sdch_manager()->GetDictionarySetByHash(
       GURL("http://" + dictionary_domain_1 + "/random_url"),
       server_hash_1, &problem_code);
   EXPECT_TRUE(dict_set);
   EXPECT_TRUE(dict_set->GetDictionary(server_hash_1));
   EXPECT_EQ(SDCH_OK, problem_code);
 
   second_manager.AddSdchDictionary(
-      dictionary_text_2, GURL("http://" + dictionary_domain_2));
+      dictionary_text_2, GURL("http://" + dictionary_domain_2), nullptr);
   dict_set = second_manager.GetDictionarySetByHash(
       GURL("http://" + dictionary_domain_2 + "/random_url"),
       server_hash_2, &problem_code);
   EXPECT_TRUE(dict_set);
   EXPECT_TRUE(dict_set->GetDictionary(server_hash_2));
   EXPECT_EQ(SDCH_OK, problem_code);
 
   dict_set = sdch_manager()->GetDictionarySetByHash(
       GURL("http://" + dictionary_domain_2 + "/random_url"),
       server_hash_2, &problem_code);
@@ skipping 117 matching lines @@
 
 TEST_F(SdchManagerTest, SdchOnByDefault) {
   GURL google_url("http://www.google.com");
   scoped_ptr<SdchManager> sdch_manager(new SdchManager);
 
   EXPECT_EQ(SDCH_OK, sdch_manager->IsInSupportedDomain(google_url));
   SdchManager::EnableSdchSupport(false);
   EXPECT_EQ(SDCH_DISABLED, sdch_manager->IsInSupportedDomain(google_url));
 }
 
+// Confirm dispatch of notification.
+TEST_F(SdchManagerTest, SdchDictionaryUsed) {
+  MockSdchObserver observer;
+  sdch_manager()->AddObserver(&observer);
+
+  EXPECT_EQ(0, observer.dictionary_used_notifications());
+  sdch_manager()->OnDictionaryUsed("xyzzy");
+  EXPECT_EQ(1, observer.dictionary_used_notifications());
+  EXPECT_EQ("xyzzy", observer.last_server_hash());
+
+  std::string dictionary_domain("x.y.z.google.com");
+  GURL target_gurl("http://" + dictionary_domain);
+  std::string dictionary_text(NewSdchDictionary(dictionary_domain));
+  std::string client_hash;
+  std::string server_hash;
+  SdchManager::GenerateHash(dictionary_text, &client_hash, &server_hash);
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text, target_gurl));
+  EXPECT_EQ("xyzzy", observer.last_server_hash());
+  EXPECT_EQ(1, observer.dictionary_used_notifications());
+
+  EXPECT_TRUE(sdch_manager()->GetDictionarySet(target_gurl));
+  EXPECT_EQ("xyzzy", observer.last_server_hash());
+  EXPECT_EQ(1, observer.dictionary_used_notifications());
+
+  sdch_manager()->RemoveObserver(&observer);
+  EXPECT_EQ(1, observer.dictionary_used_notifications());
+  EXPECT_EQ("xyzzy", observer.last_server_hash());
+  sdch_manager()->OnDictionaryUsed("plugh");
+  EXPECT_EQ(1, observer.dictionary_used_notifications());
+  EXPECT_EQ("xyzzy", observer.last_server_hash());
+}
+
 #else
 
 TEST(SdchManagerTest, SdchOffByDefault) {
   GURL google_url("http://www.google.com");
   scoped_ptr<SdchManager> sdch_manager(new SdchManager);
 
   EXPECT_EQ(SDCH_DISABLED, sdch_manager->IsInSupportedDomain(google_url));
   SdchManager::EnableSdchSupport(true);
   EXPECT_EQ(SDCH_OK, sdch_manager->IsInSupportedDomain(google_url));
 }
 
 #endif  // !defined(OS_IOS)
 
 }  // namespace net