Clang format slam.

net/proxy/proxy_resolver_v8_tracing.cc

 // Copyright (c) 2013 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/proxy/proxy_resolver_v8_tracing.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
@@ skipping 127 matching lines @@
   HostResolver* host_resolver();
   ProxyResolverErrorObserver* error_observer();
   NetLog* net_log();
 
   // Invokes the user's callback.
   void NotifyCaller(int result);
   void NotifyCallerOnOriginLoop(int result);
 
   void RecordMetrics() const;
 
-  void Start(Operation op, bool blocking_dns,
+  void Start(Operation op,
+             bool blocking_dns,
              const CompletionCallback& callback);
 
   void ExecuteBlocking();
   void ExecuteNonBlocking();
   int ExecuteProxyResolver();
 
   // Implementation of ProxyResolverv8::JSBindings
   virtual bool ResolveDns(const std::string& host,
                           ResolveDnsOperation op,
                           std::string* output,
                           bool* terminate) OVERRIDE;
   virtual void Alert(const base::string16& message) OVERRIDE;
   virtual void OnError(int line_number, const base::string16& error) OVERRIDE;
 
   bool ResolveDnsBlocking(const std::string& host,
                           ResolveDnsOperation op,
                           std::string* output);
 
   bool ResolveDnsNonBlocking(const std::string& host,
                              ResolveDnsOperation op,
                              std::string* output,
                              bool* terminate);
 
   bool PostDnsOperationAndWait(const std::string& host,
                                ResolveDnsOperation op,
                                bool* completed_synchronously)
-                               WARN_UNUSED_RESULT;
+      WARN_UNUSED_RESULT;
 
   void DoDnsOperation();
   void OnDnsOperationComplete(int result);
 
   void ScheduleRestartWithBlockingDns();
 
-  bool GetDnsFromLocalCache(const std::string& host, ResolveDnsOperation op,
-                            std::string* output, bool* return_value);
+  bool GetDnsFromLocalCache(const std::string& host,
+                            ResolveDnsOperation op,
+                            std::string* output,
+                            bool* return_value);
 
-  void SaveDnsToLocalCache(const std::string& host, ResolveDnsOperation op,
-                           int net_error, const net::AddressList& addresses);
+  void SaveDnsToLocalCache(const std::string& host,
+                           ResolveDnsOperation op,
+                           int net_error,
+                           const net::AddressList& addresses);
 
   // Builds a RequestInfo to service the specified PAC DNS operation.
   static HostResolver::RequestInfo MakeDnsRequestInfo(const std::string& host,
                                                       ResolveDnsOperation op);
 
   // Makes a key for looking up |host, op| in |dns_cache_|. Strings are used for
   // convenience, to avoid defining custom comparators.
   static std::string MakeDnsCacheKey(const std::string& host,
                                      ResolveDnsOperation op);
 
-  void HandleAlertOrError(bool is_alert, int line_number,
+  void HandleAlertOrError(bool is_alert,
+                          int line_number,
                           const base::string16& message);
   void DispatchBufferedAlertsAndErrors();
-  void DispatchAlertOrError(bool is_alert, int line_number,
+  void DispatchAlertOrError(bool is_alert,
+                            int line_number,
                             const base::string16& message);
 
   void LogEventToCurrentRequestAndGlobally(
       NetLog::EventType type,
       const NetLog::ParametersCallback& parameters_callback);
 
   // The thread which called into ProxyResolverV8Tracing, and on which the
   // completion callback is expected to run.
   scoped_refptr<base::MessageLoopProxy> origin_loop_;
 
@@ skipping 275 matching lines @@
 NetLog* ProxyResolverV8Tracing::Job::net_log() {
   return parent_->net_log_;
 }
 
 void ProxyResolverV8Tracing::Job::NotifyCaller(int result) {
   CheckIsOnWorkerThread();
 
   metrics_end_time_ = base::TimeTicks::Now();
 
   origin_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&Job::NotifyCallerOnOriginLoop, this, result));
+      FROM_HERE, base::Bind(&Job::NotifyCallerOnOriginLoop, this, result));
 }
 
 void ProxyResolverV8Tracing::Job::NotifyCallerOnOriginLoop(int result) {
   CheckIsOnOriginThread();
 
   if (cancelled_.IsSet())
     return;
 
   DCHECK(!callback_.is_null());
   DCHECK(!pending_dns_);
@@ skipping 16 matching lines @@
 
   owned_self_reference_ = NULL;
 }
 
 void ProxyResolverV8Tracing::Job::RecordMetrics() const {
   CheckIsOnOriginThread();
   DCHECK_EQ(GET_PROXY_FOR_URL, operation_);
 
   base::TimeTicks now = base::TimeTicks::Now();
 
-  // Metrics are output for each completed request to GetProxyForURL()).
-  //
-  // Note that a different set of histograms is used to record the metrics for
-  // requests that completed in non-blocking mode versus blocking mode. The
-  // expectation is for requests to complete in non-blocking mode each time.
-  // If they don't then something strange is happening, and the purpose of the
-  // seprate statistics is to better understand that trend.
-#define UPDATE_HISTOGRAMS(base_name) \
-  do {\
-  UMA_HISTOGRAM_MEDIUM_TIMES(base_name "TotalTime", now - metrics_start_time_);\
-  UMA_HISTOGRAM_MEDIUM_TIMES(base_name "TotalTimeWorkerThread",\
-                             metrics_end_time_ - metrics_start_time_);\
-  UMA_HISTOGRAM_TIMES(base_name "OriginThreadLatency",\
-                      now - metrics_end_time_);\
-  UMA_HISTOGRAM_MEDIUM_TIMES(base_name "TotalTimeDNS",\
-                             metrics_dns_total_time_);\
-  UMA_HISTOGRAM_MEDIUM_TIMES(base_name "ExecutionTime",\
-                             metrics_execution_time_);\
-  UMA_HISTOGRAM_MEDIUM_TIMES(base_name "AbandonedExecutionTotalTime",\
-                             metrics_abandoned_execution_total_time_);\
-  UMA_HISTOGRAM_MEDIUM_TIMES(base_name "DnsWaitTotalTime",\
-                             metrics_nonblocking_dns_wait_total_time_);\
-  UMA_HISTOGRAM_CUSTOM_COUNTS(\
-      base_name "NumRestarts", metrics_num_executions_ - 1,\
-      1, kMaxUniqueResolveDnsPerExec, kMaxUniqueResolveDnsPerExec);\
-  UMA_HISTOGRAM_CUSTOM_COUNTS(\
-      base_name "UniqueDNS", metrics_num_unique_dns_,\
-      1, kMaxUniqueResolveDnsPerExec, kMaxUniqueResolveDnsPerExec);\
-  UMA_HISTOGRAM_COUNTS_100(base_name "NumAlerts", metrics_num_alerts_);\
-  UMA_HISTOGRAM_CUSTOM_COUNTS(\
-      base_name "NumErrors", metrics_num_errors_, 1, 10, 10);\
+// Metrics are output for each completed request to GetProxyForURL()).
+//
+// Note that a different set of histograms is used to record the metrics for
+// requests that completed in non-blocking mode versus blocking mode. The
+// expectation is for requests to complete in non-blocking mode each time.
+// If they don't then something strange is happening, and the purpose of the
+// seprate statistics is to better understand that trend.
+#define UPDATE_HISTOGRAMS(base_name)                                      \
+  do {                                                                    \
+    UMA_HISTOGRAM_MEDIUM_TIMES(base_name "TotalTime",                     \
+                               now - metrics_start_time_);                \
+    UMA_HISTOGRAM_MEDIUM_TIMES(base_name "TotalTimeWorkerThread",         \
+                               metrics_end_time_ - metrics_start_time_);  \
+    UMA_HISTOGRAM_TIMES(base_name "OriginThreadLatency",                  \
+                        now - metrics_end_time_);                         \
+    UMA_HISTOGRAM_MEDIUM_TIMES(base_name "TotalTimeDNS",                  \
+                               metrics_dns_total_time_);                  \
+    UMA_HISTOGRAM_MEDIUM_TIMES(base_name "ExecutionTime",                 \
+                               metrics_execution_time_);                  \
+    UMA_HISTOGRAM_MEDIUM_TIMES(base_name "AbandonedExecutionTotalTime",   \
+                               metrics_abandoned_execution_total_time_);  \
+    UMA_HISTOGRAM_MEDIUM_TIMES(base_name "DnsWaitTotalTime",              \
+                               metrics_nonblocking_dns_wait_total_time_); \
+    UMA_HISTOGRAM_CUSTOM_COUNTS(base_name "NumRestarts",                  \
+                                metrics_num_executions_ - 1,              \
+                                1,                                        \
+                                kMaxUniqueResolveDnsPerExec,              \
+                                kMaxUniqueResolveDnsPerExec);             \
+    UMA_HISTOGRAM_CUSTOM_COUNTS(base_name "UniqueDNS",                    \
+                                metrics_num_unique_dns_,                  \
+                                1,                                        \
+                                kMaxUniqueResolveDnsPerExec,              \
+                                kMaxUniqueResolveDnsPerExec);             \
+    UMA_HISTOGRAM_COUNTS_100(base_name "NumAlerts", metrics_num_alerts_); \
+    UMA_HISTOGRAM_CUSTOM_COUNTS(                                          \
+        base_name "NumErrors", metrics_num_errors_, 1, 10, 10);           \
   } while (false)
 
   if (!blocking_dns_)
     UPDATE_HISTOGRAMS("Net.ProxyResolver.");
   else
     UPDATE_HISTOGRAMS("Net.ProxyResolver.BlockingDNSMode.");
 
 #undef UPDATE_HISTOGRAMS
 
   // Histograms to better understand http://crbug.com/240536 -- long
@@ skipping 20 matching lines @@
                                  metrics_execution_time_);
     }
 
     if (url_size > 131072) {
       UMA_HISTOGRAM_MEDIUM_TIMES("Net.ProxyResolver.ExecutionTime_UrlOver128K",
                                  metrics_execution_time_);
     }
   }
 }
 
