Clang format slam.

net/base/sdch_manager.cc

 // Copyright (c) 2012 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 "net/base/sdch_manager.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 99 matching lines @@
 
   // TODO(jar): Redirects in dictionary fetches might plausibly be problematic,
   // and hence the conservative approach is to not allow any redirects (if there
   // were any... then don't allow the dictionary to be set).
 
   if (domain.empty()) {
     SdchErrorRecovery(DICTIONARY_MISSING_DOMAIN_SPECIFIER);
     return false;  // Domain is required.
   }
   if (registry_controlled_domains::GetDomainAndRegistry(
-        domain,
-        registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES).empty()) {
+          domain, registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES)
+          .empty()) {
     SdchErrorRecovery(DICTIONARY_SPECIFIES_TOP_LEVEL_DOMAIN);
     return false;  // domain was a TLD.
   }
   if (!Dictionary::DomainMatch(dictionary_url, domain)) {
     SdchErrorRecovery(DICTIONARY_DOMAIN_NOT_MATCHING_SOURCE_URL);
     return false;
   }
 
   std::string referrer_url_host = dictionary_url.host();
   size_t postfix_domain_index = referrer_url_host.rfind(domain);
   // See if it is indeed a postfix, or just an internal string.
   if (referrer_url_host.size() == postfix_domain_index + domain.size()) {
     // It is a postfix... so check to see if there's a dot in the prefix.
     size_t end_of_host_index = referrer_url_host.find_first_of('.');
-    if (referrer_url_host.npos != end_of_host_index  &&
+    if (referrer_url_host.npos != end_of_host_index &&
         end_of_host_index < postfix_domain_index) {
       SdchErrorRecovery(DICTIONARY_REFERER_URL_HAS_DOT_IN_PREFIX);
       return false;
     }
   }
 
-  if (!ports.empty()
-      && 0 == ports.count(dictionary_url.EffectiveIntPort())) {
+  if (!ports.empty() && 0 == ports.count(dictionary_url.EffectiveIntPort())) {
     SdchErrorRecovery(DICTIONARY_PORT_NOT_MATCHING_SOURCE_URL);
     return false;
   }
   return true;
 }
 
 // static
 bool SdchManager::Dictionary::CanUse(const GURL& referring_url) {
   if (!SdchManager::Global()->IsInSupportedDomain(referring_url))
     return false;
   /*
     1. The request URL's host name domain-matches the Domain attribute of the
       dictionary.
     2. If the dictionary has a Port attribute, the request port is one of the
       ports listed in the Port attribute.
     3. The request URL path-matches the path attribute of the dictionary.
     4. The request is not an HTTPS request.
     We can override (ignore) item (4) only when we have explicitly enabled
     HTTPS support AND dictionary has been acquired over HTTPS.
 */
   if (!DomainMatch(referring_url, domain_)) {
     SdchErrorRecovery(DICTIONARY_FOUND_HAS_WRONG_DOMAIN);
     return false;
   }
-  if (!ports_.empty()
-      && 0 == ports_.count(referring_url.EffectiveIntPort())) {
+  if (!ports_.empty() && 0 == ports_.count(referring_url.EffectiveIntPort())) {
     SdchErrorRecovery(DICTIONARY_FOUND_HAS_WRONG_PORT_LIST);
     return false;
   }
   if (path_.size() && !PathMatch(referring_url.path(), path_)) {
     SdchErrorRecovery(DICTIONARY_FOUND_HAS_WRONG_PATH);
     return false;
   }
   if (!SdchManager::secure_scheme_supported() &&
       referring_url.SchemeIsSecure()) {
     SdchErrorRecovery(DICTIONARY_FOUND_HAS_WRONG_SCHEME);
@@ skipping 52 matching lines @@
     DictionaryMap::iterator it = dictionaries_.begin();
     it->second->Release();
     dictionaries_.erase(it->first);
   }
   global_ = NULL;
 }
 
 // static
 void SdchManager::Shutdown() {
   EnableSdchSupport(false);
-  if (!global_ )
+  if (!global_)
     return;
   global_->set_sdch_fetcher(NULL);
 }
 
 // static
 SdchManager* SdchManager::Global() {
   return global_;
 }
 
 // static
@@ skipping 11 matching lines @@
   g_sdch_enabled_ = enabled;
 }
 
 // static
 void SdchManager::EnableSecureSchemeSupport(bool enabled) {
   g_secure_scheme_supported_ = enabled;
 }
 
 // static
 void SdchManager::BlacklistDomain(const GURL& url) {
-  if (!global_ )
+  if (!global_)
     return;
   global_->SetAllowLatencyExperiment(url, false);
 
   std::string domain(StringToLowerASCII(url.host()));
   int count = global_->blacklisted_domains_[domain];
   if (count > 0)
     return;  // Domain is already blacklisted.
 
   count = 1 + 2 * global_->exponential_blacklist_count[domain];
   if (count > 0)
     global_->exponential_blacklist_count[domain] = count;
   else
     count = INT_MAX;
 
   global_->blacklisted_domains_[domain] = count;
 }
 
 // static
 void SdchManager::BlacklistDomainForever(const GURL& url) {
-  if (!global_ )
+  if (!global_)
     return;
   global_->SetAllowLatencyExperiment(url, false);
 
   std::string domain(StringToLowerASCII(url.host()));
   global_->exponential_blacklist_count[domain] = INT_MAX;
   global_->blacklisted_domains_[domain] = INT_MAX;
 }
 
 // static
 void SdchManager::ClearBlacklistings() {
@@ skipping 17 matching lines @@
 // static
 int SdchManager::BlacklistDomainExponential(const std::string& domain) {
   if (Global()->exponential_blacklist_count.end() ==
       Global()->exponential_blacklist_count.find(domain))
     return 0;
   return Global()->exponential_blacklist_count[StringToLowerASCII(domain)];
 }
 
 bool SdchManager::IsInSupportedDomain(const GURL& url) {
   DCHECK(CalledOnValidThread());
-  if (!g_sdch_enabled_ )
+  if (!g_sdch_enabled_)
     return false;
 
   if (blacklisted_domains_.empty())
     return true;
 
   std::string domain(StringToLowerASCII(url.host()));
   DomainCounter::iterator it = blacklisted_domains_.find(domain);
   if (blacklisted_domains_.end() == it)
     return true;
 
@@ skipping 43 matching lines @@
   // than current SDCH spec when needed, and justified by security audit.
   if (!referring_url.SchemeIsHTTPOrHTTPS()) {
     SdchErrorRecovery(DICTIONARY_SELECTED_FROM_NON_HTTP);
     return false;
   }
 
   return true;
 }
 
 bool SdchManager::AddSdchDictionary(const std::string& dictionary_text,
-    const GURL& dictionary_url) {
+                                    const GURL& dictionary_url) {
   DCHECK(CalledOnValidThread());
   std::string client_hash;
   std::string server_hash;
   GenerateHash(dictionary_text, &client_hash, &server_hash);
   if (dictionaries_.find(server_hash) != dictionaries_.end()) {
     SdchErrorRecovery(DICTIONARY_ALREADY_LOADED);
     return false;  // Already loaded.
   }
 
   std::string domain, path;
@@ skipping 18 matching lines @@
 
     size_t colon_index = dictionary_text.find(':', line_start);
     if (std::string::npos == colon_index) {
       SdchErrorRecovery(DICTIONARY_HEADER_LINE_MISSING_COLON);
       return false;  // Illegal line missing a colon.
     }
 
     if (colon_index > line_end)
       break;
 
-    size_t value_start = dictionary_text.find_first_not_of(" \t",
-                                                           colon_index + 1);
+    size_t value_start =
+        dictionary_text.find_first_not_of(" \t", colon_index + 1);
     if (std::string::npos != value_start) {
       if (value_start >= line_end)
         break;
       std::string name(dictionary_text, line_start, colon_index - line_start);
       std::string value(dictionary_text, value_start, line_end - value_start);
       name = StringToLowerASCII(name);
       if (name == "domain") {
         domain = value;
       } else if (name == "path") {
         path = value;
@@ skipping 29 matching lines @@
     return false;
   }
   if (kMaxDictionaryCount <= dictionaries_.size()) {
     SdchErrorRecovery(DICTIONARY_COUNT_EXCEEDED);
     return false;
   }
 
   UMA_HISTOGRAM_COUNTS("Sdch3.Dictionary size loaded", dictionary_text.size());
   DVLOG(1) << "Loaded dictionary with client hash " << client_hash
            << " and server hash " << server_hash;
-  Dictionary* dictionary =
-      new Dictionary(dictionary_text, header_end + 2, client_hash,
-                     dictionary_url, domain, path, expiration, ports);
+  Dictionary* dictionary = new Dictionary(dictionary_text,
+                                          header_end + 2,
+                                          client_hash,
+                                          dictionary_url,
+                                          domain,
+                                          path,
+                                          expiration,
+                                          ports);
   dictionary->AddRef();
   dictionaries_[server_hash] = dictionary;
   return true;
 }
 
 void SdchManager::GetVcdiffDictionary(const std::string& server_hash,
-    const GURL& referring_url, Dictionary** dictionary) {
+                                      const GURL& referring_url,
+                                      Dictionary** dictionary) {
   DCHECK(CalledOnValidThread());
   *dictionary = NULL;
   DictionaryMap::iterator it = dictionaries_.find(server_hash);
   if (it == dictionaries_.end()) {
     return;
   }
   Dictionary* matching_dictionary = it->second;
   if (!matching_dictionary->CanUse(referring_url))
     return;
   *dictionary = matching_dictionary;
 }
 
 // TODO(jar): If we have evictions from the dictionaries_, then we need to
 // change this interface to return a list of reference counted Dictionary
 // instances that can be used if/when a server specifies one.
 void SdchManager::GetAvailDictionaryList(const GURL& target_url,
                                          std::string* list) {
   DCHECK(CalledOnValidThread());
   int count = 0;
   for (DictionaryMap::iterator it = dictionaries_.begin();
-       it != dictionaries_.end(); ++it) {
+       it != dictionaries_.end();
+       ++it) {
     if (!it->second->CanAdvertise(target_url))
       continue;
     ++count;
     if (!list->empty())
       list->append(",");
     list->append(it->second->client_hash());
   }
   // Watch to see if we have corrupt or numerous dictionaries.
   if (count > 0)
     UMA_HISTOGRAM_COUNTS("Sdch3.Advertisement_Count", count);
 }
 
 // static
 void SdchManager::GenerateHash(const std::string& dictionary_text,
-    std::string* client_hash, std::string* server_hash) {
+                               std::string* client_hash,
+                               std::string* server_hash) {
   char binary_hash[32];
   crypto::SHA256HashString(dictionary_text, binary_hash, sizeof(binary_hash));
 
   std::string first_48_bits(&binary_hash[0], 6);
   std::string second_48_bits(&binary_hash[6], 6);
   UrlSafeBase64Encode(first_48_bits, client_hash);
   UrlSafeBase64Encode(second_48_bits, server_hash);
 
   DCHECK_EQ(server_hash->length(), 8u);
   DCHECK_EQ(client_hash->length(), 8u);
 }
 
 //------------------------------------------------------------------------------
 // Methods for supporting latency experiments.
 
 bool SdchManager::AllowLatencyExperiment(const GURL& url) const {
   DCHECK(CalledOnValidThread());
   return allow_latency_experiment_.end() !=
-      allow_latency_experiment_.find(url.host());
+         allow_latency_experiment_.find(url.host());
 }
 
 void SdchManager::SetAllowLatencyExperiment(const GURL& url, bool enable) {
   DCHECK(CalledOnValidThread());
   if (enable) {
     allow_latency_experiment_.insert(url.host());
     return;
   }
   ExperimentSet::iterator it = allow_latency_experiment_.find(url.host());
   if (allow_latency_experiment_.end() == it)
@@ skipping 16 matching lines @@
       case '/':
         (*output)[i] = '_';
         continue;
       default:
         continue;
     }
   }
 }
 
 }  // namespace net