Clang format slam.

net/tools/gdig/gdig.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 <stdio.h>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
@@ skipping 54 matching lines @@
     output.append(dns_config.search[i] + " ");
   }
   output.append("\n");
 
   for (size_t i = 0; i < dns_config.nameservers.size(); ++i) {
     output.append("nameserver ");
     output.append(dns_config.nameservers[i].ToString()).append("\n");
   }
 
   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)
     output.append("options rotate\n");
   if (dns_config.edns0)
     output.append("options edns0\n");
   return output;
 }
 
 // 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;
     output.append(IPEndPoint(i->second, -1).ToStringWithoutPort());
     output.append(" ").append(host_name).append("\n");
   }
   return output;
 }
 
 struct ReplayLogEntry {
@@ skipping 11 matching lines @@
 //
 //   timestamp_in_milliseconds domain_name
 //
 // The timestamp_in_milliseconds needs to be an integral delta from start of
 // resolution and is in milliseconds. domain_name is the name to be resolved.
 //
 // The file should be sorted by timestamp in ascending time.
 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;
   }
 
   // Strip out \r characters for Windows files. This isn't as efficient as a
   // smarter line splitter, but this particular use does not need to target
   // efficiency.
   std::string replay_log_contents;
   base::RemoveChars(original_replay_log_contents, "\r", &replay_log_contents);
 
@@ skipping 23 matching lines @@
           "[%s %u] replay log should have format 'timestamp domain_name\\n'\n",
           file_path.MaybeAsASCII().c_str(),
           i + 1);
       bad_parse = true;
       continue;
     }
 
     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;
     }
 
     previous_delta = delta;
     ReplayLogEntry entry;
     entry.start_time = delta;
     entry.domain_name = time_and_name[1];
     replay_log->push_back(entry);
   }
@@ skipping 15 matching lines @@
 
   Result Main(int argc, const char* argv[]);
 
  private:
   bool ParseCommandLine(int argc, const char* argv[]);
 
   void Start();
   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();
 
   base::TimeDelta config_timeout_;
   bool print_config_;
   bool print_hosts_;
   net::IPEndPoint nameserver_;
   base::TimeDelta timeout_;
   int parallellism_;
   ReplayLog replay_log_;
@@ skipping 26 matching lines @@
       active_resolves_(0) {
 }
 
 GDig::~GDig() {
   if (log_)
     log_->RemoveThreadSafeObserver(log_observer_.get());
 }
 
 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;
 
   result_ = RESULT_PENDING;
   Start();
   if (result_ == RESULT_PENDING)
     base::MessageLoop::current()->Run();
 
   // Destroy it while MessageLoopForIO is alive.
@@ skipping 37 matching lines @@
     log_.reset(new NetLog);
     log_observer_.reset(new FileNetLogObserver(stderr));
     log_->AddThreadSafeObserver(log_observer_.get(), level);
   }
 
   print_config_ = parsed_command_line.HasSwitch("print_config");
   print_hosts_ = parsed_command_line.HasSwitch("print_hosts");
 
   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");
       return false;
     }
   }
 
   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 {
       fprintf(stderr, "Invalid timeout parameter\n");
       return false;
     }
   }
 
   if (parsed_command_line.HasSwitch("replay_file")) {
     base::FilePath replay_path =
         parsed_command_line.GetSwitchValuePath("replay_file");
     if (!LoadReplayLog(replay_path, &replay_log_))
       return false;
   }
 
   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 {
       fprintf(stderr, "Invalid parallellism parameter\n");
     }
   }
 
   if (parsed_command_line.GetArgs().size() == 1) {
     ReplayLogEntry entry;
     entry.start_time = base::TimeDelta();
@@ skipping 10 matching lines @@
 }
 
 void GDig::Start() {
   if (nameserver_.address().size() > 0) {
     DnsConfig dns_config;
     dns_config.attempts = 1;
     dns_config.nameservers.push_back(nameserver_);
     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_);
   }
 }
 
 void GDig::Finish(Result result) {
   DCHECK_NE(RESULT_PENDING, result);
   result_ = result;
   if (base::MessageLoop::current())
     base::MessageLoop::current()->Quit();
 }
 
 void GDig::OnDnsConfig(const DnsConfig& dns_config_const) {
   timeout_closure_.Cancel();
   DCHECK(dns_config_const.IsValid());
   DnsConfig dns_config = 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()) {
     Finish(RESULT_OK);
     return;
   }
 
   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();
 
   start_time_ = base::Time::Now();
 
   ReplayNextEntry();
 }
 
 void GDig::ReplayNextEntry() {
   DCHECK_LT(replay_log_index_, replay_log_.size());
@@ skipping 39 matching lines @@
   DCHECK_GT(active_resolves_, 0);
   DCHECK(address_list);
   DCHECK_LT(entry_index, replay_log_.size());
   --active_resolves_;
   base::TimeDelta resolve_end_time = base::Time::Now() - start_time_;
   base::TimeDelta resolve_time = resolve_end_time - resolve_start_time;
   printf("%u %d %d %s %d ",
          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 {
     for (size_t i = 0; i < address_list->size(); ++i) {
       if (i != 0)
         printf(" ");
       printf("%s", (*address_list)[i].ToStringWithoutPort().c_str());
     }
   }
   printf("\n");
   if (active_resolves_ == 0 && replay_log_index_ >= replay_log_.size())
     Finish(RESULT_OK);
 }
 
 void GDig::OnTimeout() {
   fprintf(stderr, "Timed out waiting to load the dns config\n");
   Finish(RESULT_NO_CONFIG);
 }
 
 }  // empty namespace
 
 }  // namespace net
 
 int main(int argc, const char* argv[]) {
   net::GDig dig;
   return dig.Main(argc, argv);
 }