Clang format slam.

net/dns/mock_host_resolver.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/dns/mock_host_resolver.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 99 matching lines @@
 
 void MockHostResolverBase::CancelRequest(RequestHandle handle) {
   DCHECK(CalledOnValidThread());
   size_t id = reinterpret_cast<size_t>(handle);
   RequestMap::iterator it = requests_.find(id);
   if (it != requests_.end()) {
     scoped_ptr<Request> req(it->second);
     requests_.erase(it);
   } else {
     NOTREACHED() << "CancelRequest must NOT be called after request is "
-        "complete or canceled.";
+                    "complete or canceled.";
   }
 }
 
 HostCache* MockHostResolverBase::GetHostCache() {
   return cache_.get();
 }
 
 void MockHostResolverBase::ResolveAllPending() {
   DCHECK(CalledOnValidThread());
   DCHECK(ondemand_mode_);
@@ skipping 23 matching lines @@
                                                       AddressList* addresses) {
   IPAddressNumber ip;
   if (ParseIPLiteralToNumber(info.hostname(), &ip)) {
     *addresses = AddressList::CreateFromIPAddress(ip, info.port());
     if (info.host_resolver_flags() & HOST_RESOLVER_CANONNAME)
       addresses->SetDefaultCanonicalName();
     return OK;
   }
   int rv = ERR_DNS_CACHE_MISS;
   if (cache_.get() && info.allow_cached_response()) {
-    HostCache::Key key(info.hostname(),
-                       info.address_family(),
-                       info.host_resolver_flags());
+    HostCache::Key key(
+        info.hostname(), info.address_family(), info.host_resolver_flags());
     const HostCache::Entry* entry = cache_->Lookup(key, base::TimeTicks::Now());
     if (entry) {
       rv = entry->error;
       if (rv == OK)
         *addresses = AddressList::CopyWithPort(entry->addrlist, info.port());
     }
   }
   return rv;
 }
 
 int MockHostResolverBase::ResolveProc(size_t id,
                                       const RequestInfo& info,
                                       AddressList* addresses) {
   AddressList addr;
   int rv = rules_->Resolve(info.hostname(),
                            info.address_family(),
                            info.host_resolver_flags(),
                            &addr,
                            NULL);
   if (cache_.get()) {
-    HostCache::Key key(info.hostname(),
-                       info.address_family(),
-                       info.host_resolver_flags());
+    HostCache::Key key(
+        info.hostname(), info.address_family(), info.host_resolver_flags());
     // Storing a failure with TTL 0 so that it overwrites previous value.
     base::TimeDelta ttl;
     if (rv == OK)
       ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
     cache_->Set(key, HostCache::Entry(rv, addr), base::TimeTicks::Now(), ttl);
   }
   if (rv == OK)
     *addresses = AddressList::CopyWithPort(addr, info.port());
   return rv;
 }
