git cl format the first third of the net/base directory

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"
 #include "net/base/sdch_manager.h"
 #include "net/base/sdch_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 //------------------------------------------------------------------------------
 // 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"
+static const char kTestVcdiffDictionary[] =
+    "DictionaryFor"
     "SdchCompression1SdchCompression2SdchCompression3SdchCompression\n";
 
 //------------------------------------------------------------------------------
 
 class MockSdchObserver : public SdchObserver {
  public:
   MockSdchObserver() : get_dictionary_notifications_(0) {}
 
   const GURL& last_dictionary_request_url() {
     return last_dictionary_request_url_;
@@ skipping 32 matching lines @@
   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) {
+  bool AddSdchDictionary(const std::string& dictionary_text, const GURL& gurl) {
     std::string list;
     sdch_manager_->GetAvailDictionaryList(gurl, &list);
     sdch_manager_->AddSdchDictionary(dictionary_text, gurl);
     std::string list2;
     sdch_manager_->GetAvailDictionaryList(gurl, &list2);
 
     // The list of hashes should change iff the addition succeeds.
     return (list != list2);
   }
 
@@ skipping 96 matching lines @@
     if (exponential < 0)
       exponential = INT_MAX;  // We don't wrap.
   }
 }
 
 TEST_F(SdchManagerTest, CanSetExactMatchDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Perfect match should work.
-  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
-                                GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(
+      AddSdchDictionary(dictionary_text, GURL("http://" + dictionary_domain)));
 }
 
 TEST_F(SdchManagerTest, CanAdvertiseDictionaryOverHTTP) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
-  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
-                                GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(
+      AddSdchDictionary(dictionary_text, GURL("http://" + dictionary_domain)));
 
   std::string dictionary_list;
   // HTTP target URL can advertise dictionary.
   sdch_manager()->GetAvailDictionaryList(
-      GURL("http://" + dictionary_domain + "/test"),
-      &dictionary_list);
+      GURL("http://" + dictionary_domain + "/test"), &dictionary_list);
   EXPECT_FALSE(dictionary_list.empty());
 }
 
 TEST_F(SdchManagerTest, CanNotAdvertiseDictionaryOverHTTPS) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
-  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
-                                GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(
+      AddSdchDictionary(dictionary_text, GURL("http://" + dictionary_domain)));
 
   std::string dictionary_list;
   // HTTPS target URL should NOT advertise dictionary.
   sdch_manager()->GetAvailDictionaryList(
-      GURL("https://" + dictionary_domain + "/test"),
-      &dictionary_list);
+      GURL("https://" + dictionary_domain + "/test"), &dictionary_list);
   EXPECT_TRUE(dictionary_list.empty());
 }
 
 TEST_F(SdchManagerTest, CanUseHTTPSDictionaryOverHTTPSIfEnabled) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   SdchManager::EnableSecureSchemeSupport(false);
-  EXPECT_FALSE(AddSdchDictionary(dictionary_text,
-                                 GURL("https://" + dictionary_domain)));
+  EXPECT_FALSE(
+      AddSdchDictionary(dictionary_text, GURL("https://" + dictionary_domain)));
   SdchManager::EnableSecureSchemeSupport(true);
-  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
-                                GURL("https://" + dictionary_domain)));
+  EXPECT_TRUE(
+      AddSdchDictionary(dictionary_text, GURL("https://" + dictionary_domain)));
 
   GURL target_url("https://" + dictionary_domain + "/test");
   std::string dictionary_list;
   // HTTPS target URL should advertise dictionary if secure scheme support is
   // enabled.
   sdch_manager()->GetAvailDictionaryList(target_url, &dictionary_list);
   EXPECT_FALSE(dictionary_list.empty());
 
   // Dictionary should be available.
   scoped_refptr<SdchManager::Dictionary> dictionary;
   std::string client_hash;
   std::string server_hash;
   sdch_manager()->GenerateHash(dictionary_text, &client_hash, &server_hash);
   sdch_manager()->GetVcdiffDictionary(server_hash, target_url, &dictionary);
   EXPECT_TRUE(dictionary.get() != NULL);
 }
 
 TEST_F(SdchManagerTest, CanNotUseHTTPDictionaryOverHTTPS) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
-  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
-                                GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(
+      AddSdchDictionary(dictionary_text, GURL("http://" + dictionary_domain)));
 
   GURL target_url("https://" + dictionary_domain + "/test");
   std::string dictionary_list;
   // HTTPS target URL should not advertise dictionary acquired over HTTP even if
   // secure scheme support is enabled.
   SdchManager::EnableSecureSchemeSupport(true);
   sdch_manager()->GetAvailDictionaryList(target_url, &dictionary_list);
   EXPECT_TRUE(dictionary_list.empty());
 
   scoped_refptr<SdchManager::Dictionary> dictionary;
   std::string client_hash;
   std::string server_hash;
   sdch_manager()->GenerateHash(dictionary_text, &client_hash, &server_hash);
   sdch_manager()->GetVcdiffDictionary(server_hash, target_url, &dictionary);
   EXPECT_TRUE(dictionary.get() == NULL);
 }
 
 TEST_F(SdchManagerTest, CanNotUseHTTPSDictionaryOverHTTP) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   SdchManager::EnableSecureSchemeSupport(true);
