Clang format slam.

net/dns/host_cache.h

 // 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.
 
 #ifndef NET_DNS_HOST_CACHE_H_
 #define NET_DNS_HOST_CACHE_H_
 
 #include <functional>
 #include <string>
 
@@ skipping 21 matching lines @@
     bool has_ttl() const { return ttl >= base::TimeDelta(); }
 
     // The resolve results for this entry.
     int error;
     AddressList addrlist;
     // TTL obtained from the nameserver. Negative if unknown.
     base::TimeDelta ttl;
   };
 
   struct Key {
-    Key(const std::string& hostname, AddressFamily address_family,
+    Key(const std::string& hostname,
+        AddressFamily address_family,
         HostResolverFlags host_resolver_flags)
         : hostname(hostname),
           address_family(address_family),
           host_resolver_flags(host_resolver_flags) {}
 
     bool operator<(const Key& other) const {
       // |address_family| and |host_resolver_flags| are compared before
       // |hostname| under assumption that integer comparisons are faster than
       // string comparisons.
       if (address_family != other.address_family)
         return address_family < other.address_family;
       if (host_resolver_flags != other.host_resolver_flags)
         return host_resolver_flags < other.host_resolver_flags;
       return hostname < other.hostname;
     }
 
     std::string hostname;
     AddressFamily address_family;
     HostResolverFlags host_resolver_flags;
   };
 
   struct EvictionHandler {
     void Handle(const Key& key,
                 const Entry& entry,
                 const base::TimeTicks& expiration,
                 const base::TimeTicks& now,
                 bool onGet) const;
   };
 
-  typedef ExpiringCache<Key, Entry, base::TimeTicks,
+  typedef ExpiringCache<Key,
+                        Entry,
+                        base::TimeTicks,
                         std::less<base::TimeTicks>,
                         EvictionHandler> EntryMap;
 
   // Constructs a HostCache that stores up to |max_entries|.
   explicit HostCache(size_t max_entries);
 
   ~HostCache();
 
   // Returns a pointer to the entry for |key|, which is valid at time
   // |now|. If there is no such entry, returns NULL.
@@ skipping 18 matching lines @@
 
   const EntryMap& entries() const;
 
   // Creates a default cache.
   static scoped_ptr<HostCache> CreateDefaultCache();
 
  private:
   FRIEND_TEST_ALL_PREFIXES(HostCacheTest, NoCache);
 
   // Returns true if this HostCache can contain no entries.
-  bool caching_is_disabled() const {
-    return entries_.max_entries() == 0;
-  }
+  bool caching_is_disabled() const { return entries_.max_entries() == 0; }
 
   // Map from hostname (presumably in lowercase canonicalized format) to
   // a resolved result entry.
   EntryMap entries_;
 
   DISALLOW_COPY_AND_ASSIGN(HostCache);
 };
 
 }  // namespace net
 
 #endif  // NET_DNS_HOST_CACHE_H_