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

net/url_request/url_request_http_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_http_job.h"
 
 #include "base/bind.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 264 matching lines @@
 
   // The HTTP transaction may be restarted several times for the purposes
   // of sending authorization information. Each time it restarts, we get
   // notified of the headers completion so that we can update the cookie store.
   if (transaction_->IsReadyToRestartForAuth()) {
     DCHECK(!response_info_->auth_challenge.get());
     // TODO(battre): This breaks the webrequest API for
     // URLRequestTestHTTP.BasicAuthWithCookies
     // where OnBeforeSendHeaders -> OnSendHeaders -> OnBeforeSendHeaders
     // occurs.
-    RestartTransactionWithAuth(string16(), string16());
+    RestartTransactionWithAuth(AuthCredentials());
     return;
   }
 
   URLRequestJob::NotifyHeadersComplete();
 }
 
 void URLRequestHttpJob::NotifyDone(const URLRequestStatus& status) {
   DoneWithRequest(FINISHED);
   URLRequestJob::NotifyDone(status);
 }
@@ skipping 31 matching lines @@
     request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
         make_scoped_refptr(new NetLogStringParameter("source", "delegate")));
     NotifyCanceled();
   }
 }
 
 void URLRequestHttpJob::StartTransactionInternal() {
   // NOTE: This method assumes that request_info_ is already setup properly.
 
   // If we already have a transaction, then we should restart the transaction
-  // with auth provided by username_ and password_.
+  // with auth provided by auth_credentials_.
 
   int rv;
 
   if (request_->context() && request_->context()->network_delegate()) {
     request_->context()->network_delegate()->NotifySendHeaders(
         request_, request_info_.extra_headers);
   }
 
   if (transaction_.get()) {
-    rv = transaction_->RestartWithAuth(username_, password_, &start_callback_);
-    username_.clear();
-    password_.clear();
+    rv = transaction_->RestartWithAuth(auth_credentials_, &start_callback_);
+    auth_credentials_ = AuthCredentials();
   } else {
     DCHECK(request_->context());
     DCHECK(request_->context()->http_transaction_factory());
 
     rv = request_->context()->http_transaction_factory()->CreateTransaction(
         &transaction_);
     if (rv == OK) {
       if (!URLRequestThrottlerManager::GetInstance()->enforce_throttling() ||
           !throttling_entry_->ShouldRejectRequest(request_info_.load_flags)) {
         rv = transaction_->Start(
@@ skipping 398 matching lines @@
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
   } else {
     // Clear the IO_PENDING status
     SetStatus(URLRequestStatus());
   }
 
   NotifyReadComplete(result);
 }
 
 void URLRequestHttpJob::RestartTransactionWithAuth(
-    const string16& username,
-    const string16& password) {
-  username_ = username;
-  password_ = password;
+    const AuthCredentials& credentials) {
+  auth_credentials_ = credentials;
 
   // These will be reset in OnStartCompleted.
   response_info_ = NULL;
   response_cookies_.clear();
 
   ResetTimer();
 
   // Update the cookies, since the cookie store may have been updated from the
   // headers in the 401/407. Since cookies were already appended to
   // extra_headers, we need to strip them out before adding them again.
@@ skipping 208 matching lines @@
 
   // sanity checks:
   DCHECK(proxy_auth_state_ == AUTH_STATE_NEED_AUTH ||
          server_auth_state_ == AUTH_STATE_NEED_AUTH);
   DCHECK(GetResponseHeaders()->response_code() == 401 ||
          GetResponseHeaders()->response_code() == 407);
 
   *result = response_info_->auth_challenge;
 }
 
-void URLRequestHttpJob::SetAuth(const string16& username,
-                                const string16& password) {
+void URLRequestHttpJob::SetAuth(const AuthCredentials& credentials) {
   DCHECK(transaction_.get());
 
   // Proxy gets set first, then WWW.
   if (proxy_auth_state_ == AUTH_STATE_NEED_AUTH) {
     proxy_auth_state_ = AUTH_STATE_HAVE_AUTH;
   } else {
     DCHECK_EQ(server_auth_state_, AUTH_STATE_NEED_AUTH);
     server_auth_state_ = AUTH_STATE_HAVE_AUTH;
   }
 
-  RestartTransactionWithAuth(username, password);
+  RestartTransactionWithAuth(credentials);
 }
 
 void URLRequestHttpJob::CancelAuth() {
   // Proxy gets set first, then WWW.
   if (proxy_auth_state_ == AUTH_STATE_NEED_AUTH) {
     proxy_auth_state_ = AUTH_STATE_CANCELED;
   } else {
     DCHECK_EQ(server_auth_state_, AUTH_STATE_NEED_AUTH);
     server_auth_state_ = AUTH_STATE_CANCELED;
   }
@@ skipping 404 matching lines @@
   return override_response_headers_.get() ?
       override_response_headers_ :
       transaction_->GetResponseInfo()->headers;
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net