-  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
-                                GURL("https://" + dictionary_domain)));
+  EXPECT_TRUE(
+      AddSdchDictionary(dictionary_text, GURL("https://" + dictionary_domain)));
 
   GURL target_url("http://" + dictionary_domain + "/test");
   std::string dictionary_list;
   // HTTP target URL should not advertise dictionary acquired over HTTPS even if
   // secure scheme support is enabled.
   sdch_manager()->GetAvailDictionaryList(target_url, &dictionary_list);
   EXPECT_TRUE(dictionary_list.empty());
 
   scoped_refptr<SdchManager::Dictionary> dictionary;
   std::string client_hash;
   std::string server_hash;
   sdch_manager()->GenerateHash(dictionary_text, &client_hash, &server_hash);
   sdch_manager()->GetVcdiffDictionary(server_hash, target_url, &dictionary);
   EXPECT_TRUE(dictionary.get() == NULL);
 }
 
 TEST_F(SdchManagerTest, FailToSetDomainMismatchDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Fail the "domain match" requirement.
-  EXPECT_FALSE(AddSdchDictionary(dictionary_text,
-                                 GURL("http://y.z.google.com")));
+  EXPECT_FALSE(
+      AddSdchDictionary(dictionary_text, GURL("http://y.z.google.com")));
 }
 
 TEST_F(SdchManagerTest, FailToSetDotHostPrefixDomainDictionary) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Fail the HD with D being the domain and H having a dot requirement.
-  EXPECT_FALSE(AddSdchDictionary(dictionary_text,
-                                 GURL("http://w.x.y.z.google.com")));
+  EXPECT_FALSE(
+      AddSdchDictionary(dictionary_text, GURL("http://w.x.y.z.google.com")));
 }
 
 TEST_F(SdchManagerTest, FailToSetDotHostPrefixDomainDictionaryTrailingDot) {
   std::string dictionary_domain("x.y.z.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Fail the HD with D being the domain and H having a dot requirement.
-  EXPECT_FALSE(AddSdchDictionary(dictionary_text,
-                                 GURL("http://w.x.y.z.google.com.")));
+  EXPECT_FALSE(
+      AddSdchDictionary(dictionary_text, GURL("http://w.x.y.z.google.com.")));
 }
 
 TEST_F(SdchManagerTest, FailToSetRepeatPrefixWithDotDictionary) {
   // Make sure that a prefix that matches the domain postfix won't confuse
   // the validation checks.
   std::string dictionary_domain("www.google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Fail the HD with D being the domain and H having a dot requirement.
   EXPECT_FALSE(AddSdchDictionary(dictionary_text,
                                  GURL("http://www.google.com.www.google.com")));
 }
 
 TEST_F(SdchManagerTest, CanSetLeadingDotDomainDictionary) {
   // Make sure that a prefix that matches the domain postfix won't confuse
   // the validation checks.
   std::string dictionary_domain(".google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Verify that a leading dot in the domain is acceptable, as long as the host
   // name does not contain any dots preceding the matched domain name.
-  EXPECT_TRUE(AddSdchDictionary(dictionary_text, GURL("http://www.google.com")));
+  EXPECT_TRUE(
+      AddSdchDictionary(dictionary_text, GURL("http://www.google.com")));
 }
 
 TEST_F(SdchManagerTest,
        CanSetLeadingDotDomainDictionaryFromURLWithTrailingDot) {
   // Make sure that a prefix that matches the domain postfix won't confuse
   // the validation checks.
   std::string dictionary_domain(".google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Verify that a leading dot in the domain is acceptable, as long as the host
   // name does not contain any dots preceding the matched domain name.
-  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
-                                GURL("http://www.google.com.")));
+  EXPECT_TRUE(
+      AddSdchDictionary(dictionary_text, GURL("http://www.google.com.")));
 }
 
 TEST_F(SdchManagerTest, CannotSetLeadingDotDomainDictionary) {
   // Make sure that a prefix that matches the domain postfix won't confuse
   // the validation checks.
   std::string dictionary_domain(".google.com");
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
 
   // Verify that a leading dot in the domain does not affect the name containing
   // dots failure.
@@ skipping 12 matching lines @@
                                  GURL("http://www.subdomain.google.com.")));
 }
 
 // Make sure the order of the tests is not helping us or confusing things.
 // 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)));