-
-void ProxyResolverV8Tracing::Job::Start(Operation op, bool blocking_dns,
+void ProxyResolverV8Tracing::Job::Start(Operation op,
+                                        bool blocking_dns,
                                         const CompletionCallback& callback) {
   CheckIsOnOriginThread();
 
   metrics_start_time_ = base::TimeTicks::Now();
   operation_ = op;
   blocking_dns_ = blocking_dns;
   SetCallback(callback);
 
   owned_self_reference_ = this;
 
   worker_loop()->PostTask(FROM_HERE,
-      blocking_dns_ ? base::Bind(&Job::ExecuteBlocking, this) :
-                      base::Bind(&Job::ExecuteNonBlocking, this));
+                          blocking_dns_
+                              ? base::Bind(&Job::ExecuteBlocking, this)
+                              : base::Bind(&Job::ExecuteNonBlocking, this));
 }
 
 void ProxyResolverV8Tracing::Job::ExecuteBlocking() {
   CheckIsOnWorkerThread();
   DCHECK(blocking_dns_);
 
   if (cancelled_.IsSet())
     return;
 
   NotifyCaller(ExecuteProxyResolver());
@@ skipping 38 matching lines @@
 
   base::TimeTicks start = base::TimeTicks::Now();
 
   JSBindings* prev_bindings = v8_resolver()->js_bindings();
   v8_resolver()->set_js_bindings(this);
 
   int result = ERR_UNEXPECTED;  // Initialized to silence warnings.
 
   switch (operation_) {
     case SET_PAC_SCRIPT:
-      result = v8_resolver()->SetPacScript(
-          script_data_, CompletionCallback());
+      result = v8_resolver()->SetPacScript(script_data_, CompletionCallback());
       break;
     case GET_PROXY_FOR_URL:
       result = v8_resolver()->GetProxyForURL(
-        url_,
-        // Important: Do not write directly into |user_results_|, since if the
-        // request were to be cancelled from the origin thread, must guarantee
-        // that |user_results_| is not accessed anymore.
-        &results_,
-        CompletionCallback(),
-        NULL,
-        bound_net_log_);
+          url_,
+          // Important: Do not write directly into |user_results_|, since if the
+          // request were to be cancelled from the origin thread, must guarantee
+          // that |user_results_| is not accessed anymore.
+          &results_,
+          CompletionCallback(),
+          NULL,
+          bound_net_log_);
       break;
   }
 
   v8_resolver()->set_js_bindings(prev_bindings);
 
   metrics_execution_time_ = base::TimeTicks::Now() - start;
 
   return result;
 }
 
 bool ProxyResolverV8Tracing::Job::ResolveDns(const std::string& host,
                                              ResolveDnsOperation op,
                                              std::string* output,
                                              bool* terminate) {
   if (cancelled_.IsSet()) {
     *terminate = true;
     return false;
   }
 
   if ((op == DNS_RESOLVE || op == DNS_RESOLVE_EX) && host.empty()) {
     // a DNS resolve with an empty hostname is considered an error.
     return false;
   }
 
-  return blocking_dns_ ?
-      ResolveDnsBlocking(host, op, output) :
-      ResolveDnsNonBlocking(host, op, output, terminate);
+  return blocking_dns_ ? ResolveDnsBlocking(host, op, output)
+                       : ResolveDnsNonBlocking(host, op, output, terminate);
 }
 
 void ProxyResolverV8Tracing::Job::Alert(const base::string16& message) {
   HandleAlertOrError(true, -1, message);
 }
 
 void ProxyResolverV8Tracing::Job::OnError(int line_number,
                                           const base::string16& error) {
   HandleAlertOrError(false, line_number, error);
 }
