Net: Convert username and password to string16.

net/http/http_auth_sspi_win.cc

 // Copyright (c) 2010 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.
 
 // See "SSPI Sample Application" at
 // http://msdn.microsoft.com/en-us/library/aa918273.aspx
 
 #include "net/http/http_auth_sspi_win.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_auth.h"
 
 namespace net {
 
 namespace {
 
 int MapAcquireCredentialsStatusToError(SECURITY_STATUS status,
                                        const SEC_WCHAR* package) {
   switch (status) {
@@ skipping 12 matching lines @@
       LOG(ERROR) << "Received SEC_E_SECPKG_NOT_FOUND for " << package;
       return ERR_UNSUPPORTED_AUTH_SCHEME;
     default:
       LOG(ERROR) << "Unexpected SECURITY_STATUS " << status;
       return ERR_UNEXPECTED;
   }
 }
 
 int AcquireExplicitCredentials(SSPILibrary* library,
                                const SEC_WCHAR* package,
-                               const std::wstring& domain,
-                               const std::wstring& user,
-                               const std::wstring& password,
+                               const string16& domain,
+                               const string16& user,
+                               const string16& password,
                                CredHandle* cred) {
   SEC_WINNT_AUTH_IDENTITY identity;
   identity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
   identity.User =
       reinterpret_cast<unsigned short*>(const_cast<wchar_t*>(user.c_str()));
   identity.UserLength = user.size();
   identity.Domain =
       reinterpret_cast<unsigned short*>(const_cast<wchar_t*>(domain.c_str()));
   identity.DomainLength = domain.size();
   identity.Password =
@@ skipping 93 matching lines @@
   std::string decoded_auth_token;
   bool base64_rv = base::Base64Decode(encoded_auth_token, &decoded_auth_token);
   if (!base64_rv) {
     LOG(ERROR) << "Base64 decoding of auth token failed.";
     return false;
   }
   decoded_server_auth_token_ = decoded_auth_token;
   return true;
 }
 
-int HttpAuthSSPI::GenerateAuthToken(const std::wstring* username,
-                                    const std::wstring* password,
+int HttpAuthSSPI::GenerateAuthToken(const string16* username,
+                                    const string16* password,
                                     const std::wstring& spn,
                                     std::string* auth_token) {
   DCHECK((username == NULL) == (password == NULL));
 
   // Initial challenge.
   if (!IsFinalRound()) {
     int rv = OnFirstRound(username, password);
     if (rv != OK)
       return rv;
   }
@@ skipping 18 matching lines @@
   // OK, we are done with |out_buf|
   free(out_buf);
   if (!base64_rv) {
     LOG(ERROR) << "Base64 encoding of auth token failed.";
     return ERR_UNEXPECTED;
   }
   *auth_token = scheme_ + " " + encode_output;
   return OK;
 }
 
-int HttpAuthSSPI::OnFirstRound(const std::wstring* username,
-                               const std::wstring* password) {
+int HttpAuthSSPI::OnFirstRound(const string16* username,
+                               const string16* password) {
   DCHECK((username == NULL) == (password == NULL));
   DCHECK(!SecIsValidHandle(&cred_));
   int rv = OK;
   if (username) {
-    std::wstring domain;
-    std::wstring user;
+    string16 domain;
+    string16 user;
     SplitDomainAndUser(*username, &domain, &user);
     rv = AcquireExplicitCredentials(library_, security_package_, domain,
                                     user, *password, &cred_);
     if (rv != OK)
       return rv;
   } else {
     rv = AcquireDefaultCredentials(library_, security_package_, &cred_);
     if (rv != OK)
       return rv;
   }
@@ skipping 73 matching lines @@
   }
   if (!out_buffer.cbBuffer) {
     free(out_buffer.pvBuffer);
     out_buffer.pvBuffer = NULL;
   }
   *out_token = out_buffer.pvBuffer;
   *out_token_len = out_buffer.cbBuffer;
   return OK;
 }
 
-void SplitDomainAndUser(const std::wstring& combined,
-                        std::wstring* domain,
-                        std::wstring* user) {
+void SplitDomainAndUser(const string16& combined,
+                        string16* domain,
+                        string16* user) {
   // |combined| may be in the form "user" or "DOMAIN\user".
-  // Separatethe two parts if they exist.
+  // Separate the two parts if they exist.
   // TODO(cbentzel): I believe user@domain is also a valid form.
   size_t backslash_idx = combined.find(L'\\');
-  if (backslash_idx == std::wstring::npos) {
+  if (backslash_idx == string16::npos) {
     domain->clear();
     *user = combined;
   } else {
     *domain = combined.substr(0, backslash_idx);
     *user = combined.substr(backslash_idx + 1);
   }
 }
 
 int DetermineMaxTokenLength(SSPILibrary* library,
                             const std::wstring& package,
@@ skipping 90 matching lines @@
  private:
   friend struct DefaultSingletonTraits<SSPILibraryDefault>;
 };
 
 // static
 SSPILibrary* SSPILibrary::GetDefault() {
   return Singleton<SSPILibraryDefault>::get();
 }
 
 }  // namespace net