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

net/http/http_auth_handler_negotiate.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/http/http_auth_handler_negotiate.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
@@ skipping 87 matching lines @@
     : auth_system_(auth_library, "Negotiate", NEGOSSP_NAME, max_token_length),
 #elif defined(OS_POSIX)
     : auth_system_(auth_library, "Negotiate", CHROME_GSS_KRB5_MECH_OID_DESC),
 #endif
       disable_cname_lookup_(disable_cname_lookup),
       use_port_(use_port),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
           this, &HttpAuthHandlerNegotiate::OnIOComplete)),
       resolver_(resolver),
       already_called_(false),
-      has_username_and_password_(false),
+      has_credentials_(false),
       user_callback_(NULL),
       auth_token_(NULL),
       next_state_(STATE_NONE),
       url_security_manager_(url_security_manager) {
 }
 
 HttpAuthHandlerNegotiate::~HttpAuthHandlerNegotiate() {
 }
 
 std::wstring HttpAuthHandlerNegotiate::CreateSPN(
@@ skipping 86 matching lines @@
     auth_system_.Delegate();
   auth_scheme_ = HttpAuth::AUTH_SCHEME_NEGOTIATE;
   score_ = 4;
   properties_ = ENCRYPTS_IDENTITY | IS_CONNECTION_BASED;
   HttpAuth::AuthorizationResult auth_result =
       auth_system_.ParseChallenge(challenge);
   return (auth_result == HttpAuth::AUTHORIZATION_RESULT_ACCEPT);
 }
 
 int HttpAuthHandlerNegotiate::GenerateAuthTokenImpl(
-    const string16* username,
-    const string16* password,
+    const AuthCredentials* credentials,
     const HttpRequestInfo* request,
     OldCompletionCallback* callback,
     std::string* auth_token) {
   DCHECK(user_callback_ == NULL);
-  DCHECK((username == NULL) == (password == NULL));
   DCHECK(auth_token_ == NULL);
   auth_token_ = auth_token;
   if (already_called_) {
-    DCHECK((!has_username_and_password_ && username == NULL) ||
-           (has_username_and_password_ && *username == username_ &&
-            *password == password_));
+    DCHECK((!has_credentials_ && credentials == NULL) ||
+           (has_credentials_ && credentials->Equals(credentials_)));
     next_state_ = STATE_GENERATE_AUTH_TOKEN;
   } else {
     already_called_ = true;
-    if (username) {
-      has_username_and_password_ = true;
-      username_ = *username;
-      password_ = *password;
+    if (credentials) {
+      has_credentials_ = true;
+      credentials_ = *credentials;
     }
     next_state_ = STATE_RESOLVE_CANONICAL_NAME;
   }
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
 void HttpAuthHandlerNegotiate::OnIOComplete(int result) {
@@ skipping 67 matching lines @@
   }
 
   next_state_ = STATE_GENERATE_AUTH_TOKEN;
   spn_ = CreateSPN(address_list_, origin_);
   address_list_ = AddressList();
   return rv;
 }
 
 int HttpAuthHandlerNegotiate::DoGenerateAuthToken() {
   next_state_ = STATE_GENERATE_AUTH_TOKEN_COMPLETE;
-  string16* username = has_username_and_password_ ? &username_ : NULL;
-  string16* password = has_username_and_password_ ? &password_ : NULL;
+  AuthCredentials* credentials = has_credentials_ ? &credentials_ : NULL;
   // TODO(cbentzel): This should possibly be done async.
-  return auth_system_.GenerateAuthToken(username, password, spn_, auth_token_);
+  return auth_system_.GenerateAuthToken(credentials, spn_, auth_token_);
 }
 
 int HttpAuthHandlerNegotiate::DoGenerateAuthTokenComplete(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   auth_token_ = NULL;
   return rv;
 }
 
 bool HttpAuthHandlerNegotiate::CanDelegate() const {
   // TODO(cbentzel): Should delegation be allowed on proxies?
   if (target_ == HttpAuth::AUTH_PROXY)
     return false;
   if (!url_security_manager_)
     return false;
   return url_security_manager_->CanDelegate(origin_);
 }
 
 }  // namespace net