Clang format slam.

net/http/http_server_properties_impl.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/http/http_server_properties_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 30 matching lines @@
 }
 
 void HttpServerPropertiesImpl::InitializeSpdyServers(
     std::vector<std::string>* spdy_servers,
     bool support_spdy) {
   DCHECK(CalledOnValidThread());
   if (!spdy_servers)
     return;
   // Add the entries from persisted data.
   for (std::vector<std::string>::reverse_iterator it = spdy_servers->rbegin();
-       it != spdy_servers->rend(); ++it) {
+       it != spdy_servers->rend();
+       ++it) {
     spdy_servers_map_.Put(*it, support_spdy);
   }
 }
 
 void HttpServerPropertiesImpl::InitializeAlternateProtocolServers(
     AlternateProtocolMap* alternate_protocol_map) {
   // Keep all the ALTERNATE_PROTOCOL_BROKEN ones since those don't
   // get persisted.
   for (AlternateProtocolMap::iterator it = alternate_protocol_map_.begin();
        it != alternate_protocol_map_.end();) {
     AlternateProtocolMap::iterator old_it = it;
     ++it;
     if (old_it->second.protocol != ALTERNATE_PROTOCOL_BROKEN) {
       alternate_protocol_map_.Erase(old_it);
     }
   }
 
   // Add the entries from persisted data.
   for (AlternateProtocolMap::reverse_iterator it =
            alternate_protocol_map->rbegin();
-       it != alternate_protocol_map->rend(); ++it) {
+       it != alternate_protocol_map->rend();
+       ++it) {
     alternate_protocol_map_.Put(it->first, it->second);
   }
 
   // Attempt to find canonical servers.
-  int canonical_ports[] = { 80, 443 };
+  int canonical_ports[] = {80, 443};
   for (size_t i = 0; i < canoncial_suffixes_.size(); ++i) {
     std::string canonical_suffix = canoncial_suffixes_[i];
     for (size_t j = 0; j < arraysize(canonical_ports); ++j) {
       HostPortPair canonical_host(canonical_suffix, canonical_ports[j]);
       // If we already have a valid canonical server, we're done.
       if (ContainsKey(canonical_host_to_origin_map_, canonical_host) &&
-          (alternate_protocol_map_.Peek(canonical_host_to_origin_map_[
-               canonical_host]) != alternate_protocol_map_.end())) {
+          (alternate_protocol_map_.Peek(
+               canonical_host_to_origin_map_[canonical_host]) !=
+           alternate_protocol_map_.end())) {
         continue;
       }
       // Now attempt to find a server which matches this origin and set it as
       // canonical .
       for (AlternateProtocolMap::const_iterator it =
                alternate_protocol_map_.begin();
-           it != alternate_protocol_map_.end(); ++it) {
+           it != alternate_protocol_map_.end();
+           ++it) {
         if (EndsWith(it->first.host(), canoncial_suffixes_[i], false)) {
           canonical_host_to_origin_map_[canonical_host] = it->first;
           break;
         }
       }
     }
   }
 }
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
     SpdySettingsMap* spdy_settings_map) {
   for (SpdySettingsMap::reverse_iterator it = spdy_settings_map->rbegin();
-       it != spdy_settings_map->rend(); ++it) {
+       it != spdy_settings_map->rend();
+       ++it) {
     spdy_settings_map_.Put(it->first, it->second);
   }
 }
 
 void HttpServerPropertiesImpl::InitializePipelineCapabilities(
     const PipelineCapabilityMap* pipeline_capability_map) {
   PipelineCapabilityMap::const_iterator it;
   pipeline_capability_map_->Clear();
   for (it = pipeline_capability_map->begin();
-       it != pipeline_capability_map->end(); ++it) {
+       it != pipeline_capability_map->end();
+       ++it) {
     pipeline_capability_map_->Put(it->first, it->second);
   }
 }
 
 void HttpServerPropertiesImpl::SetNumPipelinedHostsToRemember(int max_size) {
   DCHECK(pipeline_capability_map_->empty());
   pipeline_capability_map_.reset(new CachedPipelineCapabilityMap(max_size));
 }
 
 void HttpServerPropertiesImpl::GetSpdyServerList(
     base::ListValue* spdy_server_list,
     size_t max_size) const {
   DCHECK(CalledOnValidThread());
   DCHECK(spdy_server_list);
   spdy_server_list->Clear();
   size_t count = 0;
   // Get the list of servers (host/port) that support SPDY.
   for (SpdyServerHostPortMap::const_iterator it = spdy_servers_map_.begin();
-       it != spdy_servers_map_.end() && count < max_size; ++it) {
+       it != spdy_servers_map_.end() && count < max_size;
+       ++it) {
     const std::string spdy_server_host_port = it->first;
     if (it->second) {
       spdy_server_list->Append(new base::StringValue(spdy_server_host_port));
       ++count;
     }
   }
 }
 
 // static
 std::string HttpServerPropertiesImpl::GetFlattenedSpdyServer(
@@ skipping 68 matching lines @@
 
 bool HttpServerPropertiesImpl::HasAlternateProtocol(
     const HostPortPair& server) {
   if (alternate_protocol_map_.Get(server) != alternate_protocol_map_.end() ||
       g_forced_alternate_protocol)
     return true;
 
   return GetCanonicalHost(server) != canonical_host_to_origin_map_.end();
 }
 
-PortAlternateProtocolPair
-HttpServerPropertiesImpl::GetAlternateProtocol(
+PortAlternateProtocolPair HttpServerPropertiesImpl::GetAlternateProtocol(
     const HostPortPair& server) {
   DCHECK(HasAlternateProtocol(server));
 
   // First check the map.
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Get(server);
   if (it != alternate_protocol_map_.end())
     return it->second;
 
   // Next check the canonical host.
   CanonicalHostMap::const_iterator canonical_host = GetCanonicalHost(server);
@@ skipping 26 matching lines @@
       return;
     }
 
     if (alternate_protocol != ALTERNATE_PROTOCOL_BROKEN &&
         !existing_alternate.Equals(alternate)) {
       LOG(WARNING) << "Changing the alternate protocol for: "
                    << server.ToString()
                    << " from [Port: " << existing_alternate.port
                    << ", Protocol: " << existing_alternate.protocol
                    << "] to [Port: " << alternate_port
-                   << ", Protocol: " << alternate_protocol
-                   << "].";
+                   << ", Protocol: " << alternate_protocol << "].";
     }
   } else {
     // TODO(rch): Consider the case where multiple requests are started
     // before the first completes. In this case, only one of the jobs
     // would reach this code, whereas all of them should should have.
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING);
   }
 
   alternate_protocol_map_.Put(server, alternate);
 
