Update from https://crrev.com/311076

net/filter/sdch_filter_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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_clock.h"
 #include "net/base/io_buffer.h"
+#include "net/base/sdch_observer.h"
 #include "net/filter/mock_filter_context.h"
 #include "net/filter/sdch_filter.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_http_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/zlib/zlib.h"
 
 namespace net {
 
 //------------------------------------------------------------------------------
@@ skipping 36 matching lines @@
     URLRequestContext* url_request_context =
         filter_context_->GetModifiableURLRequestContext();
 
     url_request_context->set_sdch_manager(sdch_manager_.get());
   }
 
   // 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;
   }
 
   MockFilterContext* filter_context() { return filter_context_.get(); }
 
   // Sets both the GURL and the SDCH response for a filter context.
   void SetupFilterContextWithGURL(GURL url) {
     filter_context_->SetURL(url);
     filter_context_->SetSdchResponse(
         sdch_manager_->GetDictionarySet(url).Pass());
   }
@@ skipping 11 matching lines @@
   }
 
   const std::string test_vcdiff_dictionary_;
   const std::string vcdiff_compressed_data_;
   const std::string expanded_;  // Desired final, decompressed data.
 
   scoped_ptr<SdchManager> sdch_manager_;
   scoped_ptr<MockFilterContext> filter_context_;
 };
 
-//------------------------------------------------------------------------------
-
-
 TEST_F(SdchFilterTest, Hashing) {
   std::string client_hash, server_hash;
   std::string dictionary("test contents");
   SdchManager::GenerateHash(dictionary, &client_hash, &server_hash);
 
   EXPECT_EQ(client_hash, "lMQBjS3P");
   EXPECT_EQ(server_hash, "MyciMVll");
 }
 
-
 //------------------------------------------------------------------------------
 // Provide a generic helper function for trying to filter data.
 // This function repeatedly calls the filter to process data, until the entire
 // source is consumed. The return value from the filter is appended to output.
 // This allows us to vary input and output block sizes in order to test for edge
 // effects (boundary effects?) during the filtering process.
 // This function provides data to the filter in blocks of no-more-than the
 // specified input_block_length. It allows the filter to fill no more than
 // output_buffer_length in any one call to proccess (a.k.a., Read) data, and
 // concatenates all these little output blocks into the singular output string.
@@ skipping 21 matching lines @@
     output->append(output_buffer.get(), buffer_length);
     if (status == Filter::FILTER_ERROR)
       return false;
     // Callers assume that FILTER_OK with no output buffer means FILTER_DONE.
     if (Filter::FILTER_OK == status && 0 == buffer_length)
       return true;
     if (copy_amount == 0 && buffer_length == 0)
       return true;
   } while (1);
 }
-//------------------------------------------------------------------------------
+
 static std::string NewSdchDictionary(const std::string& domain) {
   std::string dictionary;
   if (!domain.empty()) {
     dictionary.append("Domain: ");
     dictionary.append(domain);
     dictionary.append("\n");
   }
   dictionary.append("\n");
   dictionary.append(kTestVcdiffDictionary, sizeof(kTestVcdiffDictionary) - 1);
   return dictionary;
 }
 
 static std::string NewSdchExpiredDictionary(const std::string& domain) {
   std::string dictionary;
   if (!domain.empty()) {
     dictionary.append("Domain: ");
     dictionary.append(domain);
     dictionary.append("\n");
   }
   dictionary.append("Max-Age: 0\n");
   dictionary.append("\n");
   dictionary.append(kTestVcdiffDictionary, sizeof(kTestVcdiffDictionary) - 1);
   return dictionary;
 }
 
