Add utf_string_conversions to base namespace.

chrome/renderer/spellchecker/spellcheck_unittest.cc

 // Copyright (c) 2012 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 "webkit/glue/webkit_glue.h"
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_file.h"
@@ skipping 372 matching lines @@
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     size_t input_length = 0;
     if (kTestCases[i].input != NULL) {
       input_length = wcslen(kTestCases[i].input);
     }
     int misspelling_start;
     int misspelling_length;
     bool result = spell_check()->SpellCheckWord(
-        WideToUTF16(kTestCases[i].input).c_str(),
+        base::WideToUTF16(kTestCases[i].input).c_str(),
         static_cast<int>(input_length),
         0,
         &misspelling_start,
         &misspelling_length, NULL);
 
     EXPECT_EQ(kTestCases[i].expected_result, result);
     EXPECT_EQ(kTestCases[i].misspelling_start, misspelling_start);
     EXPECT_EQ(kTestCases[i].misspelling_length, misspelling_length);
   }
 }
@@ skipping 30 matching lines @@
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     std::vector<string16> suggestions;
     size_t input_length = 0;
     if (kTestCases[i].input != NULL) {
       input_length = wcslen(kTestCases[i].input);
     }
     int misspelling_start;
     int misspelling_length;
     bool result = spell_check()->SpellCheckWord(
-        WideToUTF16(kTestCases[i].input).c_str(),
+        base::WideToUTF16(kTestCases[i].input).c_str(),
         static_cast<int>(input_length),
         0,
         &misspelling_start,
         &misspelling_length,
         &suggestions);
 
     // Check for spelling.
     EXPECT_EQ(kTestCases[i].expected_result, result);
 
     // Check if the suggested words occur.
     bool suggested_word_is_present = false;
     for (int j = 0; j < static_cast<int>(suggestions.size()); j++) {
-      if (suggestions.at(j).compare(WideToUTF16(kTestCases[i].suggested_word))
-          == 0) {
+      if (suggestions.at(j).compare(base::WideToUTF16(
+              kTestCases[i].suggested_word)) == 0) {
         suggested_word_is_present = true;
         break;
       }
     }
 
     EXPECT_TRUE(suggested_word_is_present);
   }
 }
 
 // This test verifies our spellchecker can split a text into words and check
@@ skipping 323 matching lines @@
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     ReinitializeSpellCheck(kTestCases[i].language);
     size_t input_length = 0;
     if (kTestCases[i].input != NULL)
       input_length = wcslen(kTestCases[i].input);
 
     int misspelling_start = 0;
     int misspelling_length = 0;
     bool result = spell_check()->SpellCheckWord(
-        WideToUTF16(kTestCases[i].input).c_str(),
+        base::WideToUTF16(kTestCases[i].input).c_str(),
         static_cast<int>(input_length),
         0,
         &misspelling_start,
         &misspelling_length, NULL);
 
     EXPECT_TRUE(result)
         << "\""
         << std::wstring(kTestCases[i].input).substr(
                misspelling_start, misspelling_length)
         << "\" is misspelled in "
@@ skipping 60 matching lines @@
     }, {
       // A misspelled word for Russian
       "ru-RU",
       L"\x0430\x0430\x0430\x0430\x0430\x0430\x0430\x0430\x0430\x0430",
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     ReinitializeSpellCheck(kTestCases[i].language);
 
-    string16 word(WideToUTF16(kTestCases[i].input));
+    string16 word(base::WideToUTF16(kTestCases[i].input));
     int word_length = static_cast<int>(word.length());
     int misspelling_start = 0;
     int misspelling_length = 0;
     bool result = spell_check()->SpellCheckWord(word.c_str(),
                                                 word_length,
                                                 0,
                                                 &misspelling_start,
                                                 &misspelling_length,
                                                 NULL);
     EXPECT_FALSE(result);
@@ skipping 425 matching lines @@
   InitializeIfNeeded();
   ASSERT_FALSE(InitializeIfNeeded());
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     bool result = CheckSpelling(kTestCases[i].word, 0);
     EXPECT_EQ(kTestCases[i].expected_result, result) <<
         "Failed test for " << kTestCases[i].word;
   }
 }