@@ skipping 45 matching lines @@
   broken_alternate_protocol_map_.erase(server);
 }
 
 void HttpServerPropertiesImpl::ClearAlternateProtocol(
     const HostPortPair& server) {
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Peek(server);
   if (it != alternate_protocol_map_.end())
     alternate_protocol_map_.Erase(it);
 }
 
-const AlternateProtocolMap&
-HttpServerPropertiesImpl::alternate_protocol_map() const {
+const AlternateProtocolMap& HttpServerPropertiesImpl::alternate_protocol_map()
+    const {
   return alternate_protocol_map_;
 }
 
 const SettingsMap& HttpServerPropertiesImpl::GetSpdySettings(
     const HostPortPair& host_port_pair) {
   SpdySettingsMap::iterator it = spdy_settings_map_.Get(host_port_pair);
   if (it == spdy_settings_map_.end()) {
     CR_DEFINE_STATIC_LOCAL(SettingsMap, kEmptySettingsMap, ());
     return kEmptySettingsMap;
   }
   return it->second;
 }
 
 bool HttpServerPropertiesImpl::SetSpdySetting(
     const HostPortPair& host_port_pair,
     SpdySettingsIds id,
     SpdySettingsFlags flags,
     uint32 value) {
   if (!(flags & SETTINGS_FLAG_PLEASE_PERSIST))
-      return false;
+    return false;
 
   SettingsFlagsAndValue flags_and_value(SETTINGS_FLAG_PERSISTED, value);
   SpdySettingsMap::iterator it = spdy_settings_map_.Get(host_port_pair);
   if (it == spdy_settings_map_.end()) {
     SettingsMap settings_map;
     settings_map[id] = flags_and_value;
     spdy_settings_map_.Put(host_port_pair, settings_map);
   } else {
     SettingsMap& settings_map = it->second;
     settings_map[id] = flags_and_value;
   }
   return true;
 }
 
 void HttpServerPropertiesImpl::ClearSpdySettings(
     const HostPortPair& host_port_pair) {
   SpdySettingsMap::iterator it = spdy_settings_map_.Peek(host_port_pair);
   if (it != spdy_settings_map_.end())
     spdy_settings_map_.Erase(it);
 }
 
 void HttpServerPropertiesImpl::ClearAllSpdySettings() {
   spdy_settings_map_.Clear();
 }
 
-const SpdySettingsMap&
-HttpServerPropertiesImpl::spdy_settings_map() const {
+const SpdySettingsMap& HttpServerPropertiesImpl::spdy_settings_map() const {
   return spdy_settings_map_;
 }
 
 void HttpServerPropertiesImpl::SetServerNetworkStats(
     const HostPortPair& host_port_pair,
     NetworkStats stats) {
   server_network_stats_map_[host_port_pair] = stats;
 }
 
 const HttpServerProperties::NetworkStats*
@@ skipping 12 matching lines @@
   HttpPipelinedHostCapability capability = PIPELINE_UNKNOWN;
   CachedPipelineCapabilityMap::const_iterator it =
       pipeline_capability_map_->Get(origin);
   if (it != pipeline_capability_map_->end()) {
     capability = it->second;
   }
   return capability;
 }
 
 void HttpServerPropertiesImpl::SetPipelineCapability(
-      const HostPortPair& origin,
-      HttpPipelinedHostCapability capability) {
+    const HostPortPair& origin,
+    HttpPipelinedHostCapability capability) {
   CachedPipelineCapabilityMap::iterator it =
       pipeline_capability_map_->Peek(origin);
   if (it == pipeline_capability_map_->end() ||
       it->second != PIPELINE_INCAPABLE) {
     pipeline_capability_map_->Put(origin, capability);
   }
 }
 
 void HttpServerPropertiesImpl::ClearPipelineCapabilities() {
   pipeline_capability_map_->Clear();
 }
 
-PipelineCapabilityMap
-HttpServerPropertiesImpl::GetPipelineCapabilityMap() const {
+PipelineCapabilityMap HttpServerPropertiesImpl::GetPipelineCapabilityMap()
+    const {
   PipelineCapabilityMap result;
   CachedPipelineCapabilityMap::const_iterator it;
   for (it = pipeline_capability_map_->begin();
-       it != pipeline_capability_map_->end(); ++it) {
+       it != pipeline_capability_map_->end();
+       ++it) {
     result[it->first] = it->second;
   }
   return result;
 }
 
 HttpServerPropertiesImpl::CanonicalHostMap::const_iterator
 HttpServerPropertiesImpl::GetCanonicalHost(HostPortPair server) const {
   for (size_t i = 0; i < canoncial_suffixes_.size(); ++i) {
     std::string canonical_suffix = canoncial_suffixes_[i];
     if (EndsWith(server.host(), canoncial_suffixes_[i], false)) {
@@ skipping 30 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net