-//------------------------------------------------------------------------------
-
 TEST_F(SdchFilterTest, EmptyInputOk) {
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
   char output_buffer[20];
   std::string url_string("http://ignore.com");
   filter_context()->SetURL(GURL(url_string));
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
   // With no input data, try to read output.
   int output_bytes_or_buffer_size = sizeof(output_buffer);
@@ skipping 244 matching lines @@
 
   std::string url_string = "http://" + kSampleDomain;
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   // Check we can't add it twice.
   EXPECT_FALSE(AddSdchDictionary(dictionary, url));
 
   const std::string kSampleDomain2 = "sdchtest2.com";
 
-  // Don't test adding a second dictionary if our limits are tight.
-  if (SdchManager::kMaxDictionaryCount > 1) {
-    // Construct a second SDCH dictionary from a VCDIFF dictionary.
-    std::string dictionary2(NewSdchDictionary(kSampleDomain2));
+  // Construct a second SDCH dictionary from a VCDIFF dictionary.
+  std::string dictionary2(NewSdchDictionary(kSampleDomain2));
 
-    std::string url_string2 = "http://" + kSampleDomain2;
-    GURL url2(url_string2);
-    EXPECT_TRUE(AddSdchDictionary(dictionary2, url2));
-  }
+  std::string url_string2 = "http://" + kSampleDomain2;
+  GURL url2(url_string2);
+  EXPECT_TRUE(AddSdchDictionary(dictionary2, url2));
 }
 
 TEST_F(SdchFilterTest, BasicDictionary) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
