Use AuthCredentials throughout the network stack instead of username/password.

net/url_request/url_request_ftp_job.cc

 // Copyright (c) 2011 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.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/auth.h"
@@ skipping 89 matching lines @@
   // the content size information manually.
   set_expected_content_size(
       transaction_->GetResponseInfo()->expected_content_size);
 
   if (result == OK) {
     NotifyHeadersComplete();
   } else if (transaction_->GetResponseInfo()->needs_auth) {
     GURL origin = request_->url().GetOrigin();
     if (server_auth_ && server_auth_->state == AUTH_STATE_HAVE_AUTH) {
       request_->context()->ftp_auth_cache()->Remove(
-          origin,
-          server_auth_->credentials.username,
-          server_auth_->credentials.password);
+          origin, server_auth_->credentials);
     } else if (!server_auth_) {
       server_auth_ = new AuthData();
     }
     server_auth_->state = AUTH_STATE_NEED_AUTH;
 
     FtpAuthCache::Entry* cached_auth =
         request_->context()->ftp_auth_cache()->Lookup(origin);
 
     if (cached_auth) {
       // Retry using cached auth data.
-      SetAuth(cached_auth->username,
-              cached_auth->password);
+      SetAuth(cached_auth->credentials);
     } else {
       // Prompt for a username/password.
       NotifyHeadersComplete();
     }
   } else {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, 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
     SetStatus(URLRequestStatus());
   }
   NotifyReadComplete(result);
 }
 
 void URLRequestFtpJob::RestartTransactionWithAuth() {
   DCHECK(server_auth_ && server_auth_->state == AUTH_STATE_HAVE_AUTH);
 
   // 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 = transaction_->RestartWithAuth(server_auth_->credentials.username,
-                                         server_auth_->credentials.password,
+  int rv = transaction_->RestartWithAuth(server_auth_->credentials,
                                          &start_callback_);
   if (rv == ERR_IO_PENDING)
     return;
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
       method_factory_.NewRunnableMethod(
           &URLRequestFtpJob::OnStartCompleted, rv));
 }
 
@@ skipping 30 matching lines @@
          (server_auth_->state == AUTH_STATE_NEED_AUTH));
   scoped_refptr<AuthChallengeInfo> auth_info(new AuthChallengeInfo);
   auth_info->is_proxy = false;
   auth_info->challenger = HostPortPair::FromURL(request_->url());
   // scheme and realm are kept empty.
   DCHECK(auth_info->scheme.empty());
   DCHECK(auth_info->realm.empty());
   result->swap(auth_info);
 }
 
-void URLRequestFtpJob::SetAuth(const string16& username,
-                               const string16& password) {
+void URLRequestFtpJob::SetAuth(const AuthCredentials& credentials) {
   DCHECK(NeedsAuth());
   server_auth_->state = AUTH_STATE_HAVE_AUTH;
-  server_auth_->credentials.username = username;
-  server_auth_->credentials.password = password;
+  server_auth_->credentials = credentials;
 
   request_->context()->ftp_auth_cache()->Add(request_->url().GetOrigin(),
-                                             username, password);
+                                             server_auth_->credentials);
 
   RestartTransactionWithAuth();
 }
 
 void URLRequestFtpJob::CancelAuth() {
   DCHECK(NeedsAuth());
   server_auth_->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
@@ skipping 24 matching lines @@
   if (rv == ERR_IO_PENDING) {
     read_in_progress_ = true;
     SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
   } else {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
   }
   return false;
 }
 
 }  // namespace net