Clang format slam.

net/url_request/url_request_ftp_job.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/url_request/url_request_ftp_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/auth.h"
@@ skipping 43 matching lines @@
 
 bool URLRequestFtpJob::GetMimeType(std::string* mime_type) const {
   if (proxy_info_.is_direct()) {
     if (ftp_transaction_->GetResponseInfo()->is_directory_listing) {
       *mime_type = "text/vnd.chromium.ftp-dir";
       return true;
     }
   } else {
     // No special handling of MIME type is needed. As opposed to direct FTP
     // transaction, we do not get a raw directory listing to parse.
-    return http_transaction_->GetResponseInfo()->
-        headers->GetMimeType(mime_type);
+    return http_transaction_->GetResponseInfo()->headers->GetMimeType(
+        mime_type);
   }
   return false;
 }
 
 void URLRequestFtpJob::GetResponseInfo(HttpResponseInfo* info) {
   if (http_response_info_)
     *info = *http_response_info_;
 }
 
 HostPortPair URLRequestFtpJob::GetSocketAddress() const {
@@ skipping 49 matching lines @@
 
 void URLRequestFtpJob::OnResolveProxyComplete(int result) {
   pac_request_ = NULL;
 
   if (result != OK) {
     OnStartCompletedAsync(result);
     return;
   }
 
   // Remove unsupported proxies from the list.
-  proxy_info_.RemoveProxiesWithoutScheme(
-      ProxyServer::SCHEME_DIRECT |
-      ProxyServer::SCHEME_HTTP |
-      ProxyServer::SCHEME_HTTPS);
+  proxy_info_.RemoveProxiesWithoutScheme(ProxyServer::SCHEME_DIRECT |
+                                         ProxyServer::SCHEME_HTTP |
+                                         ProxyServer::SCHEME_HTTPS);
 
   // TODO(phajdan.jr): Implement proxy fallback, http://crbug.com/171495 .
   if (proxy_info_.is_direct())
     StartFtpTransaction();
   else if (proxy_info_.is_http() || proxy_info_.is_https())
     StartHttpTransaction();
   else
     OnStartCompletedAsync(ERR_NO_SUPPORTED_PROXIES);
 }
 
 void URLRequestFtpJob::StartFtpTransaction() {
   // Create a transaction.
   DCHECK(!ftp_transaction_);
 
   ftp_request_info_.url = request_->url();
   ftp_transaction_.reset(ftp_transaction_factory_->CreateTransaction());
 
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
   int rv;
   if (ftp_transaction_) {
     rv = ftp_transaction_->Start(
         &ftp_request_info_,
-        base::Bind(&URLRequestFtpJob::OnStartCompleted,
-                   base::Unretained(this)),
+        base::Bind(&URLRequestFtpJob::OnStartCompleted, base::Unretained(this)),
         request_->net_log());
     if (rv == ERR_IO_PENDING)
       return;
   } else {
     rv = ERR_FAILED;
   }
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   OnStartCompletedAsync(rv);
 }
 
 void URLRequestFtpJob::StartHttpTransaction() {
   // Create a transaction.
   DCHECK(!http_transaction_);
 
   // Do not cache FTP responses sent through HTTP proxy.
-  request_->SetLoadFlags(request_->load_flags() |
-                         LOAD_DISABLE_CACHE |
-                         LOAD_DO_NOT_SAVE_COOKIES |
-                         LOAD_DO_NOT_SEND_COOKIES);
+  request_->SetLoadFlags(request_->load_flags() | LOAD_DISABLE_CACHE |
+                         LOAD_DO_NOT_SAVE_COOKIES | LOAD_DO_NOT_SEND_COOKIES);
 
   http_request_info_.url = request_->url();
   http_request_info_.method = request_->method();
   http_request_info_.load_flags = request_->load_flags();
 
   int rv = request_->context()->http_transaction_factory()->CreateTransaction(
       priority_, &http_transaction_);
   if (rv == OK) {
     rv = http_transaction_->Start(
         &http_request_info_,
-        base::Bind(&URLRequestFtpJob::OnStartCompleted,
-                  base::Unretained(this)),
+        base::Bind(&URLRequestFtpJob::OnStartCompleted, base::Unretained(this)),
         request_->net_log());
     if (rv == ERR_IO_PENDING)
       return;
   }
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   OnStartCompletedAsync(rv);
 }
 
 void URLRequestFtpJob::OnStartCompleted(int result) {
@@ skipping 25 matching lines @@
     return;
   } else {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 }
 
 void URLRequestFtpJob::OnStartCompletedAsync(int result) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestFtpJob::OnStartCompleted,
-                 weak_factory_.GetWeakPtr(), result));
+                 weak_factory_.GetWeakPtr(),
+                 result));
 }
 
 void URLRequestFtpJob::OnReadCompleted(int result) {
   read_in_progress_ = false;
   if (result == 0) {
     NotifyDone(URLRequestStatus());
   } else if (result < 0) {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
   } else {
     // Clear the IO_PENDING status
@@ skipping 22 matching lines @@
                    base::Unretained(this)));
   }
   if (rv == ERR_IO_PENDING)
     return;
 
   OnStartCompletedAsync(rv);
 }
 
 LoadState URLRequestFtpJob::GetLoadState() const {
   if (proxy_info_.is_direct()) {
-    return ftp_transaction_ ?
-        ftp_transaction_->GetLoadState() : LOAD_STATE_IDLE;
+    return ftp_transaction_ ? ftp_transaction_->GetLoadState()
+                            : LOAD_STATE_IDLE;
   } else {
-    return http_transaction_ ?
-        http_transaction_->GetLoadState() : LOAD_STATE_IDLE;
+    return http_transaction_ ? http_transaction_->GetLoadState()
+                             : LOAD_STATE_IDLE;
   }
 }
 
 bool URLRequestFtpJob::NeedsAuth() {
   return auth_data_.get() && auth_data_->state == AUTH_STATE_NEED_AUTH;
 }
 
 void URLRequestFtpJob::GetAuthChallengeInfo(
     scoped_refptr<AuthChallengeInfo>* result) {
   DCHECK(NeedsAuth());
@@ skipping 13 matching lines @@
 }
 
 void URLRequestFtpJob::SetAuth(const AuthCredentials& credentials) {
   DCHECK(ftp_transaction_ || http_transaction_);
   DCHECK(NeedsAuth());
 
   auth_data_->state = AUTH_STATE_HAVE_AUTH;
   auth_data_->credentials = credentials;
 
   if (ftp_transaction_) {
-    ftp_auth_cache_->Add(request_->url().GetOrigin(),
-                         auth_data_->credentials);
+    ftp_auth_cache_->Add(request_->url().GetOrigin(), auth_data_->credentials);
   }
 
   RestartTransactionWithAuth();
 }
 
 void URLRequestFtpJob::CancelAuth() {
   DCHECK(ftp_transaction_ || http_transaction_);
   DCHECK(NeedsAuth());
 
   auth_data_->state = AUTH_STATE_CANCELED;
 
   // Once the auth is cancelled, we proceed with the request as though
   // there were no auth.  Schedule this for later so that we don't cause
   // any recursing into the caller as a result of this call.
   OnStartCompletedAsync(OK);
 }
 
 UploadProgress URLRequestFtpJob::GetUploadProgress() const {
   return UploadProgress();
 }
 
 bool URLRequestFtpJob::ReadRawData(IOBuffer* buf,
                                    int buf_size,
-                                   int *bytes_read) {
+                                   int* bytes_read) {
   DCHECK_NE(buf_size, 0);
   DCHECK(bytes_read);
   DCHECK(!read_in_progress_);
 
   int rv;
   if (proxy_info_.is_direct()) {
-    rv = ftp_transaction_->Read(buf, buf_size,
-                                base::Bind(&URLRequestFtpJob::OnReadCompleted,
-                                           base::Unretained(this)));
+    rv = ftp_transaction_->Read(
+        buf,
+        buf_size,
+        base::Bind(&URLRequestFtpJob::OnReadCompleted, base::Unretained(this)));
   } else {
-    rv = http_transaction_->Read(buf, buf_size,
-                                 base::Bind(&URLRequestFtpJob::OnReadCompleted,
-                                            base::Unretained(this)));
+    rv = http_transaction_->Read(
+        buf,
+        buf_size,
+        base::Bind(&URLRequestFtpJob::OnReadCompleted, base::Unretained(this)));
   }
 
   if (rv >= 0) {
     *bytes_read = rv;
     return true;
   }
 
   if (rv == ERR_IO_PENDING) {
     read_in_progress_ = true;
     SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
@@ skipping 25 matching lines @@
   if (cached_auth) {
     // Retry using cached auth data.
     SetAuth(cached_auth->credentials);
   } else {
     // Prompt for a username/password.
     NotifyHeadersComplete();
   }
 }
 
 }  // namespace net