Clang format slam.

net/proxy/dhcp_proxy_script_adapter_fetcher_win.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/proxy/dhcp_proxy_script_adapter_fetcher_win.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 28 matching lines @@
       state_(STATE_START),
       result_(ERR_IO_PENDING),
       url_request_context_(url_request_context) {
   DCHECK(url_request_context_);
 }
 
 DhcpProxyScriptAdapterFetcher::~DhcpProxyScriptAdapterFetcher() {
   Cancel();
 }
 
-void DhcpProxyScriptAdapterFetcher::Fetch(
-    const std::string& adapter_name, const CompletionCallback& callback) {
+void DhcpProxyScriptAdapterFetcher::Fetch(const std::string& adapter_name,
+                                          const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state_, STATE_START);
   result_ = ERR_IO_PENDING;
   pac_script_ = base::string16();
   state_ = STATE_WAIT_DHCP;
   callback_ = callback;
 
-  wait_timer_.Start(FROM_HERE, ImplGetTimeout(),
-                    this, &DhcpProxyScriptAdapterFetcher::OnTimeout);
+  wait_timer_.Start(FROM_HERE,
+                    ImplGetTimeout(),
+                    this,
+                    &DhcpProxyScriptAdapterFetcher::OnTimeout);
   scoped_refptr<DhcpQuery> dhcp_query(ImplCreateDhcpQuery());
   task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(
-          &DhcpProxyScriptAdapterFetcher::DhcpQuery::GetPacURLForAdapter,
-          dhcp_query.get(),
-          adapter_name),
-      base::Bind(
-          &DhcpProxyScriptAdapterFetcher::OnDhcpQueryDone,
-          AsWeakPtr(),
-          dhcp_query));
+      base::Bind(&DhcpProxyScriptAdapterFetcher::DhcpQuery::GetPacURLForAdapter,
+                 dhcp_query.get(),
+                 adapter_name),
+      base::Bind(&DhcpProxyScriptAdapterFetcher::OnDhcpQueryDone,
+                 AsWeakPtr(),
+                 dhcp_query));
 }
 
 void DhcpProxyScriptAdapterFetcher::Cancel() {
   DCHECK(CalledOnValidThread());
   callback_.Reset();
   wait_timer_.Stop();
   script_fetcher_.reset();
 
   switch (state_) {
     case STATE_WAIT_DHCP:
@@ skipping 42 matching lines @@
 
 void DhcpProxyScriptAdapterFetcher::DhcpQuery::GetPacURLForAdapter(
     const std::string& adapter_name) {
   url_ = ImplGetPacURLFromDhcp(adapter_name);
 }
 
 const std::string& DhcpProxyScriptAdapterFetcher::DhcpQuery::url() const {
   return url_;
 }
 
-std::string
-    DhcpProxyScriptAdapterFetcher::DhcpQuery::ImplGetPacURLFromDhcp(
-        const std::string& adapter_name) {
+std::string DhcpProxyScriptAdapterFetcher::DhcpQuery::ImplGetPacURLFromDhcp(
+    const std::string& adapter_name) {
   return DhcpProxyScriptAdapterFetcher::GetPacURLFromDhcp(adapter_name);
 }
 
 void DhcpProxyScriptAdapterFetcher::OnDhcpQueryDone(
     scoped_refptr<DhcpQuery> dhcp_query) {
   DCHECK(CalledOnValidThread());
   // Because we can't cancel the call to the Win32 API, we can expect
   // it to finish while we are in a few different states.  The expected
   // one is WAIT_DHCP, but it could be in CANCEL if Cancel() was called,
   // or FINISH if timeout occurred.
   DCHECK(state_ == STATE_WAIT_DHCP || state_ == STATE_CANCEL ||
          state_ == STATE_FINISH);
   if (state_ != STATE_WAIT_DHCP)
     return;
 
   wait_timer_.Stop();
 
   pac_url_ = GURL(dhcp_query->url());
   if (pac_url_.is_empty() || !pac_url_.is_valid()) {
     result_ = ERR_PAC_NOT_IN_DHCP;
     TransitionToFinish();
   } else {
     state_ = STATE_WAIT_URL;
     script_fetcher_.reset(ImplCreateScriptFetcher());
     script_fetcher_->Fetch(
-        pac_url_, &pac_script_,
+        pac_url_,
+        &pac_script_,
         base::Bind(&DhcpProxyScriptAdapterFetcher::OnFetcherDone,
                    base::Unretained(this)));
   }
 }
 
 void DhcpProxyScriptAdapterFetcher::OnTimeout() {
   DCHECK_EQ(state_, STATE_WAIT_DHCP);
   result_ = ERR_TIMED_OUT;
   TransitionToFinish();
 }
@@ skipping 14 matching lines @@
   DCHECK(state_ == STATE_WAIT_DHCP || state_ == STATE_WAIT_URL);
   state_ = STATE_FINISH;
   CompletionCallback callback = callback_;
   callback_.Reset();
 
   // Be careful not to touch any member state after this, as the client
   // may delete us during this callback.
   callback.Run(result_);
 }
 
-DhcpProxyScriptAdapterFetcher::State
-    DhcpProxyScriptAdapterFetcher::state() const {
+DhcpProxyScriptAdapterFetcher::State DhcpProxyScriptAdapterFetcher::state()
+    const {
   return state_;
 }
 
 ProxyScriptFetcher* DhcpProxyScriptAdapterFetcher::ImplCreateScriptFetcher() {
   return new ProxyScriptFetcherImpl(url_request_context_);
 }
 
 DhcpProxyScriptAdapterFetcher::DhcpQuery*
-    DhcpProxyScriptAdapterFetcher::ImplCreateDhcpQuery() {
+DhcpProxyScriptAdapterFetcher::ImplCreateDhcpQuery() {
   return new DhcpQuery();
 }
 
 base::TimeDelta DhcpProxyScriptAdapterFetcher::ImplGetTimeout() const {
   return base::TimeDelta::FromMilliseconds(kTimeoutMs);
 }
 
 // static
 std::string DhcpProxyScriptAdapterFetcher::GetPacURLFromDhcp(
     const std::string& adapter_name) {
   EnsureDhcpcsvcInit();
 
-  std::wstring adapter_name_wide = base::SysMultiByteToWide(adapter_name,
-                                                            CP_ACP);
+  std::wstring adapter_name_wide =
+      base::SysMultiByteToWide(adapter_name, CP_ACP);
 
-  DHCPCAPI_PARAMS_ARRAY send_params = { 0, NULL };
+  DHCPCAPI_PARAMS_ARRAY send_params = {0, NULL};
 
-  BYTE option_data[] = { 1, 252 };
-  DHCPCAPI_PARAMS wpad_params = { 0 };
+  BYTE option_data[] = {1, 252};
+  DHCPCAPI_PARAMS wpad_params = {0};
   wpad_params.OptionId = 252;
   wpad_params.IsVendor = FALSE;  // Surprising, but intentional.
 
-  DHCPCAPI_PARAMS_ARRAY request_params = { 0 };
+  DHCPCAPI_PARAMS_ARRAY request_params = {0};
   request_params.nParams = 1;
   request_params.Params = &wpad_params;
 
   // The maximum message size is typically 4096 bytes on Windows per
   // http://support.microsoft.com/kb/321592
   DWORD result_buffer_size = 4096;
   scoped_ptr<BYTE, base::FreeDeleter> result_buffer;
   int retry_count = 0;
   DWORD res = NO_ERROR;
   do {
     result_buffer.reset(static_cast<BYTE*>(malloc(result_buffer_size)));
 
     // Note that while the DHCPCAPI_REQUEST_SYNCHRONOUS flag seems to indicate
     // there might be an asynchronous mode, there seems to be (at least in
     // terms of well-documented use of this API) only a synchronous mode, with
     // an optional "async notifications later if the option changes" mode.
     // Even IE9, which we hope to emulate as IE is the most widely deployed
     // previous implementation of the DHCP aspect of WPAD and the only one
     // on Windows (Konqueror is the other, on Linux), uses this API with the
     // synchronous flag.  There seem to be several Microsoft Knowledge Base
     // articles about calls to this function failing when other flags are used
     // (e.g. http://support.microsoft.com/kb/885270) so we won't take any
     // chances on non-standard, poorly documented usage.
     res = ::DhcpRequestParams(DHCPCAPI_REQUEST_SYNCHRONOUS,
                               NULL,
                               const_cast<LPWSTR>(adapter_name_wide.c_str()),
                               NULL,
-                              send_params, request_params,
-                              result_buffer.get(), &result_buffer_size,
+                              send_params,
+                              request_params,
+                              result_buffer.get(),
+                              &result_buffer_size,
                               NULL);
     ++retry_count;
   } while (res == ERROR_MORE_DATA && retry_count <= 3);
 
   if (res != NO_ERROR) {
     LOG(WARNING) << "Error fetching PAC URL from DHCP: " << res;
     UMA_HISTOGRAM_COUNTS("Net.DhcpWpadUnhandledDhcpError", 1);
   } else if (wpad_params.nBytesData) {
     return SanitizeDhcpApiString(
         reinterpret_cast<const char*>(wpad_params.Data),
         wpad_params.nBytesData);
   }
 
   return "";
 }
 
 // static
 std::string DhcpProxyScriptAdapterFetcher::SanitizeDhcpApiString(
-    const char* data, size_t count_bytes) {
+    const char* data,
+    size_t count_bytes) {
   // The result should be ASCII, not wide character.  Some DHCP
   // servers appear to count the trailing NULL in nBytesData, others
   // do not.  A few (we've had one report, http://crbug.com/297810)
   // do not NULL-terminate but may \n-terminate.
   //
   // Belt and suspenders and elastic waistband: First, ensure we
   // NULL-terminate after nBytesData; this is the inner constructor
   // with nBytesData as a parameter.  Then, return only up to the
   // first null in case of embedded NULLs; this is the outer
   // constructor that takes the result of c_str() on the inner.  If
   // the server is giving us back a buffer with embedded NULLs,
   // something is broken anyway.  Finally, trim trailing whitespace.
   std::string result(std::string(data, count_bytes).c_str());
   base::TrimWhitespaceASCII(result, base::TRIM_TRAILING, &result);
   return result;
 }
 
 }  // namespace net