@@ skipping 77 matching lines @@
   // Otherwise if the result was not in the cache, then a DNS request has
   // been started. Abandon this invocation of FindProxyForURL(), it will be
   // restarted once the DNS request completes.
   abandoned_ = true;
   *terminate = true;
   last_num_dns_ = num_dns_;
   return false;
 }
 
 bool ProxyResolverV8Tracing::Job::PostDnsOperationAndWait(
-    const std::string& host, ResolveDnsOperation op,
+    const std::string& host,
+    ResolveDnsOperation op,
     bool* completed_synchronously) {
-
   base::TimeTicks start = base::TimeTicks::Now();
 
   // Post the DNS request to the origin thread.
   DCHECK(!pending_dns_);
   metrics_pending_dns_start_ = base::TimeTicks::Now();
   pending_dns_host_ = host;
   pending_dns_op_ = op;
   origin_loop_->PostTask(FROM_HERE, base::Bind(&Job::DoDnsOperation, this));
 
   event_.Wait();
@@ skipping 52 matching lines @@
     event_.Signal();
   }
 }
 
 void ProxyResolverV8Tracing::Job::OnDnsOperationComplete(int result) {
   CheckIsOnOriginThread();
 
   DCHECK(!cancelled_.IsSet());
   DCHECK(pending_dns_completed_synchronously_ == (pending_dns_ == NULL));
 
-  SaveDnsToLocalCache(pending_dns_host_, pending_dns_op_, result,
-                      pending_dns_addresses_);
+  SaveDnsToLocalCache(
+      pending_dns_host_, pending_dns_op_, result, pending_dns_addresses_);
   pending_dns_ = NULL;
 
   metrics_dns_total_time_ +=
       base::TimeTicks::Now() - metrics_pending_dns_start_;
 
   if (blocking_dns_) {
     event_.Signal();
     return;
   }
 
@@ skipping 11 matching lines @@
   DCHECK(!should_restart_with_blocking_dns_);
   DCHECK(!abandoned_);
   DCHECK(!blocking_dns_);
 
   abandoned_ = true;
 
   // The restart will happen after ExecuteNonBlocking() finishes.
   should_restart_with_blocking_dns_ = true;
 }
 
