Clang format slam.

net/tools/gdig/gdig.cc

Index: net/tools/gdig/gdig.cc
diff --git a/net/tools/gdig/gdig.cc b/net/tools/gdig/gdig.cc
index 2dd165e28b0cac0b75b455aee4f66d463f8b00ca..beae6c65e99ceda7e3310055de45c8509def30d6 100644
--- a/net/tools/gdig/gdig.cc
+++ b/net/tools/gdig/gdig.cc
@@ -72,7 +72,8 @@ std::string DnsConfigToString(const DnsConfig& dns_config) {
   }
 
   base::StringAppendF(&output, "options ndots:%d\n", dns_config.ndots);
-  base::StringAppendF(&output, "options timeout:%d\n",
+  base::StringAppendF(&output,
+                      "options timeout:%d\n",
                       static_cast<int>(dns_config.timeout.InMilliseconds()));
   base::StringAppendF(&output, "options attempts:%d\n", dns_config.attempts);
   if (dns_config.rotate)
@@ -85,8 +86,7 @@ std::string DnsConfigToString(const DnsConfig& dns_config) {
 // Convert DnsConfig hosts member to a human readable text.
 std::string DnsHostsToString(const DnsHosts& dns_hosts) {
   std::string output;
-  for (DnsHosts::const_iterator i = dns_hosts.begin();
-       i != dns_hosts.end();
+  for (DnsHosts::const_iterator i = dns_hosts.begin(); i != dns_hosts.end();
        ++i) {
     const DnsHostsKey& key = i->first;
     std::string host_name = key.first;
@@ -118,7 +118,8 @@ typedef std::vector<ReplayLogEntry> ReplayLog;
 bool LoadReplayLog(const base::FilePath& file_path, ReplayLog* replay_log) {
   std::string original_replay_log_contents;
   if (!base::ReadFileToString(file_path, &original_replay_log_contents)) {
-    fprintf(stderr, "Unable to open replay file %s\n",
+    fprintf(stderr,
+            "Unable to open replay file %s\n",
             file_path.MaybeAsASCII().c_str());
     return false;
   }
@@ -162,11 +163,10 @@ bool LoadReplayLog(const base::FilePath& file_path, ReplayLog* replay_log) {
     base::TimeDelta delta =
         base::TimeDelta::FromMilliseconds(delta_in_milliseconds);
     if (delta < previous_delta) {
-      fprintf(
-          stderr,
-          "[%s %u] replay log should be sorted by time\n",
-          file_path.MaybeAsASCII().c_str(),
-          i + 1);
+      fprintf(stderr,
+              "[%s %u] replay log should be sorted by time\n",
+              file_path.MaybeAsASCII().c_str(),
+              i + 1);
       bad_parse = true;
       continue;
     }
@@ -202,8 +202,10 @@ class GDig {
   void Finish(Result);
 
   void OnDnsConfig(const DnsConfig& dns_config_const);
-  void OnResolveComplete(unsigned index, AddressList* address_list,
-                         base::TimeDelta time_since_start, int val);
+  void OnResolveComplete(unsigned index,
+                         AddressList* address_list,
+                         base::TimeDelta time_since_start,
+                         int val);
   void OnTimeout();
   void ReplayNextEntry();
 
@@ -250,17 +252,17 @@ GDig::~GDig() {
 
 GDig::Result GDig::Main(int argc, const char* argv[]) {
   if (!ParseCommandLine(argc, argv)) {
-      fprintf(stderr,
-              "usage: %s [--net_log[=<basic|no_bytes|all>]]"
-              " [--print_config] [--print_hosts]"
-              " [--nameserver=<ip_address[:port]>]"
-              " [--timeout=<milliseconds>]"
-              " [--config_timeout=<seconds>]"
-              " [--j=<parallel resolves>]"
-              " [--replay_file=<path>]"
-              " [domain_name]\n",
-              argv[0]);
-      return RESULT_WRONG_USAGE;
+    fprintf(stderr,
+            "usage: %s [--net_log[=<basic|no_bytes|all>]]"
+            " [--print_config] [--print_hosts]"
+            " [--nameserver=<ip_address[:port]>]"
+            " [--timeout=<milliseconds>]"
+            " [--config_timeout=<seconds>]"
+            " [--j=<parallel resolves>]"
+            " [--replay_file=<path>]"
+            " [domain_name]\n",
+            argv[0]);
+    return RESULT_WRONG_USAGE;
   }
 
   base::MessageLoopForIO loop;
@@ -318,7 +320,7 @@ bool GDig::ParseCommandLine(int argc, const char* argv[]) {
 
   if (parsed_command_line.HasSwitch("nameserver")) {
     std::string nameserver =
-      parsed_command_line.GetSwitchValueASCII("nameserver");
+        parsed_command_line.GetSwitchValueASCII("nameserver");
     if (!StringToIPEndPoint(nameserver, &nameserver_)) {
       fprintf(stderr,
               "Cannot parse the namerserver string into an IPEndPoint\n");
@@ -329,8 +331,7 @@ bool GDig::ParseCommandLine(int argc, const char* argv[]) {
   if (parsed_command_line.HasSwitch("timeout")) {
     int timeout_millis = 0;
     bool parsed = base::StringToInt(
-        parsed_command_line.GetSwitchValueASCII("timeout"),
-        &timeout_millis);
+        parsed_command_line.GetSwitchValueASCII("timeout"), &timeout_millis);
     if (parsed && timeout_millis > 0) {
       timeout_ = base::TimeDelta::FromMilliseconds(timeout_millis);
     } else {
@@ -349,8 +350,7 @@ bool GDig::ParseCommandLine(int argc, const char* argv[]) {
   if (parsed_command_line.HasSwitch("j")) {
     int parallellism = 0;
     bool parsed = base::StringToInt(
-        parsed_command_line.GetSwitchValueASCII("j"),
-        &parallellism);
+        parsed_command_line.GetSwitchValueASCII("j"), &parallellism);
     if (parsed && parallellism > 0) {
       parallellism_ = parallellism;
     } else {
@@ -381,10 +381,10 @@ void GDig::Start() {
     OnDnsConfig(dns_config);
   } else {
     dns_config_service_ = DnsConfigService::CreateSystemService();
-    dns_config_service_->ReadConfig(base::Bind(&GDig::OnDnsConfig,
-                                               base::Unretained(this)));
-    timeout_closure_.Reset(base::Bind(&GDig::OnTimeout,
-                                      base::Unretained(this)));
+    dns_config_service_->ReadConfig(
+        base::Bind(&GDig::OnDnsConfig, base::Unretained(this)));
+    timeout_closure_.Reset(
+        base::Bind(&GDig::OnTimeout, base::Unretained(this)));
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, timeout_closure_.callback(), config_timeout_);
   }
@@ -405,12 +405,16 @@ void GDig::OnDnsConfig(const DnsConfig& dns_config_const) {
   if (timeout_.InMilliseconds() > 0)
     dns_config.timeout = timeout_;
   if (print_config_) {
-    printf("# Dns Configuration\n"
-           "%s", DnsConfigToString(dns_config).c_str());
+    printf(
+        "# Dns Configuration\n"
+        "%s",
+        DnsConfigToString(dns_config).c_str());
   }
   if (print_hosts_) {
-    printf("# Host Database\n"
-           "%s", DnsHostsToString(dns_config.hosts).c_str());
+    printf(
+        "# Host Database\n"
+        "%s",
+        DnsHostsToString(dns_config.hosts).c_str());
   }
 
   if (replay_log_.empty()) {
@@ -420,12 +424,11 @@ void GDig::OnDnsConfig(const DnsConfig& dns_config_const) {
 
   scoped_ptr<DnsClient> dns_client(DnsClient::CreateClient(NULL));
   dns_client->SetConfig(dns_config);
-  scoped_ptr<HostResolverImpl> resolver(
-      new HostResolverImpl(
-          HostCache::CreateDefaultCache(),
-          PrioritizedDispatcher::Limits(NUM_PRIORITIES, parallellism_),
-          HostResolverImpl::ProcTaskParams(NULL, 1),
-          log_.get()));
+  scoped_ptr<HostResolverImpl> resolver(new HostResolverImpl(
+      HostCache::CreateDefaultCache(),
+      PrioritizedDispatcher::Limits(NUM_PRIORITIES, parallellism_),
+      HostResolverImpl::ProcTaskParams(NULL, 1),
+      log_.get()));
   resolver->SetDnsClient(dns_client.Pass());
   resolver_ = resolver.Pass();
 
@@ -485,7 +488,8 @@ void GDig::OnResolveComplete(unsigned entry_index,
          entry_index,
          static_cast<int>(resolve_end_time.InMilliseconds()),
          static_cast<int>(resolve_time.InMilliseconds()),
-         replay_log_[entry_index].domain_name.c_str(), val);
+         replay_log_[entry_index].domain_name.c_str(),
+         val);
   if (val != OK) {
     printf("%s", ErrorToString(val));
   } else {