+  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")));
+    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)));
+      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)));
+  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
@@ skipping 73 matching lines @@
 
   SdchManager::GenerateHash(dictionary_text_1, &tmp_hash, &server_hash_1);
   SdchManager::GenerateHash(dictionary_text_2, &tmp_hash, &server_hash_2);
 
   // Confirm that if you add directories to one manager, you
   // can't get them from the other.
   EXPECT_TRUE(AddSdchDictionary(dictionary_text_1,
                                 GURL("http://" + dictionary_domain_1)));
   scoped_refptr<SdchManager::Dictionary> dictionary;
   sdch_manager()->GetVcdiffDictionary(
-      server_hash_1,
-      GURL("http://" + dictionary_domain_1 + "/random_url"),
+      server_hash_1, GURL("http://" + dictionary_domain_1 + "/random_url"),
       &dictionary);
   EXPECT_TRUE(dictionary.get());
 
-  second_manager.AddSdchDictionary(
-      dictionary_text_2, GURL("http://" + dictionary_domain_2));
+  second_manager.AddSdchDictionary(dictionary_text_2,
+                                   GURL("http://" + dictionary_domain_2));
   second_manager.GetVcdiffDictionary(
-      server_hash_2,
-      GURL("http://" + dictionary_domain_2 + "/random_url"),
+      server_hash_2, GURL("http://" + dictionary_domain_2 + "/random_url"),
       &dictionary);
   EXPECT_TRUE(dictionary.get());
 
   sdch_manager()->GetVcdiffDictionary(
-      server_hash_2,
-      GURL("http://" + dictionary_domain_2 + "/random_url"),
+      server_hash_2, GURL("http://" + dictionary_domain_2 + "/random_url"),
       &dictionary);
   EXPECT_FALSE(dictionary.get());
 
   second_manager.GetVcdiffDictionary(
-      server_hash_1,
-      GURL("http://" + dictionary_domain_1 + "/random_url"),
+      server_hash_1, GURL("http://" + dictionary_domain_1 + "/random_url"),
       &dictionary);
   EXPECT_FALSE(dictionary.get());
 }
 
 TEST_F(SdchManagerTest, HttpsCorrectlySupported) {
   GURL url("http://www.google.com");
   GURL secure_url("https://www.google.com");
 
   bool expect_https_support = true;
 
@@ skipping 10 matching lines @@
 TEST_F(SdchManagerTest, ClearDictionaryData) {
   std::string dictionary_domain("x.y.z.google.com");
   GURL blacklist_url("http://bad.chromium.org");
 
   std::string dictionary_text(NewSdchDictionary(dictionary_domain));
   std::string tmp_hash;
   std::string server_hash;
 
   SdchManager::GenerateHash(dictionary_text, &tmp_hash, &server_hash);
 
-  EXPECT_TRUE(AddSdchDictionary(dictionary_text,
-                                GURL("http://" + dictionary_domain)));
+  EXPECT_TRUE(
+      AddSdchDictionary(dictionary_text, GURL("http://" + dictionary_domain)));
   scoped_refptr<SdchManager::Dictionary> dictionary;
   sdch_manager()->GetVcdiffDictionary(
-      server_hash,
-      GURL("http://" + dictionary_domain + "/random_url"),
+      server_hash, GURL("http://" + dictionary_domain + "/random_url"),
       &dictionary);
   EXPECT_TRUE(dictionary.get());
 
   sdch_manager()->BlacklistDomain(GURL(blacklist_url),
                                   SdchManager::MIN_PROBLEM_CODE);
   EXPECT_FALSE(sdch_manager()->IsInSupportedDomain(blacklist_url));
 
   sdch_manager()->ClearData();
 
   dictionary = NULL;
   sdch_manager()->GetVcdiffDictionary(
-      server_hash,
-      GURL("http://" + dictionary_domain + "/random_url"),
+      server_hash, GURL("http://" + dictionary_domain + "/random_url"),
       &dictionary);
   EXPECT_FALSE(dictionary.get());
   EXPECT_TRUE(sdch_manager()->IsInSupportedDomain(blacklist_url));
 }
 
 TEST_F(SdchManagerTest, GetDictionaryNotification) {
   GURL test_request_gurl(GURL("http://www.example.com/data"));
   GURL test_dictionary_gurl(GURL("http://www.example.com/dict"));
   MockSdchObserver observer;
   sdch_manager()->AddObserver(&observer);
 
   EXPECT_EQ(0, observer.get_dictionary_notifications());
   sdch_manager()->OnGetDictionary(test_request_gurl, test_dictionary_gurl);
   EXPECT_EQ(1, observer.get_dictionary_notifications());
   EXPECT_EQ(test_request_gurl, observer.last_dictionary_request_url());
   EXPECT_EQ(test_dictionary_gurl, observer.last_dictionary_url());
 
   sdch_manager()->RemoveObserver(&observer);
   sdch_manager()->OnGetDictionary(test_request_gurl, test_dictionary_gurl);
   EXPECT_EQ(1, observer.get_dictionary_notifications());
   EXPECT_EQ(test_request_gurl, observer.last_dictionary_request_url());
   EXPECT_EQ(test_dictionary_gurl, observer.last_dictionary_url());
 }
 
 }  // namespace net