Clang format slam.

net/proxy/proxy_script_fetcher_impl.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/proxy_script_fetcher_impl.h"
 
 #include "base/compiler_specific.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 17 matching lines @@
 // The maximum size (in bytes) allowed for a PAC script. Responses exceeding
 // this will fail with ERR_FILE_TOO_BIG.
 const int kDefaultMaxResponseBytes = 1048576;  // 1 megabyte
 
 // The maximum duration (in milliseconds) allowed for fetching the PAC script.
 // Responses exceeding this will fail with ERR_TIMED_OUT.
 const int kDefaultMaxDurationMs = 300000;  // 5 minutes
 
 // Returns true if |mime_type| is one of the known PAC mime type.
 bool IsPacMimeType(const std::string& mime_type) {
-  static const char * const kSupportedPacMimeTypes[] = {
-    "application/x-ns-proxy-autoconfig",
-    "application/x-javascript-config",
+  static const char* const kSupportedPacMimeTypes[] = {
+      "application/x-ns-proxy-autoconfig", "application/x-javascript-config",
   };
   for (size_t i = 0; i < arraysize(kSupportedPacMimeTypes); ++i) {
     if (LowerCaseEqualsASCII(mime_type, kSupportedPacMimeTypes[i]))
       return true;
   }
   return false;
 }
 
 // Converts |bytes| (which is encoded by |charset|) to UTF16, saving the resul
 // to |*utf16|.
 // If |charset| is empty, then we don't know what it was and guess.
 void ConvertResponseToUTF16(const std::string& charset,
                             const std::string& bytes,
                             base::string16* utf16) {
   const char* codepage;
 
   if (charset.empty()) {
     // Assume ISO-8859-1 if no charset was specified.
     codepage = base::kCodepageLatin1;
   } else {
     // Otherwise trust the charset that was provided.
     codepage = charset.c_str();
   }
 
   // We will be generous in the conversion -- if any characters lie
   // outside of |charset| (i.e. invalid), then substitute them with
   // U+FFFD rather than failing.
-  base::CodepageToUTF16(bytes, codepage,
-                        base::OnStringConversionError::SUBSTITUTE,
-                        utf16);
+  base::CodepageToUTF16(
+      bytes, codepage, base::OnStringConversionError::SUBSTITUTE, utf16);
 }
 
 }  // namespace
 
 ProxyScriptFetcherImpl::ProxyScriptFetcherImpl(
     URLRequestContext* url_request_context)
     : weak_factory_(this),
       url_request_context_(url_request_context),
       buf_(new IOBuffer(kBufSize)),
       next_id_(0),
@@ skipping 27 matching lines @@
   DCHECK_EQ(request, cur_request_.get());
 
   // Use |result_code_| as the request's error if we have already set it to
   // something specific.
   if (result_code_ == OK && !request->status().is_success())
     result_code_ = request->status().error();
 
   FetchCompleted();
 }
 
-int ProxyScriptFetcherImpl::Fetch(
-    const GURL& url, base::string16* text, const CompletionCallback& callback) {
+int ProxyScriptFetcherImpl::Fetch(const GURL& url,
+                                  base::string16* text,
+                                  const CompletionCallback& callback) {
   // It is invalid to call Fetch() while a request is already in progress.
   DCHECK(!cur_request_.get());
   DCHECK(!callback.is_null());
   DCHECK(text);
 
   // Handle base-64 encoded data-urls that contain custom PAC scripts.
   if (url.SchemeIs("data")) {
     std::string mime_type;
     std::string charset;
     std::string data;
@@ skipping 184 matching lines @@
   // is still applicable.
   if (cur_request_id_ != id)
     return;
 
   DCHECK(cur_request_.get());
   result_code_ = ERR_TIMED_OUT;
   cur_request_->Cancel();
 }
 
 }  // namespace net