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

net/base/net_log_util.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 "net/base/net_log_util.h"
 
 #include <string>
 
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 25 matching lines @@
 // This should be incremented when significant changes are made that will
 // invalidate the old loading code.
 const int kLogFormatVersion = 1;
 
 struct StringToConstant {
   const char* name;
   const int constant;
 };
 
 const StringToConstant kCertStatusFlags[] = {
-#define CERT_STATUS_FLAG(label, value) { #label, value },
+#define CERT_STATUS_FLAG(label, value) \
+  { #label, value }                    \
+  ,
 #include "net/cert/cert_status_flags_list.h"
 #undef CERT_STATUS_FLAG
 };
 
 const StringToConstant kLoadFlags[] = {
-#define LOAD_FLAG(label, value) { #label, value },
+#define LOAD_FLAG(label, value) \
+  { #label, value }             \
+  ,

[mmenke, 2014/12/02 19:22:29]

The placement of the comma here is really weird.

 #include "net/base/load_flags_list.h"
 #undef LOAD_FLAG
 };
 
 const StringToConstant kLoadStateTable[] = {
-#define LOAD_STATE(label) { # label, net::LOAD_STATE_ ## label },
+#define LOAD_STATE(label)             \
+  { #label, net::LOAD_STATE_##label } \
+  ,
 #include "net/base/load_states_list.h"
 #undef LOAD_STATE
 };
 
 const short kNetErrors[] = {
 #define NET_ERROR(label, value) value,
 #include "net/base/net_error_list.h"
 #undef NET_ERROR
 };
 
 const char* NetInfoSourceToString(NetInfoSource source) {
   switch (source) {
-    #define NET_INFO_SOURCE(label, string, value) \
-    case NET_INFO_ ## label: \
-      return string;
+#define NET_INFO_SOURCE(label, string, value) \
+  case NET_INFO_##label:                      \
+    return string;
 #include "net/base/net_info_source_list.h"
-    #undef NET_INFO_SOURCE
+#undef NET_INFO_SOURCE
     case NET_INFO_ALL_SOURCES:
       return "All";
   }
   return "?";
 }
 
 // Returns the disk cache backend for |context| if there is one, or NULL.
 // Despite the name, can return an in memory "disk cache".
 disk_cache::Backend* GetDiskCacheBackend(net::URLRequestContext* context) {
   if (!context->http_transaction_factory())
@@ skipping 46 matching lines @@
     base::DictionaryValue* dict = new base::DictionaryValue();
 
     for (size_t i = 0; i < arraysize(kLoadStateTable); i++)
       dict->SetInteger(kLoadStateTable[i].name, kLoadStateTable[i].constant);
 
     constants_dict->Set("loadState", dict);
   }
 
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
-    #define NET_INFO_SOURCE(label, string, value) \
-        dict->SetInteger(string, NET_INFO_ ## label);
+#define NET_INFO_SOURCE(label, string, value) \
+  dict->SetInteger(string, NET_INFO_##label);
 #include "net/base/net_info_source_list.h"
-    #undef NET_INFO_SOURCE
+#undef NET_INFO_SOURCE
     constants_dict->Set("netInfoSources", dict);
   }
 
   // Add information on the relationship between net error codes and their
   // symbolic names.
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
     for (size_t i = 0; i < arraysize(kNetErrors); i++)
       dict->SetInteger(ErrorToShortString(kNetErrors[i]), kNetErrors[i]);
@@ skipping 60 matching lines @@
     constants_dict->Set("logLevelType", dict);
   }
 
   // Information about the relationship between address family enums and
   // their symbolic names.
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
     dict->SetInteger("ADDRESS_FAMILY_UNSPECIFIED",
                      net::ADDRESS_FAMILY_UNSPECIFIED);
-    dict->SetInteger("ADDRESS_FAMILY_IPV4",
-                     net::ADDRESS_FAMILY_IPV4);
-    dict->SetInteger("ADDRESS_FAMILY_IPV6",
-                     net::ADDRESS_FAMILY_IPV6);
+    dict->SetInteger("ADDRESS_FAMILY_IPV4", net::ADDRESS_FAMILY_IPV4);
+    dict->SetInteger("ADDRESS_FAMILY_IPV6", net::ADDRESS_FAMILY_IPV6);
 
     constants_dict->Set("addressFamily", dict);
   }
 
   // Information about how the "time ticks" values we have given it relate to
   // actual system times. (We used time ticks throughout since they are stable
   // across system clock changes).
   {
     int64 cur_time_ms = (base::Time::Now() - base::Time()).InMilliseconds();
 
@@ skipping 20 matching lines @@
   constants_dict->Set("clientInfo", new base::DictionaryValue());
 
   // Add a list of active field experiments.
   {
     base::FieldTrial::ActiveGroups active_groups;
     base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
     base::ListValue* field_trial_groups = new base::ListValue();
     for (base::FieldTrial::ActiveGroups::const_iterator it =
              active_groups.begin();
          it != active_groups.end(); ++it) {
-      field_trial_groups->AppendString(it->trial_name + ":" +
-                                       it->group_name);
+      field_trial_groups->AppendString(it->trial_name + ":" + it->group_name);
     }
     constants_dict->Set("activeFieldTrialGroups", field_trial_groups);
   }
 
   return constants_dict.Pass();
 }
 
 NET_EXPORT scoped_ptr<base::DictionaryValue> GetNetInfo(
-    URLRequestContext* context, int info_sources) {
+    URLRequestContext* context,
+    int info_sources) {
   scoped_ptr<base::DictionaryValue> net_info_dict(new base::DictionaryValue());
 
   // TODO(mmenke):  The code for most of these sources should probably be moved
   // into the sources themselves.
   if (info_sources & NET_INFO_PROXY_SETTINGS) {
     net::ProxyService* proxy_service = context->proxy_service();
 
     base::DictionaryValue* dict = new base::DictionaryValue();
     if (proxy_service->fetched_config().is_valid())
       dict->Set("original", proxy_service->fetched_config().ToValue());
@@ skipping 34 matching lines @@
       base::Value* dns_config = host_resolver->GetDnsConfigAsValue();
       if (dns_config)
         dict->Set("dns_config", dns_config);
 
       dict->SetInteger(
           "default_address_family",
           static_cast<int>(host_resolver->GetDefaultAddressFamily()));
 
       base::DictionaryValue* cache_info_dict = new base::DictionaryValue();
 
-      cache_info_dict->SetInteger(
-          "capacity",
-          static_cast<int>(cache->max_entries()));
+      cache_info_dict->SetInteger("capacity",
+                                  static_cast<int>(cache->max_entries()));
 
       base::ListValue* entry_list = new base::ListValue();
 
       net::HostCache::EntryMap::Iterator it(cache->entries());
       for (; it.HasNext(); it.Advance()) {
         const net::HostCache::Key& key = it.key();
         const net::HostCache::Entry& entry = it.value();
 
         base::DictionaryValue* entry_dict = new base::DictionaryValue();
 
         entry_dict->SetString("hostname", key.hostname);
         entry_dict->SetInteger("address_family",
-            static_cast<int>(key.address_family));
+                               static_cast<int>(key.address_family));
         entry_dict->SetString("expiration",
                               net::NetLog::TickCountToString(it.expiration()));
 
         if (entry.error != net::OK) {
           entry_dict->SetInteger("error", entry.error);
         } else {
           // Append all of the resolved addresses.
           base::ListValue* address_list = new base::ListValue();
           for (size_t i = 0; i < entry.addrlist.size(); ++i) {
             address_list->AppendString(entry.addrlist[i].ToStringWithoutPort());
           }
           entry_dict->Set("addresses", address_list);
         }
 
         entry_list->Append(entry_dict);
       }
 
       cache_info_dict->Set("entries", entry_list);
       dict->Set("cache", cache_info_dict);
       net_info_dict->Set(NetInfoSourceToString(NET_INFO_HOST_RESOLVER), dict);
     }
   }
 
   net::HttpNetworkSession* http_network_session =
       context->http_transaction_factory()->GetSession();
 
   if (info_sources & NET_INFO_SOCKET_POOL) {
     net_info_dict->Set(NetInfoSourceToString(NET_INFO_SOCKET_POOL),
-                        http_network_session->SocketPoolInfoToValue());
+                       http_network_session->SocketPoolInfoToValue());
   }
 
   if (info_sources & NET_INFO_SPDY_SESSIONS) {
     net_info_dict->Set(NetInfoSourceToString(NET_INFO_SPDY_SESSIONS),
-                        http_network_session->SpdySessionPoolInfoToValue());
+                       http_network_session->SpdySessionPoolInfoToValue());
   }
 
   if (info_sources & NET_INFO_SPDY_STATUS) {
     base::DictionaryValue* status_dict = new base::DictionaryValue();
 
     status_dict->SetBoolean("spdy_enabled",
                             net::HttpStreamFactory::spdy_enabled());
     status_dict->SetBoolean(
         "use_alternate_protocols",
         http_network_session->params().use_alternate_protocols);
-    status_dict->SetBoolean(
-        "force_spdy_over_ssl",
-        http_network_session->params().force_spdy_over_ssl);
-    status_dict->SetBoolean(
-        "force_spdy_always",
-        http_network_session->params().force_spdy_always);
+    status_dict->SetBoolean("force_spdy_over_ssl",
+                            http_network_session->params().force_spdy_over_ssl);
+    status_dict->SetBoolean("force_spdy_always",
+                            http_network_session->params().force_spdy_always);
 
     std::vector<std::string> next_protos;
     http_network_session->GetNextProtos(&next_protos);
     std::string next_protos_string = JoinString(next_protos, ',');
     status_dict->SetString("next_protos", next_protos_string);
 
     net_info_dict->Set(NetInfoSourceToString(NET_INFO_SPDY_STATUS),
-                        status_dict);
+                       status_dict);
   }
 
   if (info_sources & NET_INFO_SPDY_ALT_PROTO_MAPPINGS) {
     base::ListValue* dict_list = new base::ListValue();
 
     const net::HttpServerProperties& http_server_properties =
         *context->http_server_properties();
 
     const net::AlternateProtocolMap& map =
         http_server_properties.alternate_protocol_map();
 
     for (net::AlternateProtocolMap::const_iterator it = map.begin();
-          it != map.end(); ++it) {
+         it != map.end(); ++it) {
       base::DictionaryValue* dict = new base::DictionaryValue();
       dict->SetString("host_port_pair", it->first.ToString());
       dict->SetString("alternate_protocol", it->second.ToString());
       dict_list->Append(dict);
     }
 
     net_info_dict->Set(NetInfoSourceToString(NET_INFO_SPDY_ALT_PROTO_MAPPINGS),
                        dict_list);
   }
 
   if (info_sources & NET_INFO_QUIC) {
     net_info_dict->Set(NetInfoSourceToString(NET_INFO_QUIC),
-                        http_network_session->QuicInfoToValue());
+                       http_network_session->QuicInfoToValue());
   }
 
   if (info_sources & NET_INFO_HTTP_CACHE) {
     base::DictionaryValue* info_dict = new base::DictionaryValue();
     base::DictionaryValue* stats_dict = new base::DictionaryValue();
 
     disk_cache::Backend* disk_cache = GetDiskCacheBackend(context);
 
     if (disk_cache) {
       // Extract the statistics key/value pairs from the backend.
       base::StringPairs stats;
       disk_cache->GetStats(&stats);
       for (size_t i = 0; i < stats.size(); ++i) {
-        stats_dict->SetStringWithoutPathExpansion(
-            stats[i].first, stats[i].second);
+        stats_dict->SetStringWithoutPathExpansion(stats[i].first,
+                                                  stats[i].second);
       }
     }
     info_dict->Set("stats", stats_dict);
 
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_HTTP_CACHE),
-                       info_dict);
+    net_info_dict->Set(NetInfoSourceToString(NET_INFO_HTTP_CACHE), info_dict);
   }
 
   return net_info_dict.Pass();
 }
 
 }  // namespace net