@@ skipping 42 matching lines @@
         canonical_name(canonical_name),
         latency_ms(latency_ms) {}
 };
 
 RuleBasedHostResolverProc::RuleBasedHostResolverProc(HostResolverProc* previous)
     : HostResolverProc(previous) {
 }
 
 void RuleBasedHostResolverProc::AddRule(const std::string& host_pattern,
                                         const std::string& replacement) {
-  AddRuleForAddressFamily(host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
-                          replacement);
+  AddRuleForAddressFamily(
+      host_pattern, ADDRESS_FAMILY_UNSPECIFIED, replacement);
 }
 
 void RuleBasedHostResolverProc::AddRuleForAddressFamily(
     const std::string& host_pattern,
     AddressFamily address_family,
     const std::string& replacement) {
   DCHECK(!replacement.empty());
   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
-      HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
+                            HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
   Rule rule(Rule::kResolverTypeSystem,
             host_pattern,
             address_family,
             flags,
             replacement,
             std::string(),
             0);
   rules_.push_back(rule);
 }
 
 void RuleBasedHostResolverProc::AddIPLiteralRule(
     const std::string& host_pattern,
     const std::string& ip_literal,
     const std::string& canonical_name) {
   // Literals are always resolved to themselves by HostResolverImpl,
   // consequently we do not support remapping them.
   IPAddressNumber ip_number;
   DCHECK(!ParseIPLiteralToNumber(host_pattern, &ip_number));
   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
-      HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
+                            HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
   if (!canonical_name.empty())
     flags |= HOST_RESOLVER_CANONNAME;
-  Rule rule(Rule::kResolverTypeIPLiteral, host_pattern,
-            ADDRESS_FAMILY_UNSPECIFIED, flags, ip_literal, canonical_name,
+  Rule rule(Rule::kResolverTypeIPLiteral,
+            host_pattern,
+            ADDRESS_FAMILY_UNSPECIFIED,
+            flags,
+            ip_literal,
+            canonical_name,
             0);
   rules_.push_back(rule);
 }
 
 void RuleBasedHostResolverProc::AddRuleWithLatency(
     const std::string& host_pattern,
     const std::string& replacement,
     int latency_ms) {
   DCHECK(!replacement.empty());
   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
-      HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
+                            HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
   Rule rule(Rule::kResolverTypeSystem,
             host_pattern,
             ADDRESS_FAMILY_UNSPECIFIED,
             flags,
             replacement,
             std::string(),
             latency_ms);
   rules_.push_back(rule);
 }
 
 void RuleBasedHostResolverProc::AllowDirectLookup(
     const std::string& host_pattern) {
   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
-      HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
+                            HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
   Rule rule(Rule::kResolverTypeSystem,
             host_pattern,
             ADDRESS_FAMILY_UNSPECIFIED,
             flags,
             std::string(),
             std::string(),
             0);
   rules_.push_back(rule);
 }
 
 void RuleBasedHostResolverProc::AddSimulatedFailure(
     const std::string& host_pattern) {
   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
-      HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
+                            HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
   Rule rule(Rule::kResolverTypeFail,
             host_pattern,
             ADDRESS_FAMILY_UNSPECIFIED,
             flags,
             std::string(),
             std::string(),
             0);
   rules_.push_back(rule);
 }
 
@@ skipping 34 matching lines @@
       switch (r->resolver_type) {
         case Rule::kResolverTypeFail:
           return ERR_NAME_NOT_RESOLVED;
         case Rule::kResolverTypeSystem:
 #if defined(OS_WIN)
           net::EnsureWinsockInit();
 #endif
           return SystemHostResolverCall(effective_host,
                                         address_family,
                                         host_resolver_flags,
-                                        addrlist, os_error);
+                                        addrlist,
+                                        os_error);
         case Rule::kResolverTypeIPLiteral:
-          return ParseAddressList(effective_host,
-                                  r->canonical_name,
-                                  addrlist);
+          return ParseAddressList(effective_host, r->canonical_name, addrlist);
         default:
           NOTREACHED();
           return ERR_UNEXPECTED;
       }
     }
   }
-  return ResolveUsingPrevious(host, address_family,
-                              host_resolver_flags, addrlist, os_error);
+  return ResolveUsingPrevious(
+      host, address_family, host_resolver_flags, addrlist, os_error);
 }
 
 RuleBasedHostResolverProc::~RuleBasedHostResolverProc() {
 }
 
 RuleBasedHostResolverProc* CreateCatchAllHostResolverProc() {
   RuleBasedHostResolverProc* catchall = new RuleBasedHostResolverProc(NULL);
   catchall->AddIPLiteralRule("*", "127.0.0.1", "localhost");
 
   // Next add a rules-based layer the use controls.
@@ skipping 12 matching lines @@
 }
 
 int HangingHostResolver::ResolveFromCache(const RequestInfo& info,
                                           AddressList* addresses,
                                           const BoundNetLog& net_log) {
   return ERR_DNS_CACHE_MISS;
 }
 
 //-----------------------------------------------------------------------------
 
-ScopedDefaultHostResolverProc::ScopedDefaultHostResolverProc() {}
+ScopedDefaultHostResolverProc::ScopedDefaultHostResolverProc() {
+}
 
 ScopedDefaultHostResolverProc::ScopedDefaultHostResolverProc(
     HostResolverProc* proc) {
   Init(proc);
 }
 
 ScopedDefaultHostResolverProc::~ScopedDefaultHostResolverProc() {
   HostResolverProc* old_proc =
       HostResolverProc::SetDefault(previous_proc_.get());
   // The lifetimes of multiple instances must be nested.
   CHECK_EQ(old_proc, current_proc_);
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_.get());
   current_proc_->SetLastProc(previous_proc_.get());
 }
 
 }  // namespace net