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

net/socket_stream/socket_stream.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.
 //
 // TODO(ukai): code is similar with http_network_transaction.cc.  We should
 //   think about ways to share code, if possible.
 
 #include "net/socket_stream/socket_stream.h"
 
 #include <set>
@@ skipping 188 matching lines @@
   // closed.  So, return immediately.
   // Otherwise, it might call Finish() more than once, so breaks balance
   // of AddRef() and Release() in Connect() and Finish(), respectively.
   if (next_state_ == STATE_NONE)
     return;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SocketStream::DoClose));
 }
 
-void SocketStream::RestartWithAuth(
-    const string16& username, const string16& password) {
+void SocketStream::RestartWithAuth(const AuthCredentials& credentials) {
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
   DCHECK(auth_handler_.get());
   if (!socket_.get()) {
     LOG(ERROR) << "Socket is closed before restarting with auth.";
     return;
   }
 
   if (auth_identity_.invalid) {
-    // Update the username/password.
+    // Update the credentials.
     auth_identity_.source = HttpAuth::IDENT_SRC_EXTERNAL;
     auth_identity_.invalid = false;
-    auth_identity_.username = username;
-    auth_identity_.password = password;
+    auth_identity_.credentials = credentials;
   }
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SocketStream::DoRestartWithAuth));
 }
 
 void SocketStream::DetachDelegate() {
   if (!delegate_)
     return;
@@ skipping 469 matching lines @@
       if (entry) {
         scoped_ptr<HttpAuthHandler> handler_preemptive;
         int rv_create = http_auth_handler_factory_->
             CreatePreemptiveAuthHandlerFromString(
                 entry->auth_challenge(), HttpAuth::AUTH_PROXY,
                 ProxyAuthOrigin(), entry->IncrementNonceCount(),
                 net_log_, &handler_preemptive);
         if (rv_create == OK) {
           auth_identity_.source = HttpAuth::IDENT_SRC_PATH_LOOKUP;
           auth_identity_.invalid = false;
-          auth_identity_.username = entry->username();
-          auth_identity_.password = entry->password();
+          auth_identity_.credentials = AuthCredentials();
           auth_handler_.swap(handler_preemptive);
         }
       }
     }
 
     // Support basic authentication scheme only, because we don't have
     // HttpRequestInfo.
     // TODO(ukai): Add support other authentication scheme.
     if (auth_handler_.get() &&
         auth_handler_->auth_scheme() == HttpAuth::AUTH_SCHEME_BASIC) {
       HttpRequestInfo request_info;
       std::string auth_token;
       int rv = auth_handler_->GenerateAuthToken(
-          &auth_identity_.username,
-          &auth_identity_.password,
+          &auth_identity_.credentials,
           &request_info,
           NULL,
           &auth_token);
       // TODO(cbentzel): Support async auth handlers.
       DCHECK_NE(ERR_IO_PENDING, rv);
       if (rv != OK)
         return rv;
       authorization_headers.append(
           HttpAuth::GetAuthorizationHeaderName(HttpAuth::AUTH_PROXY) +
           ": " + auth_token + "\r\n");
@@ skipping 311 matching lines @@
 
   // TODO(cbentzel): Since SocketStream only suppports basic authentication
   // right now, another challenge is always treated as a rejection.
   // Ultimately this should be converted to use HttpAuthController like the
   // HttpNetworkTransaction has.
   if (auth_handler_.get() && !auth_identity_.invalid) {
     if (auth_identity_.source != HttpAuth::IDENT_SRC_PATH_LOOKUP)
       auth_cache_.Remove(auth_origin,
                          auth_handler_->realm(),
                          auth_handler_->auth_scheme(),
-                         auth_identity_.username,
-                         auth_identity_.password);
+                         auth_identity_.credentials);
     auth_handler_.reset();
     auth_identity_ = HttpAuth::Identity();
   }
 
   auth_identity_.invalid = true;
   std::set<HttpAuth::Scheme> disabled_schemes;
   HttpAuth::ChooseBestChallenge(http_auth_handler_factory_, headers,
                                 HttpAuth::AUTH_PROXY,
                                 auth_origin, disabled_schemes,
                                 net_log_, &auth_handler_);
   if (!auth_handler_.get()) {
     LOG(ERROR) << "Can't perform auth to the proxy " << auth_origin;
     return ERR_TUNNEL_CONNECTION_FAILED;
   }
   if (auth_handler_->NeedsIdentity()) {
     // We only support basic authentication scheme now.
     // TODO(ukai): Support other authentication scheme.
     HttpAuthCache::Entry* entry = auth_cache_.Lookup(
         auth_origin, auth_handler_->realm(), HttpAuth::AUTH_SCHEME_BASIC);
     if (entry) {
       auth_identity_.source = HttpAuth::IDENT_SRC_REALM_LOOKUP;
       auth_identity_.invalid = false;
-      auth_identity_.username = entry->username();
-      auth_identity_.password = entry->password();
+      auth_identity_.credentials = AuthCredentials();
       // Restart with auth info.
     }
     return ERR_PROXY_AUTH_UNSUPPORTED;
   } else {
     auth_identity_.invalid = false;
   }
   return ERR_TUNNEL_CONNECTION_FAILED;
 }
 
 int SocketStream::HandleCertificateRequest(int result) {
@@ skipping 49 matching lines @@
   else
     DoLoop(ERR_UNEXPECTED);
 }
 
 void SocketStream::DoRestartWithAuth() {
   DCHECK_EQ(next_state_, STATE_AUTH_REQUIRED);
   auth_cache_.Add(ProxyAuthOrigin(),
                   auth_handler_->realm(),
                   auth_handler_->auth_scheme(),
                   auth_handler_->challenge(),
-                  auth_identity_.username,
-                  auth_identity_.password,
+                  auth_identity_.credentials,
                   std::string());
 
   tunnel_request_headers_ = NULL;
   tunnel_request_headers_bytes_sent_ = 0;
   tunnel_response_headers_ = NULL;
   tunnel_response_headers_capacity_ = 0;
   tunnel_response_headers_len_ = 0;
 
   next_state_ = STATE_TCP_CONNECT;
   DoLoop(OK);
@@ skipping 15 matching lines @@
 
 SSLConfigService* SocketStream::ssl_config_service() const {
   return context_->ssl_config_service();
 }
 
 ProxyService* SocketStream::proxy_service() const {
   return context_->proxy_service();
 }
 
 }  // namespace net