-bool ProxyResolverV8Tracing::Job::GetDnsFromLocalCache(
-    const std::string& host,
-    ResolveDnsOperation op,
-    std::string* output,
-    bool* return_value) {
+bool ProxyResolverV8Tracing::Job::GetDnsFromLocalCache(const std::string& host,
+                                                       ResolveDnsOperation op,
+                                                       std::string* output,
+                                                       bool* return_value) {
   CheckIsOnWorkerThread();
 
   DnsCache::const_iterator it = dns_cache_.find(MakeDnsCacheKey(host, op));
   if (it == dns_cache_.end())
     return false;
 
   *output = it->second;
   *return_value = !it->second.empty();
   return true;
 }
 
 void ProxyResolverV8Tracing::Job::SaveDnsToLocalCache(
     const std::string& host,
     ResolveDnsOperation op,
     int net_error,
     const net::AddressList& addresses) {
   CheckIsOnOriginThread();
 
   // Serialize the result into a string to save to the cache.
   std::string cache_value;
   if (net_error != OK) {
     cache_value = std::string();
   } else if (op == DNS_RESOLVE || op == MY_IP_ADDRESS) {
     // dnsResolve() and myIpAddress() are expected to return a single IP
     // address.
     cache_value = addresses.front().ToStringWithoutPort();
   } else {
     // The *Ex versions are expected to return a semi-colon separated list.
     for (AddressList::const_iterator iter = addresses.begin();
-         iter != addresses.end(); ++iter) {
+         iter != addresses.end();
+         ++iter) {
       if (!cache_value.empty())
         cache_value += ";";
       cache_value += iter->ToStringWithoutPort();
     }
   }
 
   dns_cache_[MakeDnsCacheKey(host, op)] = cache_value;
 }
 
 // static
 HostResolver::RequestInfo ProxyResolverV8Tracing::Job::MakeDnsRequestInfo(
-    const std::string& host, ResolveDnsOperation op) {
+    const std::string& host,
+    ResolveDnsOperation op) {
   HostPortPair host_port = HostPortPair(host, 80);
   if (op == MY_IP_ADDRESS || op == MY_IP_ADDRESS_EX) {
     host_port.set_host(GetHostName());
   }
 
   HostResolver::RequestInfo info(host_port);
 
   // The non-ex flavors are limited to IPv4 results.
   if (op == MY_IP_ADDRESS || op == DNS_RESOLVE) {
     info.set_address_family(ADDRESS_FAMILY_IPV4);
   }
 
   return info;
 }
 
 std::string ProxyResolverV8Tracing::Job::MakeDnsCacheKey(
-    const std::string& host, ResolveDnsOperation op) {
+    const std::string& host,
+    ResolveDnsOperation op) {
   return base::StringPrintf("%d:%s", op, host.c_str());
 }
 
 void ProxyResolverV8Tracing::Job::HandleAlertOrError(
     bool is_alert,
     int line_number,
     const base::string16& message) {
   CheckIsOnWorkerThread();
 
   if (cancelled_.IsSet())
@@ skipping 30 matching lines @@
   DCHECK(!blocking_dns_);
   DCHECK(!abandoned_);
 
   for (size_t i = 0; i < alerts_and_errors_.size(); ++i) {
     const AlertOrError& x = alerts_and_errors_[i];
     DispatchAlertOrError(x.is_alert, x.line_number, x.message);
   }
 }
 
 void ProxyResolverV8Tracing::Job::DispatchAlertOrError(
-    bool is_alert, int line_number, const base::string16& message) {
+    bool is_alert,
+    int line_number,
+    const base::string16& message) {
   CheckIsOnWorkerThread();
 
   // Note that the handling of cancellation is racy with regard to
   // alerts/errors. The request might get cancelled shortly after this
   // check! (There is no lock being held to guarantee otherwise).
   //
   // If this happens, then some information will get written to the NetLog
   // needlessly, however the NetLog will still be alive so it shouldn't cause
   // problems.
   if (cancelled_.IsSet())
@@ skipping 11 matching lines @@
         NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
         NetLog::StringCallback("message", &message));
   } else {
     // -------------------
     // error
     // -------------------
     IncrementWithoutOverflow(&metrics_num_errors_);
     if (line_number == -1)
       VLOG(1) << "PAC-error: " << message;
     else
-      VLOG(1) << "PAC-error: " << "line: " << line_number << ": " << message;
+      VLOG(1) << "PAC-error: "
+              << "line: " << line_number << ": " << message;
 
     // Send the error to the NetLog.
     LogEventToCurrentRequestAndGlobally(
         NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
         base::Bind(&NetLogErrorCallback, line_number, &message));
 
     if (error_observer())
       error_observer()->OnPACScriptError(line_number, message);
   }
 }
@@ skipping 84 matching lines @@
   DCHECK(!set_pac_script_job_.get());
   CHECK_EQ(0, num_outstanding_callbacks_);
 
   set_pac_script_job_ = new Job(this);
   set_pac_script_job_->StartSetPacScript(script_data, callback);
 
   return ERR_IO_PENDING;
 }
 
 }  // namespace net