Cleanup: Get rid of base::WideToUTF16Hack.

chrome/browser/importer/firefox_importer_browsertest.cc

 // Copyright (c) 2013 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 "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
@@ skipping 20 matching lines @@
 #else
 #define MAYBE_IMPORTER(x) x
 #endif
 
 namespace {
 
 struct PasswordInfo {
   const char* origin;
   const char* action;
   const char* realm;
-  const wchar_t* username_element;
-  const wchar_t* username;
-  const wchar_t* password_element;
-  const wchar_t* password;
+  const char* username_element;
+  const char* username;
+  const char* password_element;
+  const char* password;
   bool blacklisted;
 };
 
 struct KeywordInfo {
   const wchar_t* keyword;
   const char* url;
 };
 
 const BookmarkInfo kFirefoxBookmarks[] = {
-  {true, 1, {L"Bookmarks Toolbar"},
+  {true, 1, {"Bookmarks Toolbar"},
     L"Toolbar",
     "http://site/"},
   {false, 0, {},
     L"Title",
     "http://www.google.com/"},
 };
 
 const PasswordInfo kFirefoxPasswords[] = {
   {"http://localhost:8080/", "http://localhost:8080/", "http://localhost:8080/",
-    L"loginuser", L"abc", L"loginpass", L"123", false},
+    "loginuser", "abc", "loginpass", "123", false},
   {"http://localhost:8080/", "", "http://localhost:8080/localhost",
-    L"", L"http", L"", L"Http1+1abcdefg", false},
+    "", "http", "", "Http1+1abcdefg", false},
 };
 
 const KeywordInfo kFirefoxKeywords[] = {
   { L"amazon.com",
     "http://www.amazon.com/exec/obidos/external-search/?field-keywords="
     "{searchTerms}&mode=blended" },
   { L"answers.com",
     "http://www.answers.com/main/ntquery?s={searchTerms}&gwp=13" },
   { L"search.creativecommons.org",
     "http://search.creativecommons.org/?q={searchTerms}" },
@@ skipping 51 matching lines @@
 
   virtual bool TemplateURLServiceIsLoaded() const OVERRIDE {
     return true;
   }
 
   virtual void AddPasswordForm(const autofill::PasswordForm& form) OVERRIDE {
     PasswordInfo p = kFirefoxPasswords[password_count_];
     EXPECT_EQ(p.origin, form.origin.spec());
     EXPECT_EQ(p.realm, form.signon_realm);
     EXPECT_EQ(p.action, form.action.spec());
-    EXPECT_EQ(base::WideToUTF16(p.username_element), form.username_element);
-    EXPECT_EQ(base::WideToUTF16(p.username), form.username_value);
-    EXPECT_EQ(base::WideToUTF16(p.password_element), form.password_element);
-    EXPECT_EQ(base::WideToUTF16(p.password), form.password_value);
+    EXPECT_EQ(base::ASCIIToUTF16(p.username_element), form.username_element);
+    EXPECT_EQ(base::ASCIIToUTF16(p.username), form.username_value);
+    EXPECT_EQ(base::ASCIIToUTF16(p.password_element), form.password_element);
+    EXPECT_EQ(base::ASCIIToUTF16(p.password), form.password_value);
     EXPECT_EQ(p.blacklisted, form.blacklisted_by_user);
     ++password_count_;
   }
 
   virtual void AddHistoryPage(const history::URLRows& page,
                               history::VisitSource visit_source) OVERRIDE {
     ASSERT_EQ(3U, page.size());
     EXPECT_EQ("http://www.google.com/", page[0].url().spec());
     EXPECT_EQ(base::ASCIIToUTF16("Google"), page[0].title());
     EXPECT_EQ("http://www.google.com/", page[1].url().spec());
@@ skipping 18 matching lines @@
       ++bookmark_count_;
     }
   }
 
   virtual void AddKeywords(ScopedVector<TemplateURL> template_urls,
                            bool unique_on_host_and_path) OVERRIDE {
     for (size_t i = 0; i < template_urls.size(); ++i) {
       // The order might not be deterministic, look in the expected list for
       // that template URL.
       bool found = false;
-      base::string16 keyword = template_urls[i]->keyword();
+      const base::string16& keyword = template_urls[i]->keyword();
       for (size_t j = 0; j < arraysize(kFirefoxKeywords); ++j) {
-        if (template_urls[i]->keyword() ==
-                base::WideToUTF16Hack(kFirefoxKeywords[j].keyword)) {
+        if (keyword == base::WideToUTF16(kFirefoxKeywords[j].keyword)) {
           EXPECT_EQ(kFirefoxKeywords[j].url, template_urls[i]->url());
           found = true;
           break;
         }
       }
       EXPECT_TRUE(found);
       ++keyword_count_;
     }
   }
 
@@ skipping 46 matching lines @@
     ASSERT_TRUE(base::CopyDirectory(data_path, profile_path_, false));
 
     base::FilePath search_engine_path = app_path_;
     search_engine_path = search_engine_path.AppendASCII("searchplugins");
     base::CreateDirectory(search_engine_path);
     if (import_search_plugins) {
       ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_path));
       data_path = data_path.AppendASCII("firefox3_searchplugins");
       if (!base::PathExists(data_path)) {
         // TODO(maruel):  Create search test data that we can open source!
-        LOG(ERROR) << L"Missing internal test data";
+        LOG(ERROR) << "Missing internal test data";
         return;
       }
       ASSERT_TRUE(base::CopyDirectory(data_path, search_engine_path, false));
     }
 
     importer::SourceProfile source_profile;
     source_profile.importer_type = importer::TYPE_FIREFOX;
     source_profile.app_path = app_path_;
     source_profile.source_path = profile_path_;
     source_profile.locale = "en-US";
@@ skipping 25 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(FirefoxProfileImporterBrowserTest,
                        MAYBE_IMPORTER(Firefox35Importer)) {
   bool import_search_engines = false;
   scoped_refptr<FirefoxObserver> observer(
       new FirefoxObserver(import_search_engines));
   Firefox3xImporterBrowserTest("firefox35_profile", observer.get(),
                                observer.get(), import_search_engines);
 }