diff options
67 files changed, 555 insertions, 456 deletions
diff --git a/chrome/browser/login_prompt.cc b/chrome/browser/login_prompt.cc index 37677b5..0061e9c 100644 --- a/chrome/browser/login_prompt.cc +++ b/chrome/browser/login_prompt.cc @@ -319,7 +319,7 @@ void LoginHandler::SetAuthDeferred(const std::wstring& username, DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO)); if (request_) { - request_->SetAuth(username, password); + request_->SetAuth(WideToUTF16Hack(username), WideToUTF16Hack(password)); ResetLoginHandlerForRequest(request_); } } diff --git a/net/base/auth.h b/net/base/auth.h index 3050a4c5..20c4f5c 100644 --- a/net/base/auth.h +++ b/net/base/auth.h @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. +// 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. @@ -9,6 +9,7 @@ #include <string> #include "base/ref_counted.h" +#include "base/string16.h" namespace net { @@ -51,8 +52,8 @@ class AuthData : public base::RefCountedThreadSafe<AuthData> { public: AuthState state; // whether we need, have, or gave up on authentication. std::wstring scheme; // the authentication scheme. - std::wstring username; // the username supplied to us for auth. - std::wstring password; // the password supplied to us for auth. + string16 username; // the username supplied to us for auth. + string16 password; // the password supplied to us for auth. // We wouldn't instantiate this class if we didn't need authentication. AuthData() : state(AUTH_STATE_NEED_AUTH) {} diff --git a/net/base/net_util.cc b/net/base/net_util.cc index 73df8c6..7ba8a10 100644 --- a/net/base/net_util.cc +++ b/net/base/net_util.cc @@ -1338,14 +1338,12 @@ std::string GetHostName() { } void GetIdentityFromURL(const GURL& url, - std::wstring* username, - std::wstring* password) { + string16* username, + string16* password) { UnescapeRule::Type flags = UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS; - *username = UTF16ToWideHack(UnescapeAndDecodeUTF8URLComponent(url.username(), - flags, NULL)); - *password = UTF16ToWideHack(UnescapeAndDecodeUTF8URLComponent(url.password(), - flags, NULL)); + *username = UnescapeAndDecodeUTF8URLComponent(url.username(), flags, NULL); + *password = UnescapeAndDecodeUTF8URLComponent(url.password(), flags, NULL); } std::string GetHostOrSpecFromURL(const GURL& url) { diff --git a/net/base/net_util.h b/net/base/net_util.h index 7b2ed36..44bda41 100644 --- a/net/base/net_util.h +++ b/net/base/net_util.h @@ -106,8 +106,8 @@ std::string GetHostName(); // Extracts the unescaped username/password from |url|, saving the results // into |*username| and |*password|. void GetIdentityFromURL(const GURL& url, - std::wstring* username, - std::wstring* password); + string16* username, + string16* password); // Returns either the host from |url|, or, if the host is empty, the full spec. std::string GetHostOrSpecFromURL(const GURL& url); diff --git a/net/base/net_util_unittest.cc b/net/base/net_util_unittest.cc index 2c62089..84cb4f4 100644 --- a/net/base/net_util_unittest.cc +++ b/net/base/net_util_unittest.cc @@ -575,54 +575,54 @@ TEST(NetUtilTest, FileURLConversion) { TEST(NetUtilTest, GetIdentityFromURL) { struct { const char* input_url; - const wchar_t* expected_username; - const wchar_t* expected_password; + const char* expected_username; + const char* expected_password; } tests[] = { { "http://username:password@google.com", - L"username", - L"password", + "username", + "password", }, { // Test for http://crbug.com/19200 "http://username:p@ssword@google.com", - L"username", - L"p@ssword", + "username", + "p@ssword", }, { // Special URL characters should be unescaped. "http://username:p%3fa%26s%2fs%23@google.com", - L"username", - L"p?a&s/s#", + "username", + "p?a&s/s#", }, { // Username contains %20. "http://use rname:password@google.com", - L"use rname", - L"password", + "use rname", + "password", }, { // Keep %00 as is. "http://use%00rname:password@google.com", - L"use%00rname", - L"password", + "use%00rname", + "password", }, { // Use a '+' in the username. "http://use+rname:password@google.com", - L"use+rname", - L"password", + "use+rname", + "password", }, { // Use a '&' in the password. "http://username:p&ssword@google.com", - L"username", - L"p&ssword", + "username", + "p&ssword", }, }; for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) { SCOPED_TRACE(StringPrintf("Test[%" PRIuS "]: %s", i, tests[i].input_url)); GURL url(tests[i].input_url); - std::wstring username, password; + string16 username, password; net::GetIdentityFromURL(url, &username, &password); - EXPECT_EQ(tests[i].expected_username, username); - EXPECT_EQ(tests[i].expected_password, password); + EXPECT_EQ(ASCIIToUTF16(tests[i].expected_username), username); + EXPECT_EQ(ASCIIToUTF16(tests[i].expected_password), password); } } @@ -634,12 +634,12 @@ TEST(NetUtilTest, GetIdentityFromURL_UTF8) { EXPECT_EQ("%E4%BD%A0%E5%A5%BD", url.password()); // Extract the unescaped identity. - std::wstring username, password; + string16 username, password; net::GetIdentityFromURL(url, &username, &password); // Verify that it was decoded as UTF8. - EXPECT_EQ(L"foo", username); - EXPECT_EQ(L"\x4f60\x597d", password); + EXPECT_EQ(ASCIIToUTF16("foo"), username); + EXPECT_EQ(WideToUTF16(L"\x4f60\x597d"), password); } // Just a bunch of fake headers. diff --git a/net/ftp/ftp_auth_cache.cc b/net/ftp/ftp_auth_cache.cc index d3bff90..caa2b8a 100644 --- a/net/ftp/ftp_auth_cache.cc +++ b/net/ftp/ftp_auth_cache.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. +// 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. @@ -20,8 +20,8 @@ FtpAuthCache::Entry* FtpAuthCache::Lookup(const GURL& origin) { return NULL; } -void FtpAuthCache::Add(const GURL& origin, const std::wstring& username, - const std::wstring& password) { +void FtpAuthCache::Add(const GURL& origin, const string16& username, + const string16& password) { DCHECK(origin.SchemeIs("ftp")); DCHECK_EQ(origin.GetOrigin(), origin); @@ -38,8 +38,8 @@ void FtpAuthCache::Add(const GURL& origin, const std::wstring& username, } } -void FtpAuthCache::Remove(const GURL& origin, const std::wstring& username, - const std::wstring& password) { +void FtpAuthCache::Remove(const GURL& origin, const string16& username, + const string16& password) { for (EntryList::iterator it = entries_.begin(); it != entries_.end(); ++it) { if (it->origin == origin && it->username == username && it->password == password) { diff --git a/net/ftp/ftp_auth_cache.h b/net/ftp/ftp_auth_cache.h index d541b8e..36156da 100644 --- a/net/ftp/ftp_auth_cache.h +++ b/net/ftp/ftp_auth_cache.h @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. +// 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. @@ -7,8 +7,8 @@ #pragma once #include <list> -#include <string> +#include "base/string16.h" #include "googleurl/src/gurl.h" namespace net { @@ -27,16 +27,16 @@ class FtpAuthCache { static const size_t kMaxEntries; struct Entry { - Entry(const GURL& origin, const std::wstring& username, - const std::wstring& password) + Entry(const GURL& origin, const string16& username, + const string16& password) : origin(origin), username(username), password(password) { } const GURL origin; - std::wstring username; - std::wstring password; + string16 username; + string16 password; }; FtpAuthCache() {} @@ -48,13 +48,13 @@ class FtpAuthCache { // Add an entry for |origin| to the cache (consisting of |username| and // |password|). If there is already an entry for |origin|, it will be // overwritten. - void Add(const GURL& origin, const std::wstring& username, - const std::wstring& password); + void Add(const GURL& origin, const string16& username, + const string16& password); // Remove the entry for |origin| from the cache, if one exists and matches // |username| and |password|. - void Remove(const GURL& origin, const std::wstring& username, - const std::wstring& password); + void Remove(const GURL& origin, const string16& username, + const string16& password); private: typedef std::list<Entry> EntryList; diff --git a/net/ftp/ftp_auth_cache_unittest.cc b/net/ftp/ftp_auth_cache_unittest.cc index b23781e..005de89 100644 --- a/net/ftp/ftp_auth_cache_unittest.cc +++ b/net/ftp/ftp_auth_cache_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// 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. @@ -10,6 +10,22 @@ using net::FtpAuthCache; +namespace { + +const string16 kBogus(ASCIIToUTF16("bogus")); +const string16 kOthername(ASCIIToUTF16("othername")); +const string16 kOtherword(ASCIIToUTF16("otherword")); +const string16 kPassword(ASCIIToUTF16("password")); +const string16 kPassword1(ASCIIToUTF16("password1")); +const string16 kPassword2(ASCIIToUTF16("password2")); +const string16 kPassword3(ASCIIToUTF16("password3")); +const string16 kUsername(ASCIIToUTF16("username")); +const string16 kUsername1(ASCIIToUTF16("username1")); +const string16 kUsername2(ASCIIToUTF16("username2")); +const string16 kUsername3(ASCIIToUTF16("username3")); + +} // namespace + TEST(FtpAuthCacheTest, LookupAddRemove) { FtpAuthCache cache; @@ -20,38 +36,38 @@ TEST(FtpAuthCacheTest, LookupAddRemove) { EXPECT_TRUE(cache.Lookup(origin1) == NULL); // Add entry for origin1. - cache.Add(origin1, L"username1", L"password1"); + cache.Add(origin1, kUsername1, kPassword1); FtpAuthCache::Entry* entry1 = cache.Lookup(origin1); ASSERT_TRUE(entry1); EXPECT_EQ(origin1, entry1->origin); - EXPECT_EQ(L"username1", entry1->username); - EXPECT_EQ(L"password1", entry1->password); + EXPECT_EQ(kUsername1, entry1->username); + EXPECT_EQ(kPassword1, entry1->password); // Add an entry for origin2. - cache.Add(origin2, L"username2", L"password2"); + cache.Add(origin2, kUsername2, kPassword2); FtpAuthCache::Entry* entry2 = cache.Lookup(origin2); ASSERT_TRUE(entry2); EXPECT_EQ(origin2, entry2->origin); - EXPECT_EQ(L"username2", entry2->username); - EXPECT_EQ(L"password2", entry2->password); + EXPECT_EQ(kUsername2, entry2->username); + EXPECT_EQ(kPassword2, entry2->password); // The original entry1 should still be there. EXPECT_EQ(entry1, cache.Lookup(origin1)); // Overwrite the entry for origin1. - cache.Add(origin1, L"username3", L"password3"); + cache.Add(origin1, kUsername3, kPassword3); FtpAuthCache::Entry* entry3 = cache.Lookup(origin1); ASSERT_TRUE(entry3); EXPECT_EQ(origin1, entry3->origin); - EXPECT_EQ(L"username3", entry3->username); - EXPECT_EQ(L"password3", entry3->password); + EXPECT_EQ(kUsername3, entry3->username); + EXPECT_EQ(kPassword3, entry3->password); // Remove entry of origin1. - cache.Remove(origin1, L"username3", L"password3"); + cache.Remove(origin1, kUsername3, kPassword3); EXPECT_TRUE(cache.Lookup(origin1) == NULL); // Remove non-existent entry. - cache.Remove(origin1, L"username3", L"password3"); + cache.Remove(origin1, kUsername3, kPassword3); EXPECT_TRUE(cache.Lookup(origin1) == NULL); } @@ -63,8 +79,8 @@ TEST(FtpAuthCacheTest, LookupWithPort) { GURL origin1("ftp://foo:80"); GURL origin2("ftp://foo:21"); - cache.Add(origin1, L"username", L"password"); - cache.Add(origin2, L"username", L"password"); + cache.Add(origin1, kUsername, kPassword); + cache.Add(origin2, kUsername, kPassword); EXPECT_NE(cache.Lookup(origin1), cache.Lookup(origin2)); } @@ -77,7 +93,7 @@ TEST(FtpAuthCacheTest, NormalizedKey) { FtpAuthCache cache; // Add. - cache.Add(GURL("ftp://HoSt:21"), L"username", L"password"); + cache.Add(GURL("ftp://HoSt:21"), kUsername, kPassword); // Lookup. FtpAuthCache::Entry* entry1 = cache.Lookup(GURL("ftp://HoSt:21")); @@ -86,30 +102,30 @@ TEST(FtpAuthCacheTest, NormalizedKey) { EXPECT_EQ(entry1, cache.Lookup(GURL("ftp://host"))); // Overwrite. - cache.Add(GURL("ftp://host"), L"othername", L"otherword"); + cache.Add(GURL("ftp://host"), kOthername, kOtherword); FtpAuthCache::Entry* entry2 = cache.Lookup(GURL("ftp://HoSt:21")); ASSERT_TRUE(entry2); EXPECT_EQ(GURL("ftp://host"), entry2->origin); - EXPECT_EQ(L"othername", entry2->username); - EXPECT_EQ(L"otherword", entry2->password); + EXPECT_EQ(kOthername, entry2->username); + EXPECT_EQ(kOtherword, entry2->password); // Remove - cache.Remove(GURL("ftp://HOsT"), L"othername", L"otherword"); + cache.Remove(GURL("ftp://HOsT"), kOthername, kOtherword); EXPECT_TRUE(cache.Lookup(GURL("ftp://host")) == NULL); } TEST(FtpAuthCacheTest, OnlyRemoveMatching) { FtpAuthCache cache; - cache.Add(GURL("ftp://host"), L"username", L"password"); + cache.Add(GURL("ftp://host"), kUsername, kPassword); EXPECT_TRUE(cache.Lookup(GURL("ftp://host"))); // Auth data doesn't match, shouldn't remove. - cache.Remove(GURL("ftp://host"), L"bogus", L"bogus"); + cache.Remove(GURL("ftp://host"), kBogus, kBogus); EXPECT_TRUE(cache.Lookup(GURL("ftp://host"))); // Auth data matches, should remove. - cache.Remove(GURL("ftp://host"), L"username", L"password"); + cache.Remove(GURL("ftp://host"), kUsername, kPassword); EXPECT_TRUE(cache.Lookup(GURL("ftp://host")) == NULL); } @@ -117,7 +133,7 @@ TEST(FtpAuthCacheTest, EvictOldEntries) { FtpAuthCache cache; for (size_t i = 0; i < FtpAuthCache::kMaxEntries; i++) - cache.Add(GURL("ftp://host" + IntToString(i)), L"username", L"password"); + cache.Add(GURL("ftp://host" + IntToString(i)), kUsername, kPassword); // No entries should be evicted before reaching the limit. for (size_t i = 0; i < FtpAuthCache::kMaxEntries; i++) { @@ -125,7 +141,7 @@ TEST(FtpAuthCacheTest, EvictOldEntries) { } // Adding one entry should cause eviction of the first entry. - cache.Add(GURL("ftp://last_host"), L"username", L"password"); + cache.Add(GURL("ftp://last_host"), kUsername, kPassword); EXPECT_TRUE(cache.Lookup(GURL("ftp://host0")) == NULL); // Remaining entries should not get evicted. diff --git a/net/ftp/ftp_network_transaction.cc b/net/ftp/ftp_network_transaction.cc index 471e8c9..85cac4b 100644 --- a/net/ftp/ftp_network_transaction.cc +++ b/net/ftp/ftp_network_transaction.cc @@ -212,8 +212,8 @@ int FtpNetworkTransaction::Start(const FtpRequestInfo* request_info, if (request_->url.has_username()) { GetIdentityFromURL(request_->url, &username_, &password_); } else { - username_ = L"anonymous"; - password_ = L"chrome@example.com"; + username_ = ASCIIToUTF16("anonymous"); + password_ = ASCIIToUTF16("chrome@example.com"); } DetectTypecode(); @@ -234,8 +234,8 @@ int FtpNetworkTransaction::Stop(int error) { return OK; } -int FtpNetworkTransaction::RestartWithAuth(const std::wstring& username, - const std::wstring& password, +int FtpNetworkTransaction::RestartWithAuth(const string16& username, + const string16& password, CompletionCallback* callback) { ResetStateForRestart(); @@ -653,7 +653,7 @@ int FtpNetworkTransaction::DoCtrlReadComplete(int result) { // Some servers (for example Pure-FTPd) apparently close the control // connection when anonymous login is not permitted. For more details // see http://crbug.com/25023. - if (command_sent_ == COMMAND_USER && username_ == L"anonymous") + if (command_sent_ == COMMAND_USER && username_ == ASCIIToUTF16("anonymous")) response_.needs_auth = true; return Stop(ERR_EMPTY_RESPONSE); } @@ -700,7 +700,7 @@ int FtpNetworkTransaction::DoCtrlWriteComplete(int result) { // USER Command. int FtpNetworkTransaction::DoCtrlWriteUSER() { - std::string command = "USER " + WideToUTF8(username_); + std::string command = "USER " + UTF16ToUTF8(username_); if (!IsValidFTPCommandString(command)) return Stop(ERR_MALFORMED_IDENTITY); @@ -732,7 +732,7 @@ int FtpNetworkTransaction::ProcessResponseUSER( // PASS command. int FtpNetworkTransaction::DoCtrlWritePASS() { - std::string command = "PASS " + WideToUTF8(password_); + std::string command = "PASS " + UTF16ToUTF8(password_); if (!IsValidFTPCommandString(command)) return Stop(ERR_MALFORMED_IDENTITY); diff --git a/net/ftp/ftp_network_transaction.h b/net/ftp/ftp_network_transaction.h index 6b2a1f8..3732157 100644 --- a/net/ftp/ftp_network_transaction.h +++ b/net/ftp/ftp_network_transaction.h @@ -6,13 +6,14 @@ #define NET_FTP_FTP_NETWORK_TRANSACTION_H_ #pragma once -#include <string> #include <queue> +#include <string> #include <utility> #include <vector> #include "base/ref_counted.h" #include "base/scoped_ptr.h" +#include "base/string16.h" #include "net/base/address_list.h" #include "net/base/host_resolver.h" #include "net/base/net_log.h" @@ -37,8 +38,8 @@ class FtpNetworkTransaction : public FtpTransaction { CompletionCallback* callback, const BoundNetLog& net_log); virtual int Stop(int error); - virtual int RestartWithAuth(const std::wstring& username, - const std::wstring& password, + virtual int RestartWithAuth(const string16& username, + const string16& password, CompletionCallback* callback); virtual int RestartIgnoringLastError(CompletionCallback* callback); virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback); @@ -201,10 +202,8 @@ class FtpNetworkTransaction : public FtpTransaction { // EPSV fail, we fall back to PASV for the duration of connection. bool use_epsv_; - // We get username and password as wstrings in RestartWithAuth, so they are - // also kept as wstrings here. - std::wstring username_; - std::wstring password_; + string16 username_; + string16 password_; // Current directory on the remote server, as returned by last PWD command, // with any trailing slash removed. diff --git a/net/ftp/ftp_network_transaction_unittest.cc b/net/ftp/ftp_network_transaction_unittest.cc index c5aed0d..5745ae7 100644 --- a/net/ftp/ftp_network_transaction_unittest.cc +++ b/net/ftp/ftp_network_transaction_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// 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. @@ -7,6 +7,7 @@ #include "build/build_config.h" #include "base/ref_counted.h" +#include "base/string_util.h" #include "net/base/io_buffer.h" #include "net/base/mock_host_resolver.h" #include "net/base/net_util.h" @@ -81,8 +82,8 @@ class FtpSocketDataProvider : public DynamicSocketDataProvider { return Verify("EPSV\r\n", data, PRE_SIZE, "227 Entering Extended Passive Mode (|||31744|)\r\n"); case PRE_NOPASV: - // Use unallocated 599 FTP error code to make sure it falls into the generic - // ERR_FTP_FAILED bucket. + // Use unallocated 599 FTP error code to make sure it falls into the + // generic ERR_FTP_FAILED bucket. return Verify("PASV\r\n", data, PRE_QUIT, "599 fail\r\n"); case PRE_QUIT: @@ -1045,9 +1046,10 @@ TEST_F(FtpNetworkTransactionTest, EvilRestartUser) { StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads), ctrl_writes, arraysize(ctrl_writes)); mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); - ASSERT_EQ(ERR_IO_PENDING, transaction_.RestartWithAuth(L"foo\nownz0red", - L"innocent", - &callback_)); + ASSERT_EQ(ERR_IO_PENDING, + transaction_.RestartWithAuth(ASCIIToUTF16("foo\nownz0red"), + ASCIIToUTF16("innocent"), + &callback_)); EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult()); } @@ -1077,9 +1079,10 @@ TEST_F(FtpNetworkTransactionTest, EvilRestartPassword) { StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads), ctrl_writes, arraysize(ctrl_writes)); mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); - ASSERT_EQ(ERR_IO_PENDING, transaction_.RestartWithAuth(L"innocent", - L"foo\nownz0red", - &callback_)); + ASSERT_EQ(ERR_IO_PENDING, + transaction_.RestartWithAuth(ASCIIToUTF16("innocent"), + ASCIIToUTF16("foo\nownz0red"), + &callback_)); EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult()); } diff --git a/net/ftp/ftp_transaction.h b/net/ftp/ftp_transaction.h index b4d1f76..b1f1add 100644 --- a/net/ftp/ftp_transaction.h +++ b/net/ftp/ftp_transaction.h @@ -1,11 +1,12 @@ -// Copyright (c) 2008 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. +// 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. #ifndef NET_FTP_FTP_TRANSACTION_H_ #define NET_FTP_FTP_TRANSACTION_H_ #pragma once +#include "base/string16.h" #include "net/base/completion_callback.h" #include "net/base/io_buffer.h" #include "net/base/load_states.h" @@ -42,8 +43,8 @@ class FtpTransaction { const BoundNetLog& net_log) = 0; // Restarts the FTP transaction with authentication credentials. - virtual int RestartWithAuth(const std::wstring& username, - const std::wstring& password, + virtual int RestartWithAuth(const string16& username, + const string16& password, CompletionCallback* callback) = 0; // Once response info is available for the transaction, response data may be diff --git a/net/http/http_auth.h b/net/http/http_auth.h index 1a752a0..542165c 100644 --- a/net/http/http_auth.h +++ b/net/http/http_auth.h @@ -7,8 +7,10 @@ #pragma once #include <set> +#include <string> #include "base/scoped_ptr.h" +#include "base/string16.h" #include "net/http/http_util.h" template <class T> class scoped_refptr; @@ -68,9 +70,8 @@ class HttpAuth { IdentitySource source; bool invalid; - // TODO(wtc): |username| and |password| should be string16. - std::wstring username; - std::wstring password; + string16 username; + string16 password; }; // Get the name of the header containing the auth challenge diff --git a/net/http/http_auth_cache.cc b/net/http/http_auth_cache.cc index 21db55d..58a90f1 100644 --- a/net/http/http_auth_cache.cc +++ b/net/http/http_auth_cache.cc @@ -48,14 +48,14 @@ void CheckOriginIsValid(const GURL& origin) { // Functor used by remove_if. struct IsEnclosedBy { - IsEnclosedBy(const std::string& path) : path(path) { } + explicit IsEnclosedBy(const std::string& path) : path(path) { } bool operator() (const std::string& x) { return IsEnclosingPath(path, x); } const std::string& path; }; -} // namespace +} // namespace namespace net { @@ -71,7 +71,7 @@ HttpAuthCache::Entry* HttpAuthCache::Lookup(const GURL& origin, it->scheme() == scheme) return &(*it); } - return NULL; // No realm entry found. + return NULL; // No realm entry found. } // Performance: O(n*m), where n is the number of realm entries, m is the number @@ -93,15 +93,15 @@ HttpAuthCache::Entry* HttpAuthCache::LookupByPath(const GURL& origin, if (it->origin() == origin && it->HasEnclosingPath(parent_dir)) return &(*it); } - return NULL; // No entry found. + return NULL; // No entry found. } HttpAuthCache::Entry* HttpAuthCache::Add(const GURL& origin, const std::string& realm, const std::string& scheme, const std::string& auth_challenge, - const std::wstring& username, - const std::wstring& password, + const string16& username, + const string16& password, const std::string& path) { CheckOriginIsValid(origin); CheckPathIsValid(path); @@ -165,8 +165,8 @@ bool HttpAuthCache::Entry::HasEnclosingPath(const std::string& dir) { bool HttpAuthCache::Remove(const GURL& origin, const std::string& realm, const std::string& scheme, - const std::wstring& username, - const std::wstring& password) { + const string16& username, + const string16& password) { for (EntryList::iterator it = entries_.begin(); it != entries_.end(); ++it) { if (it->origin() == origin && it->realm() == realm && it->scheme() == scheme) { @@ -180,4 +180,4 @@ bool HttpAuthCache::Remove(const GURL& origin, return false; } -} // namespace net +} // namespace net diff --git a/net/http/http_auth_cache.h b/net/http/http_auth_cache.h index 297457d..dc82107 100644 --- a/net/http/http_auth_cache.h +++ b/net/http/http_auth_cache.h @@ -10,6 +10,7 @@ #include <string> #include "base/ref_counted.h" +#include "base/string16.h" #include "googleurl/src/gurl.h" // This is needed for the FRIEND_TEST() macro. #include "testing/gtest/include/gtest/gtest_prod.h" @@ -62,8 +63,8 @@ class HttpAuthCache { const std::string& realm, const std::string& scheme, const std::string& auth_challenge, - const std::wstring& username, - const std::wstring& password, + const string16& username, + const string16& password, const std::string& path); // Remove entry on server |origin| for realm |realm| and scheme |scheme| @@ -77,8 +78,8 @@ class HttpAuthCache { bool Remove(const GURL& origin, const std::string& realm, const std::string& scheme, - const std::wstring& username, - const std::wstring& password); + const string16& username, + const string16& password); // Prevent unbounded memory growth. These are safeguards for abuse; it is // not expected that the limits will be reached in ordinary usage. @@ -115,12 +116,12 @@ class HttpAuthCache::Entry { } // The login username. - const std::wstring username() const { + const string16 username() const { return username_; } // The login password. - const std::wstring password() const { + const string16 password() const { return password_; } @@ -149,8 +150,8 @@ class HttpAuthCache::Entry { // Identity. std::string auth_challenge_; - std::wstring username_; - std::wstring password_; + string16 username_; + string16 password_; int nonce_count_; @@ -159,6 +160,6 @@ class HttpAuthCache::Entry { PathList paths_; }; -} // namespace net +} // namespace net #endif // NET_HTTP_HTTP_AUTH_CACHE_H_ diff --git a/net/http/http_auth_cache_unittest.cc b/net/http/http_auth_cache_unittest.cc index 4e2af9d..b5d7175 100644 --- a/net/http/http_auth_cache_unittest.cc +++ b/net/http/http_auth_cache_unittest.cc @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include <string> + +#include "base/string16.h" #include "base/string_util.h" #include "net/base/net_errors.h" #include "net/http/http_auth_cache.h" @@ -30,8 +33,8 @@ class MockAuthHandler : public HttpAuthHandler { return false; // Unused. } - virtual int GenerateAuthTokenImpl(const std::wstring*, - const std::wstring*, + virtual int GenerateAuthTokenImpl(const string16*, + const string16*, const HttpRequestInfo*, CompletionCallback* callback, std::string* auth_token) { @@ -44,6 +47,22 @@ class MockAuthHandler : public HttpAuthHandler { ~MockAuthHandler() {} }; +const char* kBasic = "basic"; +const char* kDigest = "digest"; +const char* kRealm1 = "Realm1"; +const char* kRealm2 = "Realm2"; +const char* kRealm3 = "Realm3"; +const char* kRealm4 = "Realm4"; +const string16 k123(ASCIIToUTF16("123")); +const string16 k1234(ASCIIToUTF16("1234")); +const string16 kAdmin(ASCIIToUTF16("admin")); +const string16 kAlice(ASCIIToUTF16("alice")); +const string16 kAlice2(ASCIIToUTF16("alice2")); +const string16 kPassword(ASCIIToUTF16("password")); +const string16 kRoot(ASCIIToUTF16("root")); +const string16 kUsername(ASCIIToUTF16("username")); +const string16 kWileCoyote(ASCIIToUTF16("wilecoyote")); + } // namespace // Test adding and looking-up cache entries (both by realm and by path). @@ -55,73 +74,74 @@ TEST(HttpAuthCacheTest, Basic) { // Add cache entries for 3 realms: "Realm1", "Realm2", "Realm3" scoped_ptr<HttpAuthHandler> realm1_handler( - new MockAuthHandler("basic", "Realm1", HttpAuth::AUTH_SERVER)); + new MockAuthHandler(kBasic, kRealm1, HttpAuth::AUTH_SERVER)); cache.Add(origin, realm1_handler->realm(), realm1_handler->scheme(), - "Basic realm=Realm1", L"realm1-user", L"realm1-password", - "/foo/bar/index.html"); + "Basic realm=Realm1", ASCIIToUTF16("realm1-user"), + ASCIIToUTF16("realm1-password"), "/foo/bar/index.html"); scoped_ptr<HttpAuthHandler> realm2_handler( - new MockAuthHandler("basic", "Realm2", HttpAuth::AUTH_SERVER)); + new MockAuthHandler(kBasic, kRealm2, HttpAuth::AUTH_SERVER)); cache.Add(origin, realm2_handler->realm(), realm2_handler->scheme(), - "Basic realm=Realm2", L"realm2-user", L"realm2-password", - "/foo2/index.html"); + "Basic realm=Realm2", ASCIIToUTF16("realm2-user"), + ASCIIToUTF16("realm2-password"), "/foo2/index.html"); scoped_ptr<HttpAuthHandler> realm3_basic_handler( - new MockAuthHandler("basic", "Realm3", HttpAuth::AUTH_PROXY)); + new MockAuthHandler(kBasic, kRealm3, HttpAuth::AUTH_PROXY)); cache.Add(origin, realm3_basic_handler->realm(), realm3_basic_handler->scheme(), "Basic realm=Realm3", - L"realm3-basic-user", L"realm3-basic-password", ""); + ASCIIToUTF16("realm3-basic-user"), + ASCIIToUTF16("realm3-basic-password"), ""); scoped_ptr<HttpAuthHandler> realm3_digest_handler( - new MockAuthHandler("digest", "Realm3", HttpAuth::AUTH_PROXY)); + new MockAuthHandler(kDigest, kRealm3, HttpAuth::AUTH_PROXY)); cache.Add(origin, realm3_digest_handler->realm(), realm3_digest_handler->scheme(), "Digest realm=Realm3", - L"realm3-digest-user", L"realm3-digest-password", - "/baz/index.html"); + ASCIIToUTF16("realm3-digest-user"), + ASCIIToUTF16("realm3-digest-password"), "/baz/index.html"); // There is no Realm4 - entry = cache.Lookup(origin, "Realm4", "basic"); + entry = cache.Lookup(origin, kRealm4, kBasic); EXPECT_TRUE(NULL == entry); // While Realm3 does exist, the origin scheme is wrong. - entry = cache.Lookup(GURL("https://www.google.com"), "Realm3", - "basic"); + entry = cache.Lookup(GURL("https://www.google.com"), kRealm3, + kBasic); EXPECT_TRUE(NULL == entry); // Realm, origin scheme ok, authentication scheme wrong - entry = cache.Lookup(GURL("http://www.google.com"), "Realm1", "digest"); + entry = cache.Lookup(GURL("http://www.google.com"), kRealm1, kDigest); EXPECT_TRUE(NULL == entry); // Valid lookup by origin, realm, scheme. - entry = cache.Lookup(GURL("http://www.google.com:80"), "Realm3", "basic"); + entry = cache.Lookup(GURL("http://www.google.com:80"), kRealm3, kBasic); ASSERT_FALSE(NULL == entry); - EXPECT_EQ("basic", entry->scheme()); - EXPECT_EQ("Realm3", entry->realm()); + EXPECT_EQ(kBasic, entry->scheme()); + EXPECT_EQ(kRealm3, entry->realm()); EXPECT_EQ("Basic realm=Realm3", entry->auth_challenge()); - EXPECT_EQ(L"realm3-basic-user", entry->username()); - EXPECT_EQ(L"realm3-basic-password", entry->password()); + EXPECT_EQ(ASCIIToUTF16("realm3-basic-user"), entry->username()); + EXPECT_EQ(ASCIIToUTF16("realm3-basic-password"), entry->password()); // Valid lookup by origin, realm, scheme when there's a duplicate // origin, realm in the cache - entry = cache.Lookup(GURL("http://www.google.com:80"), "Realm3", "digest"); + entry = cache.Lookup(GURL("http://www.google.com:80"), kRealm3, kDigest); ASSERT_FALSE(NULL == entry); - EXPECT_EQ("digest", entry->scheme()); - EXPECT_EQ("Realm3", entry->realm()); + EXPECT_EQ(kDigest, entry->scheme()); + EXPECT_EQ(kRealm3, entry->realm()); EXPECT_EQ("Digest realm=Realm3", entry->auth_challenge()); - EXPECT_EQ(L"realm3-digest-user", entry->username()); - EXPECT_EQ(L"realm3-digest-password", entry->password()); + EXPECT_EQ(ASCIIToUTF16("realm3-digest-user"), entry->username()); + EXPECT_EQ(ASCIIToUTF16("realm3-digest-password"), entry->password()); // Valid lookup by realm. - entry = cache.Lookup(origin, "Realm2", "basic"); + entry = cache.Lookup(origin, kRealm2, kBasic); ASSERT_FALSE(NULL == entry); - EXPECT_EQ("basic", entry->scheme()); - EXPECT_EQ("Realm2", entry->realm()); + EXPECT_EQ(kBasic, entry->scheme()); + EXPECT_EQ(kRealm2, entry->realm()); EXPECT_EQ("Basic realm=Realm2", entry->auth_challenge()); - EXPECT_EQ(L"realm2-user", entry->username()); - EXPECT_EQ(L"realm2-password", entry->password()); + EXPECT_EQ(ASCIIToUTF16("realm2-user"), entry->username()); + EXPECT_EQ(ASCIIToUTF16("realm2-password"), entry->password()); // Check that subpaths are recognized. - HttpAuthCache::Entry* realm2_entry = cache.Lookup(origin, "Realm2", "basic"); + HttpAuthCache::Entry* realm2_entry = cache.Lookup(origin, kRealm2, kBasic); EXPECT_FALSE(NULL == realm2_entry); // Positive tests: entry = cache.LookupByPath(origin, "/foo2/index.html"); @@ -145,7 +165,7 @@ TEST(HttpAuthCacheTest, Basic) { // Confirm we find the same realm, different auth scheme by path lookup HttpAuthCache::Entry* realm3_digest_entry = - cache.Lookup(origin, "Realm3", "digest"); + cache.Lookup(origin, kRealm3, kDigest); EXPECT_FALSE(NULL == realm3_digest_entry); entry = cache.LookupByPath(origin, "/baz/index.html"); EXPECT_TRUE(realm3_digest_entry == entry); @@ -156,7 +176,7 @@ TEST(HttpAuthCacheTest, Basic) { // Confirm we find the same realm, different auth scheme by path lookup HttpAuthCache::Entry* realm3DigestEntry = - cache.Lookup(origin, "Realm3", "digest"); + cache.Lookup(origin, kRealm3, kDigest); EXPECT_FALSE(NULL == realm3DigestEntry); entry = cache.LookupByPath(origin, "/baz/index.html"); EXPECT_TRUE(realm3DigestEntry == entry); @@ -168,8 +188,8 @@ TEST(HttpAuthCacheTest, Basic) { // Lookup using empty path (may be used for proxy). entry = cache.LookupByPath(origin, ""); EXPECT_FALSE(NULL == entry); - EXPECT_EQ("basic", entry->scheme()); - EXPECT_EQ("Realm3", entry->realm()); + EXPECT_EQ(kBasic, entry->scheme()); + EXPECT_EQ(kRealm3, entry->realm()); } TEST(HttpAuthCacheTest, AddPath) { @@ -212,21 +232,21 @@ TEST(HttpAuthCacheTest, AddToExistingEntry) { const std::string auth_challenge = "Basic realm=MyRealm"; scoped_ptr<HttpAuthHandler> handler( - new MockAuthHandler("basic", "MyRealm", HttpAuth::AUTH_SERVER)); + new MockAuthHandler(kBasic, "MyRealm", HttpAuth::AUTH_SERVER)); HttpAuthCache::Entry* orig_entry = cache.Add( origin, handler->realm(), handler->scheme(), auth_challenge, - L"user1", L"password1", "/x/y/z/"); + ASCIIToUTF16("user1"), ASCIIToUTF16("password1"), "/x/y/z/"); cache.Add(origin, handler->realm(), handler->scheme(), auth_challenge, - L"user2", L"password2", "/z/y/x/"); + ASCIIToUTF16("user2"), ASCIIToUTF16("password2"), "/z/y/x/"); cache.Add(origin, handler->realm(), handler->scheme(), auth_challenge, - L"user3", L"password3", "/z/y"); + ASCIIToUTF16("user3"), ASCIIToUTF16("password3"), "/z/y"); - HttpAuthCache::Entry* entry = cache.Lookup(origin, "MyRealm", "basic"); + HttpAuthCache::Entry* entry = cache.Lookup(origin, "MyRealm", kBasic); EXPECT_TRUE(entry == orig_entry); - EXPECT_EQ(L"user3", entry->username()); - EXPECT_EQ(L"password3", entry->password()); + EXPECT_EQ(ASCIIToUTF16("user3"), entry->username()); + EXPECT_EQ(ASCIIToUTF16("password3"), entry->password()); EXPECT_EQ(2U, entry->paths_.size()); EXPECT_EQ("/z/", entry->paths_.front()); @@ -237,63 +257,64 @@ TEST(HttpAuthCacheTest, Remove) { GURL origin("http://foobar2.com"); scoped_ptr<HttpAuthHandler> realm1_handler( - new MockAuthHandler("basic", "Realm1", HttpAuth::AUTH_SERVER)); + new MockAuthHandler(kBasic, kRealm1, HttpAuth::AUTH_SERVER)); scoped_ptr<HttpAuthHandler> realm2_handler( - new MockAuthHandler("basic", "Realm2", HttpAuth::AUTH_SERVER)); + new MockAuthHandler(kBasic, kRealm2, HttpAuth::AUTH_SERVER)); scoped_ptr<HttpAuthHandler> realm3_basic_handler( - new MockAuthHandler("basic", "Realm3", HttpAuth::AUTH_SERVER)); + new MockAuthHandler(kBasic, kRealm3, HttpAuth::AUTH_SERVER)); scoped_ptr<HttpAuthHandler> realm3_digest_handler( - new MockAuthHandler("digest", "Realm3", HttpAuth::AUTH_SERVER)); + new MockAuthHandler(kDigest, kRealm3, HttpAuth::AUTH_SERVER)); HttpAuthCache cache; cache.Add(origin, realm1_handler->realm(), realm1_handler->scheme(), - "basic realm=Realm1", L"alice", L"123", "/"); + "basic realm=Realm1", kAlice, k123, "/"); cache.Add(origin, realm2_handler->realm(), realm2_handler->scheme(), - "basic realm=Realm2", L"bob", L"princess", "/"); + "basic realm=Realm2", ASCIIToUTF16("bob"), ASCIIToUTF16("princess"), + "/"); cache.Add(origin, realm3_basic_handler->realm(), - realm3_basic_handler->scheme(), "basic realm=Realm3", L"admin", - L"password", "/"); + realm3_basic_handler->scheme(), "basic realm=Realm3", + kAdmin, kPassword, "/"); cache.Add(origin, realm3_digest_handler->realm(), - realm3_digest_handler->scheme(), "digest realm=Realm3", L"root", - L"wilecoyote", "/"); + realm3_digest_handler->scheme(), "digest realm=Realm3", + kRoot, kWileCoyote, "/"); // Fails, because there is no realm "Realm4". - EXPECT_FALSE(cache.Remove(origin, "Realm4", "basic", L"alice", L"123")); + EXPECT_FALSE(cache.Remove(origin, kRealm4, kBasic, kAlice, k123)); // Fails because the origin is wrong. EXPECT_FALSE(cache.Remove( - GURL("http://foobar2.com:100"), "Realm1", "basic", L"alice", L"123")); + GURL("http://foobar2.com:100"), kRealm1, kBasic, kAlice, k123)); // Fails because the username is wrong. - EXPECT_FALSE(cache.Remove(origin, "Realm1", "basic", L"alice2", L"123")); + EXPECT_FALSE(cache.Remove(origin, kRealm1, kBasic, kAlice2, k123)); // Fails because the password is wrong. - EXPECT_FALSE(cache.Remove(origin, "Realm1", "basic", L"alice", L"1234")); + EXPECT_FALSE(cache.Remove(origin, kRealm1, kBasic, kAlice, k1234)); // Fails because the authentication type is wrong. - EXPECT_FALSE(cache.Remove(origin, "Realm1", "digest", L"alice", L"123")); + EXPECT_FALSE(cache.Remove(origin, kRealm1, kDigest, kAlice, k123)); // Succeeds. - EXPECT_TRUE(cache.Remove(origin, "Realm1", "basic", L"alice", L"123")); + EXPECT_TRUE(cache.Remove(origin, kRealm1, kBasic, kAlice, k123)); // Fails because we just deleted the entry! - EXPECT_FALSE(cache.Remove(origin, "Realm1", "basic", L"alice", L"123")); + EXPECT_FALSE(cache.Remove(origin, kRealm1, kBasic, kAlice, k123)); // Succeed when there are two authentication types for the same origin,realm. - EXPECT_TRUE(cache.Remove(origin, "Realm3", "digest", L"root", L"wilecoyote")); + EXPECT_TRUE(cache.Remove(origin, kRealm3, kDigest, kRoot, kWileCoyote)); // Succeed as above, but when entries were added in opposite order cache.Add(origin, realm3_digest_handler->realm(), - realm3_digest_handler->scheme(), "digest realm=Realm3", L"root", - L"wilecoyote", "/"); - EXPECT_TRUE(cache.Remove(origin, "Realm3", "basic", L"admin", L"password")); + realm3_digest_handler->scheme(), "digest realm=Realm3", + kRoot, kWileCoyote, "/"); + EXPECT_TRUE(cache.Remove(origin, kRealm3, kBasic, kAdmin, kPassword)); // Make sure that removing one entry still leaves the other available for // lookup. - HttpAuthCache::Entry* entry = cache.Lookup(origin, "Realm3", "digest"); + HttpAuthCache::Entry* entry = cache.Lookup(origin, kRealm3, kDigest); EXPECT_FALSE(NULL == entry); } @@ -316,13 +337,13 @@ class HttpAuthCacheEvictionTest : public testing::Test { } void AddPathToRealm(int realm_i, int path_i) { - cache_.Add(origin_, GenerateRealm(realm_i), "basic", "", - L"username", L"password", GeneratePath(realm_i, path_i)); + cache_.Add(origin_, GenerateRealm(realm_i), kBasic, "", + kUsername, kPassword, GeneratePath(realm_i, path_i)); } void CheckRealmExistence(int realm_i, bool exists) { const HttpAuthCache::Entry* entry = - cache_.Lookup(origin_, GenerateRealm(realm_i), "basic"); + cache_.Lookup(origin_, GenerateRealm(realm_i), kBasic); if (exists) { EXPECT_FALSE(entry == NULL); EXPECT_EQ(GenerateRealm(realm_i), entry->realm()); diff --git a/net/http/http_auth_controller.cc b/net/http/http_auth_controller.cc index c077ee8..3f2d688 100644 --- a/net/http/http_auth_controller.cc +++ b/net/http/http_auth_controller.cc @@ -73,8 +73,8 @@ int HttpAuthController::MaybeGenerateAuthToken(const HttpRequestInfo* request, bool needs_auth = HaveAuth() || SelectPreemptiveAuth(net_log); if (!needs_auth) return OK; - const std::wstring* username = NULL; - const std::wstring* password = NULL; + const string16* username = NULL; + const string16* password = NULL; if (identity_.source != HttpAuth::IDENT_SRC_DEFAULT_CREDENTIALS) { username = &identity_.username; password = &identity_.password; @@ -219,8 +219,8 @@ int HttpAuthController::HandleAuthChallenge( return OK; } -void HttpAuthController::ResetAuth(const std::wstring& username, - const std::wstring& password) { +void HttpAuthController::ResetAuth(const string16& username, + const string16& password) { DCHECK(identity_.invalid || (username.empty() && password.empty())); if (identity_.invalid) { diff --git a/net/http/http_auth_controller.h b/net/http/http_auth_controller.h index 098adb8..be335ba 100644 --- a/net/http/http_auth_controller.h +++ b/net/http/http_auth_controller.h @@ -12,6 +12,7 @@ #include "base/basictypes.h" #include "base/ref_counted.h" #include "base/scoped_ptr.h" +#include "base/string16.h" #include "googleurl/src/gurl.h" #include "net/base/completion_callback.h" #include "net/base/net_log.h" @@ -55,8 +56,8 @@ class HttpAuthController : public base::RefCounted<HttpAuthController> { const BoundNetLog& net_log); // Store the supplied credentials and prepare to restart the auth. - virtual void ResetAuth(const std::wstring& username, - const std::wstring& password); + virtual void ResetAuth(const string16& username, + const string16& password); virtual bool HaveAuthHandler() const { return handler_.get() != NULL; diff --git a/net/http/http_auth_gssapi_posix.cc b/net/http/http_auth_gssapi_posix.cc index 5c88375..444f882 100644 --- a/net/http/http_auth_gssapi_posix.cc +++ b/net/http/http_auth_gssapi_posix.cc @@ -721,8 +721,8 @@ bool HttpAuthGSSAPI::ParseChallenge(HttpAuth::ChallengeTokenizer* tok) { return true; } -int HttpAuthGSSAPI::GenerateAuthToken(const std::wstring* username, - const std::wstring* password, +int HttpAuthGSSAPI::GenerateAuthToken(const string16* username, + const string16* password, const std::wstring& spn, std::string* auth_token) { DCHECK(auth_token); @@ -757,8 +757,8 @@ int HttpAuthGSSAPI::GenerateAuthToken(const std::wstring* username, return OK; } -int HttpAuthGSSAPI::OnFirstRound(const std::wstring* username, - const std::wstring* password) { +int HttpAuthGSSAPI::OnFirstRound(const string16* username, + const string16* password) { // TODO(cbentzel): Acquire credentials? DCHECK((username == NULL) == (password == NULL)); username_.clear(); diff --git a/net/http/http_auth_gssapi_posix.h b/net/http/http_auth_gssapi_posix.h index 746ce59..094a784 100644 --- a/net/http/http_auth_gssapi_posix.h +++ b/net/http/http_auth_gssapi_posix.h @@ -10,6 +10,7 @@ #include "base/gtest_prod_util.h" #include "base/native_library.h" +#include "base/string16.h" #include "net/http/http_auth.h" #define GSS_USE_FUNCTION_POINTERS @@ -201,7 +202,7 @@ class GSSAPISharedLibrary : public GSSAPILibrary { // scope. class ScopedSecurityContext { public: - ScopedSecurityContext(GSSAPILibrary* gssapi_lib); + explicit ScopedSecurityContext(GSSAPILibrary* gssapi_lib); ~ScopedSecurityContext(); const gss_ctx_id_t get() const { return security_context_; } @@ -238,21 +239,21 @@ class HttpAuthGSSAPI { // If this is the first round of a multiple round scheme, credentials are // obtained using |*username| and |*password|. If |username| and |password| // are NULL, the default credentials are used instead. - int GenerateAuthToken(const std::wstring* username, - const std::wstring* password, + int GenerateAuthToken(const string16* username, + const string16* password, const std::wstring& spn, std::string* auth_token); private: - int OnFirstRound(const std::wstring* username, - const std::wstring* password); + int OnFirstRound(const string16* username, + const string16* password); int GetNextSecurityToken(const std::wstring& spn, gss_buffer_t in_token, gss_buffer_t out_token); std::string scheme_; - std::wstring username_; - std::wstring password_; + string16 username_; + string16 password_; gss_OID gss_oid_; GSSAPILibrary* library_; std::string decoded_server_auth_token_; diff --git a/net/http/http_auth_handler.cc b/net/http/http_auth_handler.cc index 0bb017b..4858658 100644 --- a/net/http/http_auth_handler.cc +++ b/net/http/http_auth_handler.cc @@ -76,8 +76,8 @@ NetLog::EventType EventTypeFromAuthTarget(HttpAuth::Target target) { } // namespace -int HttpAuthHandler::GenerateAuthToken(const std::wstring* username, - const std::wstring* password, +int HttpAuthHandler::GenerateAuthToken(const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token) { diff --git a/net/http/http_auth_handler.h b/net/http/http_auth_handler.h index 179ed25..9b092cf 100644 --- a/net/http/http_auth_handler.h +++ b/net/http/http_auth_handler.h @@ -8,6 +8,7 @@ #include <string> +#include "base/string16.h" #include "base/time.h" #include "net/base/completion_callback.h" #include "net/base/net_log.h" @@ -57,8 +58,8 @@ class HttpAuthHandler { // call. // Otherwise, there was a problem generating a token synchronously, and the // value of |*auth_token| is unspecified. - int GenerateAuthToken(const std::wstring* username, - const std::wstring* password, + int GenerateAuthToken(const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token); @@ -137,8 +138,8 @@ class HttpAuthHandler { // |GenerateAuthTokenImpl()} is the auth-scheme specific implementation // of generating the next auth token. Callers sohuld use |GenerateAuthToken()| // which will in turn call |GenerateAuthTokenImpl()| - virtual int GenerateAuthTokenImpl(const std::wstring* username, - const std::wstring* password, + virtual int GenerateAuthTokenImpl(const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token) = 0; diff --git a/net/http/http_auth_handler_basic.cc b/net/http/http_auth_handler_basic.cc index efd8c5e..31edf23 100644 --- a/net/http/http_auth_handler_basic.cc +++ b/net/http/http_auth_handler_basic.cc @@ -42,14 +42,14 @@ bool HttpAuthHandlerBasic::Init(HttpAuth::ChallengeTokenizer* challenge) { } int HttpAuthHandlerBasic::GenerateAuthTokenImpl( - const std::wstring* username, - const std::wstring* password, + const string16* username, + const string16* password, const HttpRequestInfo*, CompletionCallback*, std::string* auth_token) { // TODO(eroman): is this the right encoding of username/password? std::string base64_username_password; - if (!base::Base64Encode(WideToUTF8(*username) + ":" + WideToUTF8(*password), + if (!base::Base64Encode(UTF16ToUTF8(*username) + ":" + UTF16ToUTF8(*password), &base64_username_password)) { LOG(ERROR) << "Unexpected problem Base64 encoding."; return ERR_UNEXPECTED; diff --git a/net/http/http_auth_handler_basic.h b/net/http/http_auth_handler_basic.h index a4cb28e..3204e94 100644 --- a/net/http/http_auth_handler_basic.h +++ b/net/http/http_auth_handler_basic.h @@ -6,6 +6,9 @@ #define NET_HTTP_HTTP_AUTH_HANDLER_BASIC_H_ #pragma once +#include <string> + +#include "base/string16.h" #include "net/http/http_auth_handler.h" #include "net/http/http_auth_handler_factory.h" @@ -31,8 +34,8 @@ class HttpAuthHandlerBasic : public HttpAuthHandler { protected: virtual bool Init(HttpAuth::ChallengeTokenizer* challenge); - virtual int GenerateAuthTokenImpl(const std::wstring* username, - const std::wstring* password, + virtual int GenerateAuthTokenImpl(const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token); diff --git a/net/http/http_auth_handler_basic_unittest.cc b/net/http/http_auth_handler_basic_unittest.cc index 12e8830..a758887 100644 --- a/net/http/http_auth_handler_basic_unittest.cc +++ b/net/http/http_auth_handler_basic_unittest.cc @@ -2,28 +2,30 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "testing/gtest/include/gtest/gtest.h" +#include <string> #include "base/basictypes.h" +#include "base/string_util.h" #include "net/base/net_errors.h" #include "net/http/http_auth_handler_basic.h" #include "net/http/http_request_info.h" +#include "testing/gtest/include/gtest/gtest.h" namespace net { TEST(HttpAuthHandlerBasicTest, GenerateAuthToken) { static const struct { - const wchar_t* username; - const wchar_t* password; + const char* username; + const char* password; const char* expected_credentials; } tests[] = { - { L"foo", L"bar", "Basic Zm9vOmJhcg==" }, + { "foo", "bar", "Basic Zm9vOmJhcg==" }, // Empty username - { L"", L"foobar", "Basic OmZvb2Jhcg==" }, + { "", "foobar", "Basic OmZvb2Jhcg==" }, // Empty password - { L"anon", L"", "Basic YW5vbjo=" }, + { "anon", "", "Basic YW5vbjo=" }, // Empty username and empty password. - { L"", L"", "Basic Og==" }, + { "", "", "Basic Og==" }, }; GURL origin("http://www.example.com"); HttpAuthHandlerBasic::Factory factory; @@ -32,8 +34,8 @@ TEST(HttpAuthHandlerBasicTest, GenerateAuthToken) { scoped_ptr<HttpAuthHandler> basic; EXPECT_EQ(OK, factory.CreateAuthHandlerFromString( challenge, HttpAuth::AUTH_SERVER, origin, BoundNetLog(), &basic)); - std::wstring username(tests[i].username); - std::wstring password(tests[i].password); + string16 username(ASCIIToUTF16(tests[i].username)); + string16 password(ASCIIToUTF16(tests[i].password)); HttpRequestInfo request_info; std::string auth_token; int rv = basic->GenerateAuthToken(&username, &password, &request_info, @@ -77,4 +79,4 @@ TEST(HttpAuthHandlerBasicTest, InitFromChallenge) { } } -} // namespace net +} // namespace net diff --git a/net/http/http_auth_handler_digest.cc b/net/http/http_auth_handler_digest.cc index 90090a6..c0d04d5 100644 --- a/net/http/http_auth_handler_digest.cc +++ b/net/http/http_auth_handler_digest.cc @@ -4,6 +4,8 @@ #include "net/http/http_auth_handler_digest.h" +#include <string> + #include "base/logging.h" #include "base/md5.h" #include "base/rand_util.h" @@ -86,8 +88,8 @@ std::string HttpAuthHandlerDigest::AlgorithmToString(int algorithm) { } int HttpAuthHandlerDigest::GenerateAuthTokenImpl( - const std::wstring* username, - const std::wstring* password, + const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token) { @@ -101,9 +103,8 @@ int HttpAuthHandlerDigest::GenerateAuthTokenImpl( GetRequestMethodAndPath(request, &method, &path); *auth_token = AssembleCredentials(method, path, - // TODO(eroman): is this the right encoding? - WideToUTF8(*username), - WideToUTF8(*password), + *username, + *password, cnonce, nonce_count_); return OK; } @@ -128,12 +129,14 @@ void HttpAuthHandlerDigest::GetRequestMethodAndPath( std::string HttpAuthHandlerDigest::AssembleResponseDigest( const std::string& method, const std::string& path, - const std::string& username, - const std::string& password, + const string16& username, + const string16& password, const std::string& cnonce, const std::string& nc) const { // ha1 = MD5(A1) - std::string ha1 = MD5String(username + ":" + realm_ + ":" + password); + // TODO(eroman): is this the right encoding? + std::string ha1 = MD5String(UTF16ToUTF8(username) + ":" + realm_ + ":" + + UTF16ToUTF8(password)); if (algorithm_ == HttpAuthHandlerDigest::ALGORITHM_MD5_SESS) ha1 = MD5String(ha1 + ":" + nonce_ + ":" + cnonce); @@ -152,15 +155,16 @@ std::string HttpAuthHandlerDigest::AssembleResponseDigest( std::string HttpAuthHandlerDigest::AssembleCredentials( const std::string& method, const std::string& path, - const std::string& username, - const std::string& password, + const string16& username, + const string16& password, const std::string& cnonce, int nonce_count) const { // the nonce-count is an 8 digit hex string. std::string nc = StringPrintf("%08x", nonce_count); + // TODO(eroman): is this the right encoding? std::string authorization = std::string("Digest username=") + - HttpUtil::Quote(username); + HttpUtil::Quote(UTF16ToUTF8(username)); authorization += ", realm=" + HttpUtil::Quote(realm_); authorization += ", nonce=" + HttpUtil::Quote(nonce_); authorization += ", uri=" + HttpUtil::Quote(path); @@ -219,7 +223,7 @@ bool HttpAuthHandlerDigest::ParseChallenge( if (!challenge->valid() || !LowerCaseEqualsASCII(challenge->scheme(), "digest")) - return false; // FAIL -- Couldn't match auth-scheme. + return false; // FAIL -- Couldn't match auth-scheme. // Loop through all the properties. while (challenge->GetNext()) { @@ -229,16 +233,16 @@ bool HttpAuthHandlerDigest::ParseChallenge( } if (!ParseChallengeProperty(challenge->name(), challenge->unquoted_value())) - return false; // FAIL -- couldn't parse a property. + return false; // FAIL -- couldn't parse a property. } // Check if tokenizer failed. if (!challenge->valid()) - return false; // FAIL + return false; // FAIL // Check that a minimum set of properties were provided. if (nonce_.empty()) - return false; // FAIL + return false; // FAIL return true; } @@ -264,7 +268,7 @@ bool HttpAuthHandlerDigest::ParseChallengeProperty(const std::string& name, algorithm_ = ALGORITHM_MD5_SESS; } else { DLOG(INFO) << "Unknown value of algorithm"; - return false; // FAIL -- unsupported value of algorithm. + return false; // FAIL -- unsupported value of algorithm. } } else if (LowerCaseEqualsASCII(name, "qop")) { // Parse the comma separated list of qops. diff --git a/net/http/http_auth_handler_digest.h b/net/http/http_auth_handler_digest.h index bf3aa77..1b03d17 100644 --- a/net/http/http_auth_handler_digest.h +++ b/net/http/http_auth_handler_digest.h @@ -6,6 +6,9 @@ #define NET_HTTP_HTTP_AUTH_HANDLER_DIGEST_H_ #pragma once +#include <string> + +#include "base/string16.h" #include "net/http/http_auth_handler.h" #include "net/http/http_auth_handler_factory.h" @@ -36,8 +39,8 @@ class HttpAuthHandlerDigest : public HttpAuthHandler { return ParseChallenge(challenge); } - virtual int GenerateAuthTokenImpl(const std::wstring* username, - const std::wstring* password, + virtual int GenerateAuthTokenImpl(const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token); @@ -97,16 +100,16 @@ class HttpAuthHandlerDigest : public HttpAuthHandler { // Build up the 'response' production. std::string AssembleResponseDigest(const std::string& method, const std::string& path, - const std::string& username, - const std::string& password, + const string16& username, + const string16& password, const std::string& cnonce, const std::string& nc) const; // Build up the value for (Authorization/Proxy-Authorization). std::string AssembleCredentials(const std::string& method, const std::string& path, - const std::string& username, - const std::string& password, + const string16& username, + const string16& password, const std::string& cnonce, int nonce_count) const; @@ -121,7 +124,7 @@ class HttpAuthHandlerDigest : public HttpAuthHandler { std::string opaque_; bool stale_; DigestAlgorithm algorithm_; - int qop_; // Bitfield of QualityOfProtection + int qop_; // Bitfield of QualityOfProtection int nonce_count_; diff --git a/net/http/http_auth_handler_digest_unittest.cc b/net/http/http_auth_handler_digest_unittest.cc index b1782f6..c563aae 100644 --- a/net/http/http_auth_handler_digest_unittest.cc +++ b/net/http/http_auth_handler_digest_unittest.cc @@ -2,11 +2,13 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "testing/gtest/include/gtest/gtest.h" +#include <string> #include "base/basictypes.h" +#include "base/string_util.h" #include "net/base/net_errors.h" #include "net/http/http_auth_handler_digest.h" +#include "testing/gtest/include/gtest/gtest.h" namespace net { @@ -276,12 +278,13 @@ TEST(HttpAuthHandlerDigestTest, AssembleCredentials) { HttpAuthHandlerDigest* digest = static_cast<HttpAuthHandlerDigest*>(handler.get()); - std::string creds = digest->AssembleCredentials(tests[i].req_method, - tests[i].req_path, - tests[i].username, - tests[i].password, - tests[i].cnonce, - tests[i].nonce_count); + std::string creds = + digest->AssembleCredentials(tests[i].req_method, + tests[i].req_path, + ASCIIToUTF16(tests[i].username), + ASCIIToUTF16(tests[i].password), + tests[i].cnonce, + tests[i].nonce_count); EXPECT_STREQ(tests[i].expected_creds, creds.c_str()); } diff --git a/net/http/http_auth_handler_mock.cc b/net/http/http_auth_handler_mock.cc index 09a03561..983105b 100644 --- a/net/http/http_auth_handler_mock.cc +++ b/net/http/http_auth_handler_mock.cc @@ -76,8 +76,8 @@ bool HttpAuthHandlerMock::Init(HttpAuth::ChallengeTokenizer* challenge) { return true; } -int HttpAuthHandlerMock::GenerateAuthTokenImpl(const std::wstring* username, - const std::wstring* password, +int HttpAuthHandlerMock::GenerateAuthTokenImpl(const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token) { diff --git a/net/http/http_auth_handler_mock.h b/net/http/http_auth_handler_mock.h index c99092a..f9a676c 100644 --- a/net/http/http_auth_handler_mock.h +++ b/net/http/http_auth_handler_mock.h @@ -8,6 +8,7 @@ #include <string> +#include "base/string16.h" #include "base/task.h" #include "net/http/http_auth_handler.h" #include "net/http/http_auth_handler_factory.h" @@ -69,8 +70,8 @@ class HttpAuthHandlerMock : public HttpAuthHandler { protected: virtual bool Init(HttpAuth::ChallengeTokenizer* challenge); - virtual int GenerateAuthTokenImpl(const std::wstring* username, - const std::wstring* password, + virtual int GenerateAuthTokenImpl(const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token); diff --git a/net/http/http_auth_handler_negotiate.cc b/net/http/http_auth_handler_negotiate.cc index d7a9c50..889dea2 100644 --- a/net/http/http_auth_handler_negotiate.cc +++ b/net/http/http_auth_handler_negotiate.cc @@ -44,8 +44,8 @@ HttpAuthHandlerNegotiate::~HttpAuthHandlerNegotiate() { } int HttpAuthHandlerNegotiate::GenerateAuthTokenImpl( - const std::wstring* username, - const std::wstring* password, + const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token) { @@ -223,8 +223,8 @@ int HttpAuthHandlerNegotiate::DoResolveCanonicalNameComplete(int rv) { int HttpAuthHandlerNegotiate::DoGenerateAuthToken() { next_state_ = STATE_GENERATE_AUTH_TOKEN_COMPLETE; - std::wstring* username = has_username_and_password_ ? &username_ : NULL; - std::wstring* password = has_username_and_password_ ? &password_ : NULL; + string16* username = has_username_and_password_ ? &username_ : NULL; + string16* password = has_username_and_password_ ? &password_ : NULL; // TODO(cbentzel): This should possibly be done async. return auth_system_.GenerateAuthToken(username, password, spn_, auth_token_); } diff --git a/net/http/http_auth_handler_negotiate.h b/net/http/http_auth_handler_negotiate.h index abc18ef..005e665 100644 --- a/net/http/http_auth_handler_negotiate.h +++ b/net/http/http_auth_handler_negotiate.h @@ -8,8 +8,7 @@ #include <string> -#include "build/build_config.h" - +#include "base/string16.h" #include "build/build_config.h" #include "net/base/address_list.h" #include "net/http/http_auth_handler.h" @@ -119,8 +118,8 @@ class HttpAuthHandlerNegotiate : public HttpAuthHandler { protected: virtual bool Init(HttpAuth::ChallengeTokenizer* challenge); - virtual int GenerateAuthTokenImpl(const std::wstring* username, - const std::wstring* password, + virtual int GenerateAuthTokenImpl(const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token); @@ -156,8 +155,8 @@ class HttpAuthHandlerNegotiate : public HttpAuthHandler { // Things which should be consistent after first call to GenerateAuthToken. bool already_called_; bool has_username_and_password_; - std::wstring username_; - std::wstring password_; + string16 username_; + string16 password_; std::wstring spn_; // Things which vary each round. diff --git a/net/http/http_auth_handler_negotiate_unittest.cc b/net/http/http_auth_handler_negotiate_unittest.cc index 4fcdad1..75063ca 100644 --- a/net/http/http_auth_handler_negotiate_unittest.cc +++ b/net/http/http_auth_handler_negotiate_unittest.cc @@ -4,6 +4,7 @@ #include "net/http/http_auth_handler_negotiate.h" +#include "base/string_util.h" #include "net/base/mock_host_resolver.h" #include "net/base/net_errors.h" #include "net/base/test_completion_callback.h" @@ -225,8 +226,8 @@ TEST_F(HttpAuthHandlerNegotiateTest, DisableCname) { TestCompletionCallback callback; HttpRequestInfo request_info; std::string token; - std::wstring username = L"foo"; - std::wstring password = L"bar"; + string16 username = ASCIIToUTF16("foo"); + string16 password = ASCIIToUTF16("bar"); EXPECT_EQ(OK, auth_handler->GenerateAuthToken(&username, &password, &request_info, &callback, &token)); @@ -246,8 +247,8 @@ TEST_F(HttpAuthHandlerNegotiateTest, DisableCnameStandardPort) { TestCompletionCallback callback; HttpRequestInfo request_info; std::string token; - std::wstring username = L"foo"; - std::wstring password = L"bar"; + string16 username = ASCIIToUTF16("foo"); + string16 password = ASCIIToUTF16("bar"); EXPECT_EQ(OK, auth_handler->GenerateAuthToken(&username, &password, &request_info, &callback, &token)); @@ -267,8 +268,8 @@ TEST_F(HttpAuthHandlerNegotiateTest, DisableCnameNonstandardPort) { TestCompletionCallback callback; HttpRequestInfo request_info; std::string token; - std::wstring username = L"foo"; - std::wstring password = L"bar"; + string16 username = ASCIIToUTF16("foo"); + string16 password = ASCIIToUTF16("bar"); EXPECT_EQ(OK, auth_handler->GenerateAuthToken(&username, &password, &request_info, &callback, &token)); @@ -288,8 +289,8 @@ TEST_F(HttpAuthHandlerNegotiateTest, CnameSync) { TestCompletionCallback callback; HttpRequestInfo request_info; std::string token; - std::wstring username = L"foo"; - std::wstring password = L"bar"; + string16 username = ASCIIToUTF16("foo"); + string16 password = ASCIIToUTF16("bar"); EXPECT_EQ(OK, auth_handler->GenerateAuthToken(&username, &password, &request_info, &callback, &token)); @@ -309,8 +310,8 @@ TEST_F(HttpAuthHandlerNegotiateTest, CnameAsync) { TestCompletionCallback callback; HttpRequestInfo request_info; std::string token; - std::wstring username = L"foo"; - std::wstring password = L"bar"; + string16 username = ASCIIToUTF16("foo"); + string16 password = ASCIIToUTF16("bar"); EXPECT_EQ(ERR_IO_PENDING, auth_handler->GenerateAuthToken( &username, &password, &request_info, &callback, &token)); EXPECT_EQ(OK, callback.WaitForResult()); diff --git a/net/http/http_auth_handler_ntlm.cc b/net/http/http_auth_handler_ntlm.cc index d8e8a75..3191df6 100644 --- a/net/http/http_auth_handler_ntlm.cc +++ b/net/http/http_auth_handler_ntlm.cc @@ -14,8 +14,8 @@ namespace net { int HttpAuthHandlerNTLM::GenerateAuthTokenImpl( - const std::wstring* username, - const std::wstring* password, + const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token) { @@ -36,8 +36,8 @@ int HttpAuthHandlerNTLM::GenerateAuthTokenImpl( // |username| may be in the form "DOMAIN\user". Parse it into the two // components. - std::wstring domain; - std::wstring user; + string16 domain; + string16 user; size_t backslash_idx = username->find(L'\\'); if (backslash_idx == std::wstring::npos) { user = *username; @@ -45,9 +45,9 @@ int HttpAuthHandlerNTLM::GenerateAuthTokenImpl( domain = username->substr(0, backslash_idx); user = username->substr(backslash_idx + 1); } - domain_ = WideToUTF16(domain); - username_ = WideToUTF16(user); - password_ = WideToUTF16(*password); + domain_ = domain; + username_ = user; + password_ = *password; // Initial challenge. if (auth_data_.empty()) { diff --git a/net/http/http_auth_handler_ntlm.h b/net/http/http_auth_handler_ntlm.h index 3cefc56..00d6905 100644 --- a/net/http/http_auth_handler_ntlm.h +++ b/net/http/http_auth_handler_ntlm.h @@ -117,8 +117,8 @@ class HttpAuthHandlerNTLM : public HttpAuthHandler { return ParseChallenge(tok); } - virtual int GenerateAuthTokenImpl(const std::wstring* username, - const std::wstring* password, + virtual int GenerateAuthTokenImpl(const string16* username, + const string16* password, const HttpRequestInfo* request, CompletionCallback* callback, std::string* auth_token); diff --git a/net/http/http_auth_handler_unittest.cc b/net/http/http_auth_handler_unittest.cc index 2516745..62ecf22 100644 --- a/net/http/http_auth_handler_unittest.cc +++ b/net/http/http_auth_handler_unittest.cc @@ -4,6 +4,7 @@ #include "net/http/http_auth_handler.h" +#include "base/string_util.h" #include "net/base/capturing_net_log.h" #include "net/base/net_errors.h" #include "net/base/net_log_unittest.h" @@ -18,8 +19,8 @@ TEST(HttpAuthHandlerTest, NetLog) { NetLog::Source source; GURL origin("http://www.example.com"); std::string challenge = "Mock asdf"; - std::wstring username = L"user"; - std::wstring password = L"pass"; + string16 username = ASCIIToUTF16("user"); + string16 password = ASCIIToUTF16("pass"); std::string auth_token; HttpRequestInfo request; diff --git a/net/http/http_auth_sspi_win.cc b/net/http/http_auth_sspi_win.cc index 221acf1..9c195df 100644 --- a/net/http/http_auth_sspi_win.cc +++ b/net/http/http_auth_sspi_win.cc @@ -11,6 +11,7 @@ #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" @@ -43,9 +44,9 @@ int MapAcquireCredentialsStatusToError(SECURITY_STATUS status, 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; @@ -159,8 +160,8 @@ bool HttpAuthSSPI::ParseChallenge(HttpAuth::ChallengeTokenizer* tok) { 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)); @@ -199,14 +200,14 @@ int HttpAuthSSPI::GenerateAuthToken(const std::wstring* username, 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_); @@ -300,14 +301,14 @@ int HttpAuthSSPI::GetNextSecurityToken( 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 { diff --git a/net/http/http_auth_sspi_win.h b/net/http/http_auth_sspi_win.h index 95775ae..bf1778f 100644 --- a/net/http/http_auth_sspi_win.h +++ b/net/http/http_auth_sspi_win.h @@ -17,6 +17,7 @@ #include <string> +#include "base/string16.h" #include "net/http/http_auth.h" namespace net { @@ -93,14 +94,14 @@ class HttpAuthSSPI { // obtained using |*username| and |*password|. If |username| and |password| // are both NULL, the credentials for the currently logged in user are used // instead. - int GenerateAuthToken(const std::wstring* username, - const std::wstring* password, + int GenerateAuthToken(const string16* username, + const string16* password, const std::wstring& spn, std::string* auth_token); private: - int OnFirstRound(const std::wstring* username, - const std::wstring* password); + int OnFirstRound(const string16* username, + const string16* password); int GetNextSecurityToken( const std::wstring& spn, @@ -126,9 +127,9 @@ class HttpAuthSSPI { // If |combined| is of form "bar", |domain| will be empty and |user| will // contain "bar". // |domain| and |user| must be non-NULL. -void SplitDomainAndUser(const std::wstring& combined, - std::wstring* domain, - std::wstring* user); +void SplitDomainAndUser(const string16& combined, + string16* domain, + string16* user); // Determines the maximum token length in bytes for a particular SSPI package. // diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc index 2ea08b8..bbd42f8 100644 --- a/net/http/http_cache_transaction.cc +++ b/net/http/http_cache_transaction.cc @@ -4,12 +4,15 @@ #include "net/http/http_cache_transaction.h" -#include "base/compiler_specific.h" +#include "build/build_config.h" #if defined(OS_POSIX) #include <unistd.h> #endif +#include <string> + +#include "base/compiler_specific.h" #include "base/histogram.h" #include "base/ref_counted.h" #include "base/string_util.h" @@ -223,8 +226,8 @@ int HttpCache::Transaction::RestartWithCertificate( } int HttpCache::Transaction::RestartWithAuth( - const std::wstring& username, - const std::wstring& password, + const string16& username, + const string16& password, CompletionCallback* callback) { DCHECK(auth_response_.headers); DCHECK(callback); @@ -1497,8 +1500,8 @@ int HttpCache::Transaction::RestartNetworkRequestWithCertificate( } int HttpCache::Transaction::RestartNetworkRequestWithAuth( - const std::wstring& username, - const std::wstring& password) { + const string16& username, + const string16& password) { DCHECK(mode_ & WRITE || mode_ == NONE); DCHECK(network_trans_.get()); DCHECK_EQ(STATE_NONE, next_state_); diff --git a/net/http/http_cache_transaction.h b/net/http/http_cache_transaction.h index bd9dc75..05a8484 100644 --- a/net/http/http_cache_transaction.h +++ b/net/http/http_cache_transaction.h @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2010 The Chromium Authors. All rights reserved. +// 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. @@ -9,8 +9,11 @@ #define NET_HTTP_HTTP_CACHE_TRANSACTION_H_ #pragma once -#include "net/base/net_log.h" +#include <string> + +#include "base/string16.h" #include "base/time.h" +#include "net/base/net_log.h" #include "net/http/http_cache.h" #include "net/http/http_response_info.h" #include "net/http/http_transaction.h" @@ -33,8 +36,8 @@ class HttpCache::Transaction : public HttpTransaction { virtual int RestartIgnoringLastError(CompletionCallback* callback); virtual int RestartWithCertificate(X509Certificate* client_cert, CompletionCallback* callback); - virtual int RestartWithAuth(const std::wstring& username, - const std::wstring& password, + virtual int RestartWithAuth(const string16& username, + const string16& password, CompletionCallback* callback); virtual bool IsReadyToRestartForAuth(); virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback); @@ -250,8 +253,8 @@ class HttpCache::Transaction : public HttpTransaction { // Called to restart a network transaction with authentication credentials. // Returns network error code. - int RestartNetworkRequestWithAuth(const std::wstring& username, - const std::wstring& password); + int RestartNetworkRequestWithAuth(const string16& username, + const string16& password); // Called to determine if we need to validate the cache entry before using it. bool RequiresValidation(); diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc index 789170a..3fa59bf 100644 --- a/net/http/http_network_transaction.cc +++ b/net/http/http_network_transaction.cc @@ -318,8 +318,8 @@ int HttpNetworkTransaction::RestartWithCertificate( } int HttpNetworkTransaction::RestartWithAuth( - const std::wstring& username, - const std::wstring& password, + const string16& username, + const string16& password, CompletionCallback* callback) { HttpAuth::Target target = pending_auth_target_; if (target == HttpAuth::AUTH_NONE) { diff --git a/net/http/http_network_transaction.h b/net/http/http_network_transaction.h index ec35ced..3fa0e67 100644 --- a/net/http/http_network_transaction.h +++ b/net/http/http_network_transaction.h @@ -11,6 +11,7 @@ #include "base/basictypes.h" #include "base/ref_counted.h" #include "base/scoped_ptr.h" +#include "base/string16.h" #include "base/time.h" #include "net/base/address_list.h" #include "net/base/io_buffer.h" @@ -68,8 +69,8 @@ class HttpNetworkTransaction : public HttpTransaction { virtual int RestartIgnoringLastError(CompletionCallback* callback); virtual int RestartWithCertificate(X509Certificate* client_cert, CompletionCallback* callback); - virtual int RestartWithAuth(const std::wstring& username, - const std::wstring& password, + virtual int RestartWithAuth(const string16& username, + const string16& password, CompletionCallback* callback); virtual bool IsReadyToRestartForAuth() { return pending_auth_target_ != HttpAuth::AUTH_NONE && diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc index 11c3965..09b0029 100644 --- a/net/http/http_network_transaction_unittest.cc +++ b/net/http/http_network_transaction_unittest.cc @@ -44,6 +44,23 @@ //----------------------------------------------------------------------------- +namespace { + +const string16 kBar(ASCIIToUTF16("bar")); +const string16 kBar2(ASCIIToUTF16("bar2")); +const string16 kBar3(ASCIIToUTF16("bar3")); +const string16 kBaz(ASCIIToUTF16("baz")); +const string16 kFirst(ASCIIToUTF16("first")); +const string16 kFoo(ASCIIToUTF16("foo")); +const string16 kFoo2(ASCIIToUTF16("foo2")); +const string16 kFoo3(ASCIIToUTF16("foo3")); +const string16 kFou(ASCIIToUTF16("fou")); +const string16 kSecond(ASCIIToUTF16("second")); +const string16 kTestingNTLM(ASCIIToUTF16("testing-ntlm")); +const string16 kWrongPassword(ASCIIToUTF16("wrongpassword")); + +} // namespace + namespace net { class HttpNetworkSessionPeer { @@ -945,7 +962,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuth) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback2); + rv = trans->RestartWithAuth(kFoo, kBar, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -1061,7 +1078,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthKeepAlive) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback2); + rv = trans->RestartWithAuth(kFoo, kBar, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -1134,7 +1151,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthKeepAliveNoBody) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback2); + rv = trans->RestartWithAuth(kFoo, kBar, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -1215,7 +1232,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthKeepAliveLargeBody) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback2); + rv = trans->RestartWithAuth(kFoo, kBar, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -1306,7 +1323,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthKeepAliveImpatientServer) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback2); + rv = trans->RestartWithAuth(kFoo, kBar, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -1404,7 +1421,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthProxyKeepAlive) { TestCompletionCallback callback2; // Wrong password (should be "bar"). - rv = trans->RestartWithAuth(L"foo", L"baz", &callback2); + rv = trans->RestartWithAuth(kFoo, kBaz, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -1842,7 +1859,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthProxyThenServer) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback2); + rv = trans->RestartWithAuth(kFoo, kBar, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -1858,7 +1875,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthProxyThenServer) { TestCompletionCallback callback3; - rv = trans->RestartWithAuth(L"foo2", L"bar2", &callback3); + rv = trans->RestartWithAuth(kFoo2, kBar2, &callback3); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback3.WaitForResult(); @@ -1972,7 +1989,7 @@ TEST_F(HttpNetworkTransactionTest, NTLMAuth1) { EXPECT_TRUE(trans->IsReadyToRestartForAuth()); TestCompletionCallback callback2; - rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2); + rv = trans->RestartWithAuth(string16(), string16(), &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); EXPECT_EQ(OK, rv); @@ -1991,7 +2008,7 @@ TEST_F(HttpNetworkTransactionTest, NTLMAuth1) { TestCompletionCallback callback3; - rv = trans->RestartWithAuth(L"testing-ntlm", L"testing-ntlm", &callback3); + rv = trans->RestartWithAuth(kTestingNTLM, kTestingNTLM, &callback3); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback3.WaitForResult(); @@ -2150,7 +2167,7 @@ TEST_F(HttpNetworkTransactionTest, NTLMAuth2) { EXPECT_TRUE(trans->IsReadyToRestartForAuth()); TestCompletionCallback callback2; - rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2); + rv = trans->RestartWithAuth(string16(), string16(), &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); EXPECT_EQ(OK, rv); @@ -2169,7 +2186,7 @@ TEST_F(HttpNetworkTransactionTest, NTLMAuth2) { TestCompletionCallback callback3; // Enter the wrong password. - rv = trans->RestartWithAuth(L"testing-ntlm", L"wrongpassword", &callback3); + rv = trans->RestartWithAuth(kTestingNTLM, kWrongPassword, &callback3); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback3.WaitForResult(); @@ -2177,7 +2194,7 @@ TEST_F(HttpNetworkTransactionTest, NTLMAuth2) { EXPECT_TRUE(trans->IsReadyToRestartForAuth()); TestCompletionCallback callback4; - rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback4); + rv = trans->RestartWithAuth(string16(), string16(), &callback4); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback4.WaitForResult(); EXPECT_EQ(OK, rv); @@ -2196,7 +2213,7 @@ TEST_F(HttpNetworkTransactionTest, NTLMAuth2) { TestCompletionCallback callback5; // Now enter the right password. - rv = trans->RestartWithAuth(L"testing-ntlm", L"testing-ntlm", &callback5); + rv = trans->RestartWithAuth(kTestingNTLM, kTestingNTLM, &callback5); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback5.WaitForResult(); @@ -2569,7 +2586,7 @@ TEST_F(HttpNetworkTransactionTest, AuthIdentityInURL) { EXPECT_TRUE(trans->IsReadyToRestartForAuth()); TestCompletionCallback callback2; - rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2); + rv = trans->RestartWithAuth(string16(), string16(), &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); EXPECT_EQ(OK, rv); @@ -2667,7 +2684,7 @@ TEST_F(HttpNetworkTransactionTest, WrongAuthIdentityInURL) { EXPECT_TRUE(trans->IsReadyToRestartForAuth()); TestCompletionCallback callback2; - rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2); + rv = trans->RestartWithAuth(string16(), string16(), &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); EXPECT_EQ(OK, rv); @@ -2683,7 +2700,7 @@ TEST_F(HttpNetworkTransactionTest, WrongAuthIdentityInURL) { EXPECT_EQ(L"basic", response->auth_challenge->scheme); TestCompletionCallback callback3; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback3); + rv = trans->RestartWithAuth(kFoo, kBar, &callback3); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback3.WaitForResult(); EXPECT_EQ(OK, rv); @@ -2771,7 +2788,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthCacheAndPreauth) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback2); + rv = trans->RestartWithAuth(kFoo, kBar, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -2856,7 +2873,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthCacheAndPreauth) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo2", L"bar2", &callback2); + rv = trans->RestartWithAuth(kFoo2, kBar2, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -2972,7 +2989,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthCacheAndPreauth) { EXPECT_TRUE(trans->IsReadyToRestartForAuth()); TestCompletionCallback callback2; - rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2); + rv = trans->RestartWithAuth(string16(), string16(), &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); EXPECT_EQ(OK, rv); @@ -3061,7 +3078,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthCacheAndPreauth) { EXPECT_TRUE(trans->IsReadyToRestartForAuth()); TestCompletionCallback callback2; - rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2); + rv = trans->RestartWithAuth(string16(), string16(), &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); EXPECT_EQ(OK, rv); @@ -3080,7 +3097,7 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthCacheAndPreauth) { TestCompletionCallback callback3; - rv = trans->RestartWithAuth(L"foo3", L"bar3", &callback3); + rv = trans->RestartWithAuth(kFoo3, kBar3, &callback3); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback3.WaitForResult(); @@ -3167,7 +3184,7 @@ TEST_F(HttpNetworkTransactionTest, DigestPreAuthNonceCount) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback2); + rv = trans->RestartWithAuth(kFoo, kBar, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -4528,7 +4545,7 @@ TEST_F(HttpNetworkTransactionTest, DrainResetOK) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback2); + rv = trans->RestartWithAuth(kFoo, kBar, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -4796,7 +4813,7 @@ TEST_F(HttpNetworkTransactionTest, UnreadableUploadFileAfterAuthRestart) { TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"foo", L"bar", &callback2); + rv = trans->RestartWithAuth(kFoo, kBar, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); @@ -4915,7 +4932,7 @@ TEST_F(HttpNetworkTransactionTest, ChangeAuthRealms) { // password prompt for second_realm waiting to be filled in after the // transaction completes. TestCompletionCallback callback2; - rv = trans->RestartWithAuth(L"first", L"baz", &callback2); + rv = trans->RestartWithAuth(kFirst, kBaz, &callback2); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback2.WaitForResult(); EXPECT_EQ(OK, rv); @@ -4931,7 +4948,7 @@ TEST_F(HttpNetworkTransactionTest, ChangeAuthRealms) { // prompt is not present, it indicates that the HttpAuthCacheEntry for // first_realm was not correctly removed. TestCompletionCallback callback3; - rv = trans->RestartWithAuth(L"second", L"fou", &callback3); + rv = trans->RestartWithAuth(kSecond, kFou, &callback3); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback3.WaitForResult(); EXPECT_EQ(OK, rv); @@ -4944,7 +4961,7 @@ TEST_F(HttpNetworkTransactionTest, ChangeAuthRealms) { // Issue the fourth request with the correct password and username. TestCompletionCallback callback4; - rv = trans->RestartWithAuth(L"first", L"bar", &callback4); + rv = trans->RestartWithAuth(kFirst, kBar, &callback4); EXPECT_EQ(ERR_IO_PENDING, rv); rv = callback4.WaitForResult(); EXPECT_EQ(OK, rv); @@ -5896,7 +5913,7 @@ TEST_F(HttpNetworkTransactionTest, GenerateAuthToken) { if (round == 0) { rv = trans->Start(&request, &callback, BoundNetLog()); } else { - rv = trans->RestartWithAuth(L"foo", L"bar", &callback); + rv = trans->RestartWithAuth(kFoo, kBar, &callback); } if (rv == ERR_IO_PENDING) rv = callback.WaitForResult(); @@ -6008,7 +6025,7 @@ TEST_F(HttpNetworkTransactionTest, MultiRoundAuth) { // Second round auth_handler->SetGenerateExpectation(false, OK); - rv = trans->RestartWithAuth(L"foo", L"bar", &callback); + rv = trans->RestartWithAuth(kFoo, kBar, &callback); if (rv == ERR_IO_PENDING) rv = callback.WaitForResult(); EXPECT_EQ(OK, rv); @@ -6018,7 +6035,7 @@ TEST_F(HttpNetworkTransactionTest, MultiRoundAuth) { // Third round auth_handler->SetGenerateExpectation(false, OK); - rv = trans->RestartWithAuth(L"", L"", &callback); + rv = trans->RestartWithAuth(string16(), string16(), &callback); if (rv == ERR_IO_PENDING) rv = callback.WaitForResult(); EXPECT_EQ(OK, rv); diff --git a/net/http/http_transaction.h b/net/http/http_transaction.h index 9e7d028..690d521 100644 --- a/net/http/http_transaction.h +++ b/net/http/http_transaction.h @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. +// 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. @@ -6,8 +6,7 @@ #define NET_HTTP_HTTP_TRANSACTION_H_ #pragma once -#include <string> - +#include "base/string16.h" #include "net/base/completion_callback.h" #include "net/base/load_states.h" @@ -62,8 +61,8 @@ class HttpTransaction { CompletionCallback* callback) = 0; // Restarts the HTTP transaction with authentication credentials. - virtual int RestartWithAuth(const std::wstring& username, - const std::wstring& password, + virtual int RestartWithAuth(const string16& username, + const string16& password, CompletionCallback* callback) = 0; // Returns true if auth is ready to be continued. Callers should check diff --git a/net/http/http_transaction_unittest.h b/net/http/http_transaction_unittest.h index 6b8d428..47629b5 100644 --- a/net/http/http_transaction_unittest.h +++ b/net/http/http_transaction_unittest.h @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. +// 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. @@ -14,6 +14,7 @@ #include "base/callback.h" #include "base/compiler_specific.h" #include "base/message_loop.h" +#include "base/string16.h" #include "base/string_util.h" #include "net/base/io_buffer.h" #include "net/base/net_errors.h" @@ -260,8 +261,8 @@ class MockNetworkTransaction : public net::HttpTransaction { return net::ERR_FAILED; } - virtual int RestartWithAuth(const std::wstring& username, - const std::wstring& password, + virtual int RestartWithAuth(const string16& username, + const string16& password, net::CompletionCallback* callback) { return net::ERR_FAILED; } diff --git a/net/socket/socket_test_util.cc b/net/socket/socket_test_util.cc index 0d75516..8ff6ace 100644 --- a/net/socket/socket_test_util.cc +++ b/net/socket/socket_test_util.cc @@ -920,8 +920,8 @@ int MockHttpAuthController::HandleAuthChallenge( return OK; } -void MockHttpAuthController::ResetAuth(const std::wstring& username, - const std::wstring& password) { +void MockHttpAuthController::ResetAuth(const string16& username, + const string16& password) { data_index_++; } diff --git a/net/socket/socket_test_util.h b/net/socket/socket_test_util.h index d2dd31a..1a0ab11 100644 --- a/net/socket/socket_test_util.h +++ b/net/socket/socket_test_util.h @@ -16,6 +16,7 @@ #include "base/logging.h" #include "base/scoped_ptr.h" #include "base/scoped_vector.h" +#include "base/string16.h" #include "net/base/address_list.h" #include "net/base/io_buffer.h" #include "net/base/net_errors.h" @@ -636,8 +637,8 @@ class MockTCPClientSocketPool : public TCPClientSocketPool { const scoped_refptr<ClientSocketPoolHistograms>& histograms, ClientSocketFactory* socket_factory); - int release_count() const { return release_count_; }; - int cancel_count() const { return cancel_count_; }; + int release_count() const { return release_count_; } + int cancel_count() const { return cancel_count_; } // TCPClientSocketPool methods. virtual int RequestSocket(const std::string& group_name, @@ -695,7 +696,8 @@ class MockSOCKSClientSocketPool : public SOCKSClientSocketPool { }; struct MockHttpAuthControllerData { - MockHttpAuthControllerData(std::string header) : auth_header(header) {} + explicit MockHttpAuthControllerData(std::string header) + : auth_header(header) {} std::string auth_header; }; @@ -716,8 +718,8 @@ class MockHttpAuthController : public HttpAuthController { bool do_not_send_server_auth, bool establishing_tunnel, const BoundNetLog& net_log); - virtual void ResetAuth(const std::wstring& username, - const std::wstring& password); + virtual void ResetAuth(const string16& username, + const string16& password); virtual bool HaveAuthHandler() const; virtual bool HaveAuth() const; diff --git a/net/socket/ssl_client_socket_pool_unittest.cc b/net/socket/ssl_client_socket_pool_unittest.cc index 64cae4c..d8b6339 100644 --- a/net/socket/ssl_client_socket_pool_unittest.cc +++ b/net/socket/ssl_client_socket_pool_unittest.cc @@ -77,7 +77,6 @@ class SSLClientSocketPoolTest : public ClientSocketPoolTest { scoped_refptr<SSLSocketParams> SSLParams( ProxyServer::Scheme proxy, struct MockHttpAuthControllerData* auth_data, size_t auth_data_len, bool want_spdy_over_ssl, bool want_spdy_over_npn) { - scoped_refptr<HttpProxySocketParams> http_proxy_params; if (proxy == ProxyServer::SCHEME_HTTP) { scoped_refptr<MockHttpAuthController> auth_controller = @@ -641,8 +640,8 @@ TEST_F(SSLClientSocketPoolTest, DoProxyAuth) { const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info(); EXPECT_EQ(tunnel_info.headers->response_code(), 407); - params->http_proxy_params()->auth_controller()->ResetAuth(std::wstring(), - std::wstring()); + params->http_proxy_params()->auth_controller()->ResetAuth(string16(), + string16()); rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); EXPECT_FALSE(handle.is_initialized()); @@ -710,8 +709,8 @@ TEST_F(SSLClientSocketPoolTest, DoProxyAuthNoKeepAlive) { const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info(); EXPECT_EQ(tunnel_info.headers->response_code(), 407); - params->http_proxy_params()->auth_controller()->ResetAuth(std::wstring(), - std::wstring()); + params->http_proxy_params()->auth_controller()->ResetAuth(string16(), + string16()); rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); EXPECT_EQ(ERR_IO_PENDING, rv); EXPECT_FALSE(handle.is_initialized()); diff --git a/net/socket_stream/socket_stream.cc b/net/socket_stream/socket_stream.cc index c1216d7..6e7f270 100644 --- a/net/socket_stream/socket_stream.cc +++ b/net/socket_stream/socket_stream.cc @@ -196,7 +196,7 @@ void SocketStream::Close() { } void SocketStream::RestartWithAuth( - const std::wstring& username, const std::wstring& password) { + const string16& username, const string16& password) { DCHECK(MessageLoop::current()) << "The current MessageLoop must exist"; DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) << diff --git a/net/socket_stream/socket_stream.h b/net/socket_stream/socket_stream.h index 74b87cf..860f785 100644 --- a/net/socket_stream/socket_stream.h +++ b/net/socket_stream/socket_stream.h @@ -14,6 +14,7 @@ #include "base/linked_ptr.h" #include "base/ref_counted.h" #include "base/scoped_ptr.h" +#include "base/string16.h" #include "base/task.h" #include "net/base/address_list.h" #include "net/base/completion_callback.h" @@ -133,8 +134,8 @@ class SocketStream : public base::RefCountedThreadSafe<SocketStream> { // Restarts with authentication info. // Should be used for response of OnAuthRequired. virtual void RestartWithAuth( - const std::wstring& username, - const std::wstring& password); + const string16& username, + const string16& password); // Detach delegate. Call before delegate is deleted. // Once delegate is detached, close the socket stream and never call delegate diff --git a/net/socket_stream/socket_stream_job.h b/net/socket_stream/socket_stream_job.h index 086aa79..89e0c36 100644 --- a/net/socket_stream/socket_stream_job.h +++ b/net/socket_stream/socket_stream_job.h @@ -9,6 +9,7 @@ #include <string> #include "base/ref_counted.h" +#include "base/string16.h" #include "net/socket_stream/socket_stream.h" class GURL; @@ -65,8 +66,8 @@ class SocketStreamJob : public base::RefCountedThreadSafe<SocketStreamJob> { } virtual void RestartWithAuth( - const std::wstring& username, - const std::wstring& password) { + const string16& username, + const string16& password) { socket_->RestartWithAuth(username, password); } diff --git a/net/socket_stream/socket_stream_unittest.cc b/net/socket_stream/socket_stream_unittest.cc index d32654a..def766c 100644 --- a/net/socket_stream/socket_stream_unittest.cc +++ b/net/socket_stream/socket_stream_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// 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. @@ -119,8 +119,8 @@ class SocketStreamEventRecorder : public net::SocketStream::Delegate { << " password=" << password_; event->socket->RestartWithAuth(username_, password_); } - void SetAuthInfo(const std::wstring& username, - const std::wstring& password) { + void SetAuthInfo(const string16& username, + const string16& password) { username_ = username; password_ = password; } @@ -138,8 +138,8 @@ class SocketStreamEventRecorder : public net::SocketStream::Delegate { Callback1<SocketStreamEvent*>::Type* on_auth_required_; net::CompletionCallback* callback_; - std::wstring username_; - std::wstring password_; + string16 username_; + string16 password_; DISALLOW_COPY_AND_ASSIGN(SocketStreamEventRecorder); }; @@ -318,9 +318,7 @@ TEST_F(SocketStreamTest, BasicAuthProxy) { new SocketStreamEventRecorder(&callback)); delegate->SetOnConnected(NewCallback(delegate.get(), &SocketStreamEventRecorder::DoClose)); - const std::wstring kUsername = L"foo"; - const std::wstring kPassword = L"bar"; - delegate->SetAuthInfo(kUsername, kPassword); + delegate->SetAuthInfo(ASCIIToUTF16("foo"), ASCIIToUTF16("bar")); delegate->SetOnAuthRequired( NewCallback(delegate.get(), &SocketStreamEventRecorder::DoRestartWithAuth)); diff --git a/net/spdy/spdy_network_transaction.cc b/net/spdy/spdy_network_transaction.cc index 6e0c930..e575ad0 100644 --- a/net/spdy/spdy_network_transaction.cc +++ b/net/spdy/spdy_network_transaction.cc @@ -1,9 +1,11 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// 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. #include "net/spdy/spdy_network_transaction.h" +#include <string> + #include "base/compiler_specific.h" #include "base/logging.h" #include "base/scoped_ptr.h" @@ -78,8 +80,8 @@ int SpdyNetworkTransaction::RestartWithCertificate( } int SpdyNetworkTransaction::RestartWithAuth( - const std::wstring& username, - const std::wstring& password, + const string16& username, + const string16& password, CompletionCallback* callback) { // TODO(mbelshe): implement me. NOTIMPLEMENTED(); diff --git a/net/spdy/spdy_network_transaction.h b/net/spdy/spdy_network_transaction.h index 92357ac..7df2e64 100644 --- a/net/spdy/spdy_network_transaction.h +++ b/net/spdy/spdy_network_transaction.h @@ -1,17 +1,17 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// 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. -#ifndef NET_SPDY_NETWORK_TRANSACTION_H_ -#define NET_SPDY_NETWORK_TRANSACTION_H_ +#ifndef NET_SPDY_SPDY_NETWORK_TRANSACTION_H_ +#define NET_SPDY_SPDY_NETWORK_TRANSACTION_H_ #pragma once -#include <string> #include <deque> #include "base/basictypes.h" #include "base/ref_counted.h" #include "base/scoped_ptr.h" +#include "base/string16.h" #include "base/time.h" #include "net/base/completion_callback.h" #include "net/base/load_states.h" @@ -43,8 +43,8 @@ class SpdyNetworkTransaction : public HttpTransaction { virtual int RestartIgnoringLastError(CompletionCallback* callback); virtual int RestartWithCertificate(X509Certificate* client_cert, CompletionCallback* callback); - virtual int RestartWithAuth(const std::wstring& username, - const std::wstring& password, + virtual int RestartWithAuth(const string16& username, + const string16& password, CompletionCallback* callback); virtual bool IsReadyToRestartForAuth() { return false; } virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback); @@ -121,4 +121,4 @@ class SpdyNetworkTransaction : public HttpTransaction { } // namespace net -#endif // NET_SPDY_NETWORK_TRANSACTION_H_ +#endif // NET_SPDY_SPDY_NETWORK_TRANSACTION_H_ diff --git a/net/url_request/url_request.cc b/net/url_request/url_request.cc index 9f226c2..3ed7d92 100644 --- a/net/url_request/url_request.cc +++ b/net/url_request/url_request.cc @@ -1,4 +1,4 @@ -// Copyright (c) 20010 The Chromium Authors. All rights reserved. +// 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. @@ -23,7 +23,6 @@ using base::Time; using net::UploadData; using std::string; -using std::wstring; namespace { @@ -395,7 +394,7 @@ void URLRequest::FollowDeferredRedirect() { job_->FollowDeferredRedirect(); } -void URLRequest::SetAuth(const wstring& username, const wstring& password) { +void URLRequest::SetAuth(const string16& username, const string16& password) { DCHECK(job_); DCHECK(job_->NeedsAuth()); diff --git a/net/url_request/url_request.h b/net/url_request/url_request.h index e5a644e..a6ef386 100644 --- a/net/url_request/url_request.h +++ b/net/url_request/url_request.h @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. +// 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. @@ -15,6 +15,7 @@ #include "base/logging.h" #include "base/non_thread_safe.h" #include "base/ref_counted.h" +#include "base/string16.h" #include "googleurl/src/gurl.h" #include "net/base/load_states.h" #include "net/base/net_log.h" @@ -504,7 +505,7 @@ class URLRequest : public NonThreadSafe { // OnAuthRequired() callback (and only then). // SetAuth will reissue the request with the given credentials. // CancelAuth will give up and display the error page. - void SetAuth(const std::wstring& username, const std::wstring& password); + void SetAuth(const string16& username, const string16& password); void CancelAuth(); // This method can be called after the user selects a client certificate to diff --git a/net/url_request/url_request_ftp_job.cc b/net/url_request/url_request_ftp_job.cc index f8746fc..e59f79f 100644 --- a/net/url_request/url_request_ftp_job.cc +++ b/net/url_request/url_request_ftp_job.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// 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. @@ -90,8 +90,8 @@ void URLRequestFtpJob::GetAuthChallengeInfo( result->swap(auth_info); } -void URLRequestFtpJob::SetAuth(const std::wstring& username, - const std::wstring& password) { +void URLRequestFtpJob::SetAuth(const string16& username, + const string16& password) { DCHECK(NeedsAuth()); server_auth_->state = net::AUTH_STATE_HAVE_AUTH; server_auth_->username = username; diff --git a/net/url_request/url_request_ftp_job.h b/net/url_request/url_request_ftp_job.h index 02a034d..c614554 100644 --- a/net/url_request/url_request_ftp_job.h +++ b/net/url_request/url_request_ftp_job.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// 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. @@ -8,6 +8,7 @@ #include <string> +#include "base/string16.h" #include "net/base/auth.h" #include "net/base/completion_callback.h" #include "net/ftp/ftp_request_info.h" @@ -42,8 +43,8 @@ class URLRequestFtpJob : public URLRequestJob { virtual bool NeedsAuth(); virtual void GetAuthChallengeInfo( scoped_refptr<net::AuthChallengeInfo>* auth_info); - virtual void SetAuth(const std::wstring& username, - const std::wstring& password); + virtual void SetAuth(const string16& username, + const string16& password); virtual void CancelAuth(); // TODO(ibrar): Yet to give another look at this function. diff --git a/net/url_request/url_request_http_job.cc b/net/url_request/url_request_http_job.cc index 9a03213..cbccff2 100644 --- a/net/url_request/url_request_http_job.cc +++ b/net/url_request/url_request_http_job.cc @@ -310,8 +310,8 @@ void URLRequestHttpJob::GetAuthChallengeInfo( *result = response_info_->auth_challenge; } -void URLRequestHttpJob::SetAuth(const std::wstring& username, - const std::wstring& password) { +void URLRequestHttpJob::SetAuth(const string16& username, + const string16& password) { DCHECK(transaction_.get()); // Proxy gets set first, then WWW. @@ -326,8 +326,8 @@ void URLRequestHttpJob::SetAuth(const std::wstring& username, } void URLRequestHttpJob::RestartTransactionWithAuth( - const std::wstring& username, - const std::wstring& password) { + const string16& username, + const string16& password) { username_ = username; password_ = password; @@ -596,7 +596,7 @@ void URLRequestHttpJob::NotifyHeadersComplete() { // notified of the headers completion so that we can update the cookie store. if (transaction_->IsReadyToRestartForAuth()) { DCHECK(!response_info_->auth_challenge.get()); - RestartTransactionWithAuth(std::wstring(), std::wstring()); + RestartTransactionWithAuth(string16(), string16()); return; } diff --git a/net/url_request/url_request_http_job.h b/net/url_request/url_request_http_job.h index 223edf8..ea2e544 100644 --- a/net/url_request/url_request_http_job.h +++ b/net/url_request/url_request_http_job.h @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. +// 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. @@ -11,6 +11,7 @@ #include <vector> #include "base/scoped_ptr.h" +#include "base/string16.h" #include "net/base/auth.h" #include "net/base/completion_callback.h" #include "net/http/http_request_info.h" @@ -50,8 +51,8 @@ class URLRequestHttpJob : public URLRequestJob { virtual bool IsSafeRedirect(const GURL& location); virtual bool NeedsAuth(); virtual void GetAuthChallengeInfo(scoped_refptr<net::AuthChallengeInfo>*); - virtual void SetAuth(const std::wstring& username, - const std::wstring& password); + virtual void SetAuth(const string16& username, + const string16& password); virtual void CancelAuth(); virtual void ContinueWithCertificate(net::X509Certificate* client_cert); virtual void ContinueDespiteLastError(); @@ -80,8 +81,8 @@ class URLRequestHttpJob : public URLRequestJob { bool ShouldTreatAsCertificateError(int result); - void RestartTransactionWithAuth(const std::wstring& username, - const std::wstring& password); + void RestartTransactionWithAuth(const string16& username, + const string16& password); // Keep a reference to the url request context to be sure it's not deleted // before us. @@ -97,8 +98,8 @@ class URLRequestHttpJob : public URLRequestJob { net::AuthState proxy_auth_state_; net::AuthState server_auth_state_; - std::wstring username_; - std::wstring password_; + string16 username_; + string16 password_; net::CompletionCallbackImpl<URLRequestHttpJob> can_get_cookies_callback_; net::CompletionCallbackImpl<URLRequestHttpJob> can_set_cookie_callback_; diff --git a/net/url_request/url_request_job.cc b/net/url_request/url_request_job.cc index 7ce60c3..11fc46d5 100644 --- a/net/url_request/url_request_job.cc +++ b/net/url_request/url_request_job.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. +// 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. @@ -110,8 +110,8 @@ void URLRequestJob::GetAuthChallengeInfo( NOTREACHED(); } -void URLRequestJob::SetAuth(const std::wstring& username, - const std::wstring& password) { +void URLRequestJob::SetAuth(const string16& username, + const string16& password) { // This will only be called if NeedsAuth() returns true, in which // case the derived class should implement this! NOTREACHED(); diff --git a/net/url_request/url_request_job.h b/net/url_request/url_request_job.h index 7cd496b..05f55bc 100644 --- a/net/url_request/url_request_job.h +++ b/net/url_request/url_request_job.h @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. +// 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. @@ -11,6 +11,7 @@ #include "base/ref_counted.h" #include "base/scoped_ptr.h" +#include "base/string16.h" #include "base/time.h" #include "googleurl/src/gurl.h" #include "net/base/filter.h" @@ -171,8 +172,8 @@ class URLRequestJob : public base::RefCountedThreadSafe<URLRequestJob>, scoped_refptr<net::AuthChallengeInfo>* auth_info); // Resend the request with authentication credentials. - virtual void SetAuth(const std::wstring& username, - const std::wstring& password); + virtual void SetAuth(const string16& username, + const string16& password); // Display the error page without asking for credentials again. virtual void CancelAuth(); diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc index 8c842fe..bfbd290 100644 --- a/net/url_request/url_request_unittest.cc +++ b/net/url_request/url_request_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2006-2010 The Chromium Authors. All rights reserved. +// 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. @@ -51,6 +51,10 @@ using base::Time; namespace { +const string16 kChrome(ASCIIToUTF16("chrome")); +const string16 kSecret(ASCIIToUTF16("secret")); +const string16 kUser(ASCIIToUTF16("user")); + base::StringPiece TestNetResourceProvider(int key) { return "header"; } @@ -1165,8 +1169,8 @@ TEST_F(URLRequestTestHTTP, BasicAuth) { // populate the cache { TestDelegate d; - d.set_username(L"user"); - d.set_password(L"secret"); + d.set_username(kUser); + d.set_password(kSecret); URLRequest r(server_->TestServerPage("auth-basic"), &d); r.set_context(context); @@ -1182,8 +1186,8 @@ TEST_F(URLRequestTestHTTP, BasicAuth) { // response should be fetched from the cache. { TestDelegate d; - d.set_username(L"user"); - d.set_password(L"secret"); + d.set_username(kUser); + d.set_password(kSecret); URLRequest r(server_->TestServerPage("auth-basic"), &d); r.set_context(context); @@ -1212,8 +1216,8 @@ TEST_F(URLRequestTestHTTP, BasicAuthWithCookies) { { scoped_refptr<URLRequestContext> context = new TestURLRequestContext(); TestDelegate d; - d.set_username(L"user"); - d.set_password(L"secret"); + d.set_username(kUser); + d.set_password(kSecret); URLRequest r(url_requiring_auth, &d); r.set_context(context); @@ -1771,7 +1775,7 @@ class RestartTestJob : public URLRequestTestJob { this->NotifyRestartRequired(); } private: - ~RestartTestJob() {} + ~RestartTestJob() {} }; class CancelTestJob : public URLRequestTestJob { @@ -2335,8 +2339,8 @@ TEST_F(URLRequestTestFTP, FLAKY_FTPCheckWrongPasswordRestart) { TestDelegate d; // Set correct login credentials. The delegate will be asked for them when // the initial login with wrong credentials will fail. - d.set_username(L"chrome"); - d.set_password(L"chrome"); + d.set_username(kChrome); + d.set_password(kChrome); { TestURLRequest r(server_->TestServerPage("/LICENSE", "chrome", "wrong_password"), &d); @@ -2388,8 +2392,8 @@ TEST_F(URLRequestTestFTP, FLAKY_FTPCheckWrongUserRestart) { TestDelegate d; // Set correct login credentials. The delegate will be asked for them when // the initial login with wrong credentials will fail. - d.set_username(L"chrome"); - d.set_password(L"chrome"); + d.set_username(kChrome); + d.set_password(kChrome); { TestURLRequest r(server_->TestServerPage("/LICENSE", "wrong_user", "chrome"), &d); @@ -2464,8 +2468,8 @@ TEST_F(URLRequestTestFTP, FLAKY_FTPCacheLoginBoxCredentials) { scoped_ptr<TestDelegate> d(new TestDelegate); // Set correct login credentials. The delegate will be asked for them when // the initial login with wrong credentials will fail. - d->set_username(L"chrome"); - d->set_password(L"chrome"); + d->set_username(kChrome); + d->set_password(kChrome); { TestURLRequest r(server_->TestServerPage("/LICENSE", "chrome", "wrong_password"), diff --git a/net/url_request/url_request_unittest.h b/net/url_request/url_request_unittest.h index 39dc5bf..92f527f 100644 --- a/net/url_request/url_request_unittest.h +++ b/net/url_request/url_request_unittest.h @@ -18,6 +18,7 @@ #include "base/message_loop.h" #include "base/path_service.h" #include "base/process_util.h" +#include "base/string16.h" #include "base/thread.h" #include "base/time.h" #include "base/utf_string_conversions.h" @@ -346,8 +347,8 @@ class TestDelegate : public URLRequest::Delegate { void set_allow_certificate_errors(bool val) { allow_certificate_errors_ = val; } - void set_username(const std::wstring& u) { username_ = u; } - void set_password(const std::wstring& p) { password_ = p; } + void set_username(const string16& u) { username_ = u; } + void set_password(const string16& p) { password_ = p; } // query state const std::string& data_received() const { return data_received_; } @@ -376,8 +377,8 @@ class TestDelegate : public URLRequest::Delegate { bool quit_on_redirect_; bool allow_certificate_errors_; - std::wstring username_; - std::wstring password_; + string16 username_; + string16 password_; // tracks status of callbacks int response_started_count_; diff --git a/net/websockets/websocket_job.cc b/net/websockets/websocket_job.cc index 17dc54b..ba79c44 100644 --- a/net/websockets/websocket_job.cc +++ b/net/websockets/websocket_job.cc @@ -134,8 +134,8 @@ void WebSocketJob::Close() { } void WebSocketJob::RestartWithAuth( - const std::wstring& username, - const std::wstring& password) { + const string16& username, + const string16& password) { state_ = CONNECTING; socket_->RestartWithAuth(username, password); } diff --git a/net/websockets/websocket_job.h b/net/websockets/websocket_job.h index d1dae8d..f19653d 100644 --- a/net/websockets/websocket_job.h +++ b/net/websockets/websocket_job.h @@ -9,6 +9,7 @@ #include <string> #include <vector> +#include "base/string16.h" #include "net/base/address_list.h" #include "net/base/completion_callback.h" #include "net/socket_stream/socket_stream_job.h" @@ -47,8 +48,8 @@ class WebSocketJob : public SocketStreamJob, public SocketStream::Delegate { virtual bool SendData(const char* data, int len); virtual void Close(); virtual void RestartWithAuth( - const std::wstring& username, - const std::wstring& password); + const string16& username, + const string16& password); virtual void DetachDelegate(); // SocketStream::Delegate methods. diff --git a/net/websockets/websocket_job_unittest.cc b/net/websockets/websocket_job_unittest.cc index f33b42c..0136759 100644 --- a/net/websockets/websocket_job_unittest.cc +++ b/net/websockets/websocket_job_unittest.cc @@ -35,7 +35,7 @@ class MockSocketStream : public SocketStream { virtual void Close() {} virtual void RestartWithAuth( - const std::wstring& username, const std::wstring& password) {} + const string16& username, const string16& password) {} virtual void DetachDelegate() { delegate_ = NULL; } |