net: Add namespace net to Sdch* classes.

net/base/sdch_filter_unittest.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// 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.
 
 #include <limits.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #if defined(USE_SYSTEM_ZLIB)
@@ skipping 39 matching lines @@
 //------------------------------------------------------------------------------
 
 class SdchFilterTest : public testing::Test {
  protected:
   SdchFilterTest()
     : test_vcdiff_dictionary_(kTestVcdiffDictionary,
                               sizeof(kTestVcdiffDictionary) - 1),
       vcdiff_compressed_data_(kSdchCompressedTestData,
                               sizeof(kSdchCompressedTestData) - 1),
       expanded_(kTestData, sizeof(kTestData) - 1),
-      sdch_manager_(new SdchManager) {
+      sdch_manager_(new net::SdchManager) {
     sdch_manager_->EnableSdchSupport("");
   }
 
   std::string NewSdchCompressedData(const std::string dictionary);
 
   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_;  // A singleton database.
+  scoped_ptr<net::SdchManager> sdch_manager_;  // A singleton database.
 };
 
 std::string SdchFilterTest::NewSdchCompressedData(
     const std::string dictionary) {
   std::string client_hash;
   std::string server_hash;
-  SdchManager::GenerateHash(dictionary, &client_hash, &server_hash);
+  net::SdchManager::GenerateHash(dictionary, &client_hash, &server_hash);
 
   // Build compressed data that refers to our dictionary.
   std::string compressed(server_hash);
   compressed.append("\0", 1);
   compressed.append(vcdiff_compressed_data_);
   return compressed;
 }
 
 //------------------------------------------------------------------------------
 
 
 TEST_F(SdchFilterTest, Hashing) {
   std::string client_hash, server_hash;
   std::string dictionary("test contents");
-  SdchManager::GenerateHash(dictionary, &client_hash, &server_hash);
+  net::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.
@@ skipping 277 matching lines @@
          dictionary_hash_postfix.size());
   filter->FlushStreamBuffer(dictionary_hash_postfix.size());
 
   // With a non-existant dictionary specifier, try to read output.
   output_bytes_or_buffer_size = sizeof(output_buffer);
   status = filter->ReadData(output_buffer, &output_bytes_or_buffer_size);
 
   EXPECT_EQ(0, output_bytes_or_buffer_size);
   EXPECT_EQ(Filter::FILTER_ERROR, status);
 
-  EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
-  SdchManager::ClearBlacklistings();
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
+  EXPECT_FALSE(
+      net::SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
+  net::SdchManager::ClearBlacklistings();
+  EXPECT_TRUE(
+      net::SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
 }
 
 TEST_F(SdchFilterTest, DictionaryAddOnce) {
   // 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(sdch_manager_->AddSdchDictionary(dictionary, url));
@@ skipping 233 matching lines @@
   GURL url(url_string);
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
   const int kInputBufferSize(100);
 
   // Decode with content arriving from the "wrong" domain.
-  // This tests SdchManager::CanSet().
+  // This tests net::SdchManager::CanSet().
   net::MockFilterContext filter_context(kInputBufferSize);
   GURL wrong_domain_url("http://www.wrongdomain.com");
   filter_context.SetURL(wrong_domain_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_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                               filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
-  EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(wrong_domain_url));
-  SdchManager::ClearBlacklistings();
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(wrong_domain_url));
+  EXPECT_TRUE(
+      net::SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
+  EXPECT_FALSE(
+      net::SdchManager::Global()->IsInSupportedDomain(wrong_domain_url));
+  net::SdchManager::ClearBlacklistings();
+  EXPECT_TRUE(
+      net::SdchManager::Global()->IsInSupportedDomain(wrong_domain_url));
 }
 
 TEST_F(SdchFilterTest, DictionaryPathValidation) {
   // 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 28 matching lines @@
   filter_context.SetURL(GURL(url_string));
   filter.reset((Filter::Factory(filter_types, filter_context)));
 
   feed_block_size = 100;
   output_block_size = 100;
   output.clear();
   EXPECT_FALSE(FilterTestData(compressed_for_path, feed_block_size,
                               output_block_size, filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
-  EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
-  SdchManager::ClearBlacklistings();
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
+  EXPECT_FALSE(
+      net::SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
+  net::SdchManager::ClearBlacklistings();
+  EXPECT_TRUE(
+      net::SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
 }
 
 TEST_F(SdchFilterTest, DictionaryPortValidation) {
   // 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 41 matching lines @@
   filter_context.SetURL(GURL(url_string + ":" + port + "1"));
   filter.reset((Filter::Factory(filter_types, filter_context)));
 
   feed_block_size = 100;
   output_block_size = 100;
   output.clear();
   EXPECT_FALSE(FilterTestData(compressed_for_port, feed_block_size,
                               output_block_size, filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
-  EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
-  SdchManager::ClearBlacklistings();
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
+  EXPECT_FALSE(
+      net::SdchManager::Global()->IsInSupportedDomain(GURL(url_string)));
+  net::SdchManager::ClearBlacklistings();
+  EXPECT_TRUE(
+      net::SdchManager::Global()->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;
 
@@ skipping 361 matching lines @@
   output.clear();
   EXPECT_TRUE(FilterTestData(double_gzip_compressed_sdch, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 }
 
 TEST_F(SdchFilterTest, DomainSupported) {
   GURL test_url("http://www.test.com");
   GURL google_url("http://www.google.com");
 
-  EXPECT_TRUE(SdchManager::sdch_enabled());
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(test_url));
+  EXPECT_TRUE(net::SdchManager::sdch_enabled());
+  EXPECT_TRUE(net::SdchManager::Global()->IsInSupportedDomain(test_url));
   sdch_manager_->EnableSdchSupport(".google.com");
-  EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(test_url));
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(google_url));
+  EXPECT_FALSE(net::SdchManager::Global()->IsInSupportedDomain(test_url));
+  EXPECT_TRUE(net::SdchManager::Global()->IsInSupportedDomain(google_url));
 }
 
 TEST_F(SdchFilterTest, DomainBlacklisting) {
   GURL test_url("http://www.test.com");
   GURL google_url("http://www.google.com");
 
-  SdchManager::BlacklistDomain(test_url);
-  EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(test_url));
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(google_url));
+  net::SdchManager::BlacklistDomain(test_url);
+  EXPECT_FALSE(net::SdchManager::Global()->IsInSupportedDomain(test_url));
+  EXPECT_TRUE(net::SdchManager::Global()->IsInSupportedDomain(google_url));
 
-  SdchManager::BlacklistDomain(google_url);
-  EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(google_url));
+  net::SdchManager::BlacklistDomain(google_url);
+  EXPECT_FALSE(net::SdchManager::Global()->IsInSupportedDomain(google_url));
 }
 
 TEST_F(SdchFilterTest, DomainBlacklistingCaseSensitivity) {
   GURL test_url("http://www.TesT.com");
   GURL test2_url("http://www.tEst.com");
 
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(test_url));
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(test2_url));
-  SdchManager::BlacklistDomain(test_url);
-  EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(test2_url));
+  EXPECT_TRUE(net::SdchManager::Global()->IsInSupportedDomain(test_url));
+  EXPECT_TRUE(net::SdchManager::Global()->IsInSupportedDomain(test2_url));
+  net::SdchManager::BlacklistDomain(test_url);
+  EXPECT_FALSE(net::SdchManager::Global()->IsInSupportedDomain(test2_url));
 }
 
 TEST_F(SdchFilterTest, BlacklistingReset) {
   GURL gurl("http://mytest.DoMain.com");
   std::string domain(gurl.host());
 
-  SdchManager::ClearBlacklistings();
-  EXPECT_EQ(SdchManager::BlackListDomainCount(domain), 0);
-  EXPECT_EQ(SdchManager::BlacklistDomainExponential(domain), 0);
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(gurl));
+  net::SdchManager::ClearBlacklistings();
+  EXPECT_EQ(net::SdchManager::BlackListDomainCount(domain), 0);
+  EXPECT_EQ(net::SdchManager::BlacklistDomainExponential(domain), 0);
+  EXPECT_TRUE(net::SdchManager::Global()->IsInSupportedDomain(gurl));
 }
 
 TEST_F(SdchFilterTest, BlacklistingSingleBlacklist) {
   GURL gurl("http://mytest.DoMain.com");
   std::string domain(gurl.host());
-  SdchManager::ClearBlacklistings();
+  net::SdchManager::ClearBlacklistings();
 
-  SdchManager::Global()->BlacklistDomain(gurl);
-  EXPECT_EQ(SdchManager::BlackListDomainCount(domain), 1);
-  EXPECT_EQ(SdchManager::BlacklistDomainExponential(domain), 1);
+  net::SdchManager::Global()->BlacklistDomain(gurl);
+  EXPECT_EQ(net::SdchManager::BlackListDomainCount(domain), 1);
+  EXPECT_EQ(net::SdchManager::BlacklistDomainExponential(domain), 1);
 
   // Check that any domain lookup reduces the blacklist counter.
-  EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(gurl));
-  EXPECT_EQ(SdchManager::BlackListDomainCount(domain), 0);
-  EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(gurl));
+  EXPECT_FALSE(net::SdchManager::Global()->IsInSupportedDomain(gurl));
+  EXPECT_EQ(net::SdchManager::BlackListDomainCount(domain), 0);
+  EXPECT_TRUE(net::SdchManager::Global()->IsInSupportedDomain(gurl));
 }
 
 TEST_F(SdchFilterTest, BlacklistingExponential) {
   GURL gurl("http://mytest.DoMain.com");
   std::string domain(gurl.host());
-  SdchManager::ClearBlacklistings();
+  net::SdchManager::ClearBlacklistings();
 
   int exponential = 1;
   for (int i = 1; i < 100; ++i) {
-    SdchManager::Global()->BlacklistDomain(gurl);
-    EXPECT_EQ(SdchManager::BlacklistDomainExponential(domain), exponential);
+    net::SdchManager::Global()->BlacklistDomain(gurl);
+    EXPECT_EQ(
+        net::SdchManager::BlacklistDomainExponential(domain), exponential);
 
-    EXPECT_EQ(SdchManager::BlackListDomainCount(domain), exponential);
-    EXPECT_FALSE(SdchManager::Global()->IsInSupportedDomain(gurl));
-    EXPECT_EQ(SdchManager::BlackListDomainCount(domain), exponential - 1);
+    EXPECT_EQ(net::SdchManager::BlackListDomainCount(domain), exponential);
+    EXPECT_FALSE(net::SdchManager::Global()->IsInSupportedDomain(gurl));
+    EXPECT_EQ(net::SdchManager::BlackListDomainCount(domain), exponential - 1);
 
     // Simulate a large number of domain checks (which eventually remove the
     // blacklisting).
-    SdchManager::ClearDomainBlacklisting(domain);
-    EXPECT_EQ(SdchManager::BlackListDomainCount(domain), 0);
-    EXPECT_TRUE(SdchManager::Global()->IsInSupportedDomain(gurl));
+    net::SdchManager::ClearDomainBlacklisting(domain);
+    EXPECT_EQ(net::SdchManager::BlackListDomainCount(domain), 0);
+    EXPECT_TRUE(net::SdchManager::Global()->IsInSupportedDomain(gurl));
 
     // Predict what exponential backoff will be.
     exponential = 1 + 2 * exponential;
     if (exponential < 0)
       exponential = INT_MAX;  // We don't wrap.
   }
 }
 
 TEST_F(SdchFilterTest, CanSetExactMatchDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
@@ skipping 55 matching lines @@
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary_text,
               GURL("http://" + dictionary_domain)));
 }
 
 // Make sure the DOS protection precludes the addition of too many dictionaries.
 TEST_F(SdchFilterTest, TooManyDictionaries) {
   std::string dictionary_domain(".google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   size_t count = 0;
-  while (count <= SdchManager::kMaxDictionaryCount + 1) {
+  while (count <= net::SdchManager::kMaxDictionaryCount + 1) {
     if (!sdch_manager_->AddSdchDictionary(dictionary_text,
                                           GURL("http://www.google.com")))
       break;
 
     dictionary_text += " ";  // Create dictionary with different SHA signature.
     ++count;
   }
-  EXPECT_EQ(SdchManager::kMaxDictionaryCount, count);
+  EXPECT_EQ(net::SdchManager::kMaxDictionaryCount, count);
 }
 
 TEST_F(SdchFilterTest, DictionaryNotTooLarge) {
   std::string dictionary_domain(".google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   dictionary_text.append(
-      SdchManager::kMaxDictionarySize  - dictionary_text.size(), ' ');
+      net::SdchManager::kMaxDictionarySize  - dictionary_text.size(), ' ');
   EXPECT_TRUE(sdch_manager_->AddSdchDictionary(dictionary_text,
               GURL("http://" + dictionary_domain)));
 }
 
 TEST_F(SdchFilterTest, DictionaryTooLarge) {
   std::string dictionary_domain(".google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   dictionary_text.append(
-      SdchManager::kMaxDictionarySize + 1 - dictionary_text.size(), ' ');
+      net::SdchManager::kMaxDictionarySize + 1 - dictionary_text.size(), ' ');
   EXPECT_FALSE(sdch_manager_->AddSdchDictionary(dictionary_text,
               GURL("http://" + dictionary_domain)));
 }
 
 TEST_F(SdchFilterTest, PathMatch) {
   bool (*PathMatch)(const std::string& path, const std::string& restriction) =
-      SdchManager::Dictionary::PathMatch;
+      net::SdchManager::Dictionary::PathMatch;

[tfarina, 2011/01/31 02:23:00]

Guys, any glue how to fix this?

See trybot errors, here is the mac output:
http://build.chromium.org/p/tryserver.chromium/builders/mac/builds/10880/step...

   // 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.
 
   // Rely on the slash in the path (not at the end of the restriction).
   EXPECT_TRUE(PathMatch("/search/something", "/search"));
   EXPECT_TRUE(PathMatch("/search/s", "/search"));
@@ skipping 45 matching lines @@
 
   // And can reset them to false.
   sdch_manager_->SetAllowLatencyExperiment(url, false);
   EXPECT_FALSE(sdch_manager_->AllowLatencyExperiment(url));
   EXPECT_TRUE(sdch_manager_->AllowLatencyExperiment(url2));
 
   sdch_manager_->SetAllowLatencyExperiment(url2, false);
   EXPECT_FALSE(sdch_manager_->AllowLatencyExperiment(url));
   EXPECT_FALSE(sdch_manager_->AllowLatencyExperiment(url2));
 }