wstring cleanup in browser/ui/login

chrome/browser/ui/login/login_prompt_browsertest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <list>
 #include <map>
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/test/test_browser_thread.h"
 #include "net/base/auth.h"
 #include "net/base/mock_host_resolver.h"
 
 namespace {
 
 class LoginPromptBrowserTest : public InProcessBrowserTest {
  public:
   LoginPromptBrowserTest()
-      : bad_password_(L"incorrect"), bad_username_(L"nouser") {
+      : bad_password_("incorrect"), bad_username_("nouser") {
     set_show_window(true);
 
-    auth_map_["foo"] = AuthInfo(L"testuser", L"foopassword");
-    auth_map_["bar"] = AuthInfo(L"testuser", L"barpassword");
+    auth_map_["foo"] = AuthInfo("testuser", "foopassword");
+    auth_map_["bar"] = AuthInfo("testuser", "barpassword");
   }
 
  protected:
   struct AuthInfo {
-    std::wstring username_;
-    std::wstring password_;
+    std::string username_;
+    std::string password_;
 
     AuthInfo() {}
 
-    AuthInfo(const std::wstring username,
-             const std::wstring password)
+    AuthInfo(const std::string username,
+             const std::string password)
         : username_(username), password_(password) {}
   };
 
   typedef std::map<std::string, AuthInfo> AuthMap;
 
   void SetAuthFor(LoginHandler* handler);
 
   AuthMap auth_map_;
-  std::wstring bad_password_;
-  std::wstring bad_username_;
+  std::string bad_password_;
+  std::string bad_username_;
 };
 
 void LoginPromptBrowserTest::SetAuthFor(LoginHandler* handler) {
   const net::AuthChallengeInfo* challenge = handler->auth_info();
 
   ASSERT_TRUE(challenge);
   AuthMap::iterator i = auth_map_.find(challenge->realm);
   EXPECT_TRUE(auth_map_.end() != i);
   if (i != auth_map_.end()) {
     const AuthInfo& info = i->second;
-    handler->SetAuth(WideToUTF16Hack(info.username_),
-                     WideToUTF16Hack(info.password_));
+    handler->SetAuth(UTF8ToUTF16(info.username_),
+                     UTF8ToUTF16(info.password_));
   }
 }
 
 // Maintains a set of LoginHandlers that are currently active and
 // keeps a count of the notifications that were observed.
 class LoginPromptBrowserTestObserver : public content::NotificationObserver {
  public:
   LoginPromptBrowserTestObserver()
       : auth_needed_count_(0),
         auth_supplied_count_(0),
@@ skipping 407 matching lines @@
   }
 
   EXPECT_FALSE(observer.handlers_.empty());
 
   if (!observer.handlers_.empty()) {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
     WindowedAuthSuppliedObserver auth_supplied_waiter(controller);
     LoginHandler* handler = *observer.handlers_.begin();
 
     ASSERT_TRUE(handler);
-    handler->SetAuth(WideToUTF16Hack(bad_username_),
-                     WideToUTF16Hack(bad_password_));
+    handler->SetAuth(UTF8ToUTF16(bad_username_),
+                     UTF8ToUTF16(bad_password_));
     auth_supplied_waiter.Wait();
 
     // The request should be retried after the incorrect password is
     // supplied.  This should result in a new AUTH_NEEDED notification
     // for the same realm.
     auth_needed_waiter.Wait();
   }
 
   int n_handlers = 0;
 
@@ skipping 143 matching lines @@
       handler->CancelAuth();
       auth_cancelled_waiter.Wait();
     }
   }
 
   EXPECT_EQ(1, observer.auth_needed_count_);
   EXPECT_TRUE(test_server()->Stop());
 }
 
 }  // namespace