@@ skipping 216 matching lines @@
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
   EXPECT_EQ(SDCH_OK, sdch_manager_->IsInSupportedDomain(GURL(url_string)));
   EXPECT_EQ(SDCH_DOMAIN_BLACKLIST_INCLUDES_TARGET,
             sdch_manager_->IsInSupportedDomain(wrong_domain_url));
   sdch_manager_->ClearBlacklistings();
   EXPECT_EQ(SDCH_OK, sdch_manager_->IsInSupportedDomain(wrong_domain_url));
 }
 
 TEST_F(SdchFilterTest, DictionaryPathValidation) {
-  // Can't test path distinction between dictionaries if we aren't allowed
-  // more than one dictionary.
-  if (SdchManager::kMaxDictionaryCount <= 1)
-    return;
-
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   // Create a dictionary with a path restriction, by prefixing dictionary.
@@ skipping 31 matching lines @@
                               output_block_size, filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
   EXPECT_EQ(SDCH_DOMAIN_BLACKLIST_INCLUDES_TARGET,
             sdch_manager_->IsInSupportedDomain(GURL(url_string)));
   sdch_manager_->ClearBlacklistings();
   EXPECT_EQ(SDCH_OK, sdch_manager_->IsInSupportedDomain(GURL(url_string)));
 }
 
 TEST_F(SdchFilterTest, DictionaryPortValidation) {
-  // Can't test port distinction between dictionaries if we aren't allowed
-  // more than one dictionary.
-  if (SdchManager::kMaxDictionaryCount <= 1)
-    return;
-
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   // Create a dictionary with a port restriction, by prefixing old dictionary.
@@ skipping 41 matching lines @@
   EXPECT_FALSE(FilterTestData(compressed_for_port, feed_block_size,
                               output_block_size, filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
   EXPECT_EQ(SDCH_DOMAIN_BLACKLIST_INCLUDES_TARGET,
             sdch_manager_->IsInSupportedDomain(GURL(url_string)));
   sdch_manager_->ClearBlacklistings();
   EXPECT_EQ(SDCH_OK, sdch_manager_->IsInSupportedDomain(GURL(url_string)));
 }
 
-//------------------------------------------------------------------------------
 // Helper function to perform gzip compression of data.
-
 static std::string gzip_compress(const std::string &input) {
   z_stream zlib_stream;
   memset(&zlib_stream, 0, sizeof(zlib_stream));
   int code;
 
   // Initialize zlib
   code = deflateInit2(&zlib_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
                       -MAX_WBITS,
                       8,  // DEF_MEM_LEVEL
                       Z_DEFAULT_STRATEGY);
@@ skipping 156 matching lines @@
 
   filter_context()->SetMimeType("anything/mime");
   SetupFilterContextWithGURL(url);
 
   Filter::FixupEncodingTypes(*filter_context(), &filter_types);
   ASSERT_EQ(filter_types.size(), 2u);
   EXPECT_EQ(filter_types[0], Filter::FILTER_TYPE_SDCH);
   EXPECT_EQ(filter_types[1], Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
 
   // First try with a large buffer (larger than test input, or compressed data).
-    scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
   // Verify that chained filter is waiting for data.
   char tiny_output_buffer[10];
   int tiny_output_size = sizeof(tiny_output_buffer);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA,
             filter->ReadData(tiny_output_buffer, &tiny_output_size));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
@@ skipping 200 matching lines @@
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
 
   // Setup another dictionary, expired. Don't add it to the filter context.
   // Delete stored dictionaries first to handle platforms which only
   // have room for a single dictionary.
   sdch_manager_->ClearData();
   std::string expired_dictionary(NewSdchExpiredDictionary(kSampleDomain));
 
   // Don't use the Helper function since its insertion check is indeterminate
   // for a Max-Age: 0 dictionary.
-  sdch_manager_->AddSdchDictionary(expired_dictionary, url);
+  sdch_manager_->AddSdchDictionary(expired_dictionary, url, nullptr);
 
   std::string client_hash;
   std::string server_hash;
   SdchManager::GenerateHash(expired_dictionary, &client_hash, &server_hash);
 
   // Make sure Max-Age: 0 shows up as expired.
   scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
   clock->SetNow(base::Time::Now());
   clock->Advance(base::TimeDelta::FromMinutes(5));
   SdchProblemCode problem_code;
   scoped_ptr<SdchManager::DictionarySet> hash_set(
       sdch_manager_->GetDictionarySetByHash(
           url, server_hash, &problem_code).Pass());
   ASSERT_TRUE(hash_set);
   ASSERT_EQ(SDCH_OK, problem_code);
 
   const_cast<SdchManager::Dictionary*>(
       hash_set->GetDictionary(server_hash))->SetClockForTesting(
       clock.Pass());
 
   // Encode output with the second dictionary.
   std::string sdch_compressed(NewSdchCompressedData(expired_dictionary));
 
   // See if the filter decodes it.
   std::string output;
   EXPECT_TRUE(FilterTestData(sdch_compressed, 100, 100, filter.get(), &output));
   EXPECT_EQ(expanded_, output);
 }
 
+class SimpleSdchObserver : public SdchObserver {
+ public:
+  explicit SimpleSdchObserver(SdchManager* manager)
+      : dictionary_used_(0), manager_(manager) {
+    manager_->AddObserver(this);
+  }
+  ~SimpleSdchObserver() override { manager_->RemoveObserver(this); }
+
+  // SdchObserver
+  void OnDictionaryUsed(SdchManager* manager,
+                        const std::string& server_hash) override {
+    dictionary_used_++;
+    last_server_hash_ = server_hash;
+  }
+
+  int dictionary_used_calls() const { return dictionary_used_; }
+  std::string last_server_hash() const { return last_server_hash_; }
+
+  void OnGetDictionary(SdchManager* /* manager */,
+                       const GURL& /* request_url */,
+                       const GURL& /* dictionary_url */) override {}
+  void OnClearDictionaries(SdchManager* /* manager */) override {}
+
+ private:
+  int dictionary_used_;
+  std::string last_server_hash_;
+  SdchManager* manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(SimpleSdchObserver);
+};
+
+TEST_F(SdchFilterTest, DictionaryUsedSignaled) {
+  // Construct a valid SDCH dictionary from a VCDIFF dictionary.
+  const std::string kSampleDomain = "sdchtest.com";
+  std::string dictionary(NewSdchDictionary(kSampleDomain));
+  SimpleSdchObserver observer(sdch_manager_.get());
+
+  std::string url_string = "http://" + kSampleDomain;
+
+  GURL url(url_string);
+  EXPECT_TRUE(AddSdchDictionary(dictionary, url));
+
+  std::string client_hash;
+  std::string server_hash;
+  SdchManager::GenerateHash(dictionary, &client_hash, &server_hash);
+
+  std::string compressed(NewSdchCompressedData(dictionary));
+
+  std::vector<Filter::FilterType> filter_types;
+  filter_types.push_back(Filter::FILTER_TYPE_SDCH);
+
+  SetupFilterContextWithGURL(url);
+
+  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+
+  size_t feed_block_size = 100;
+  size_t output_block_size = 100;
+  std::string output;
+  EXPECT_TRUE(FilterTestData(compressed, feed_block_size, output_block_size,
+                             filter.get(), &output));
+  EXPECT_EQ(output, expanded_);
+
+  filter.reset(nullptr);
+
+  // Confirm that we got a "DictionaryUsed" signal from the SdchManager
+  // for our dictionary.
+  EXPECT_EQ(1, observer.dictionary_used_calls());
+  EXPECT_EQ(server_hash, observer.last_server_hash());
+}
+
 }  // namespace net