Use base namespace for string16 in chrome/renderer.

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 "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_file.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 67 matching lines @@
   SpellCheck* spell_check() { return spell_check_.get(); }
 
   bool CheckSpelling(const std::string& word, int tag) {
     return spell_check_->spellcheck_.platform_spelling_engine_->CheckSpelling(
         ASCIIToUTF16(word), tag);
   }
 
 #if !defined(OS_MACOSX)
  protected:
   void TestSpellCheckParagraph(
-      const string16& input,
+      const base::string16& input,
       const std::vector<SpellCheckResult>& expected) {
     blink::WebVector<blink::WebTextCheckingResult> results;
     spell_check()->SpellCheckParagraph(input,
                                        &results);
 
     EXPECT_EQ(results.size(), expected.size());
     size_t size = std::min(results.size(), expected.size());
     for (size_t j = 0; j < size; ++j) {
       EXPECT_EQ(results[j].decoration, blink::WebTextDecorationTypeSpelling);
       EXPECT_EQ(results[j].location, expected[j].location);
@@ skipping 325 matching lines @@
     {L"jum", false, 0, 0, L"jump"},
     {L"jum", false, 0, 0, L"hum"},
     {L"jum", false, 0, 0, L"sum"},
     {L"jum", false, 0, 0, L"um"},
     // A regression test for Issue 36523.
     {L"privliged", false, 0, 0, L"privileged"},
     // TODO (Sidchat): add many more examples.
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
-    std::vector<string16> suggestions;
+    std::vector<base::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(),
         static_cast<int>(input_length),
         0,
@@ skipping 389 matching lines @@
     {"teh", "the"},
     {"moer", "more"},
     {"watre", "water"},
     {"noen", ""},
     {"what", ""},
   };
 
   EnableAutoCorrect(true);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
-    string16 misspelled_word(UTF8ToUTF16(kTestCases[i].input));
-    string16 expected_autocorrect_word(
+    base::string16 misspelled_word(UTF8ToUTF16(kTestCases[i].input));
+    base::string16 expected_autocorrect_word(
         UTF8ToUTF16(kTestCases[i].expected_result));
-    string16 autocorrect_word = spell_check()->GetAutoCorrectionWord(
+    base::string16 autocorrect_word = spell_check()->GetAutoCorrectionWord(
         misspelled_word, 0);
 
     // Check for spelling.
     EXPECT_EQ(expected_autocorrect_word, autocorrect_word);
   }
 }
 
 // Verify that our SpellCheck::SpellCheckWord() returns false when it checks
 // misspelled words.
 TEST_F(SpellCheckTest, MisspelledWords) {
@@ skipping 20 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));
+    base::string16 word(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);
     EXPECT_EQ(0, misspelling_start);
     EXPECT_EQ(word_length, misspelling_length);
   }
 }
 
 // Since SpellCheck::SpellCheckParagraph is not implemented on Mac,
 // we skip these SpellCheckParagraph tests on Mac.
 #if !defined(OS_MACOSX)
 
 // Make sure SpellCheckParagraph does not crash if the input is empty.
 TEST_F(SpellCheckTest, SpellCheckParagraphEmptyParagraph) {
   std::vector<SpellCheckResult> expected;
   TestSpellCheckParagraph(UTF8ToUTF16(""), expected);
 }
 
 // A simple test case having no misspellings.
 TEST_F(SpellCheckTest, SpellCheckParagraphNoMisspellings) {
-  const string16 text = UTF8ToUTF16("apple");
+  const base::string16 text = UTF8ToUTF16("apple");
   std::vector<SpellCheckResult> expected;
   TestSpellCheckParagraph(text, expected);
 }
 
 // A simple test case having one misspelling.
 TEST_F(SpellCheckTest, SpellCheckParagraphSingleMisspellings) {
-  const string16 text = UTF8ToUTF16("zz");
+  const base::string16 text = UTF8ToUTF16("zz");
   std::vector<SpellCheckResult> expected;
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 0, 2));
 
   TestSpellCheckParagraph(text, expected);
 }
 
 // A simple test case having multiple misspellings.
 TEST_F(SpellCheckTest, SpellCheckParagraphMultipleMisspellings) {
-  const string16 text = UTF8ToUTF16("zz, zz");
+  const base::string16 text = UTF8ToUTF16("zz, zz");
   std::vector<SpellCheckResult> expected;
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 0, 2));
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 4, 2));
 
   TestSpellCheckParagraph(text, expected);
 }
 
 // Make sure a relatively long (correct) sentence can be spellchecked.
 TEST_F(SpellCheckTest, SpellCheckParagraphLongSentence) {
   std::vector<SpellCheckResult> expected;
   // The text is taken from US constitution preamble.
-  const string16 text = UTF8ToUTF16(
+  const base::string16 text = UTF8ToUTF16(
       "We the people of the United States, in order to form a more perfect "
       "union, establish justice, insure domestic tranquility, provide for "
       "the common defense, promote the general welfare, and secure the "
       "blessings of liberty to ourselves and our posterity, do ordain and "
       "establish this Constitution for the United States of America.");
 
   TestSpellCheckParagraph(text, expected);
 }
 
 // Make sure all misspellings can be found in a relatively long sentence.
 TEST_F(SpellCheckTest, SpellCheckParagraphLongSentenceMultipleMisspellings) {
   std::vector<SpellCheckResult> expected;
 
   // All 'the' are converted to 'hte' in US consitition preamble.
-  const string16 text = UTF8ToUTF16(
+  const base::string16 text = UTF8ToUTF16(
       "We hte people of hte United States, in order to form a more perfect "
       "union, establish justice, insure domestic tranquility, provide for "
       "hte common defense, promote hte general welfare, and secure hte "
       "blessings of liberty to ourselves and our posterity, do ordain and "
       "establish this Constitution for hte United States of America.");
 
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 3, 3));
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 17, 3));
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 135, 3));
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 163, 3));
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 195, 3));
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 298, 3));
 
   TestSpellCheckParagraph(text, expected);
 }
 
 // We also skip RequestSpellCheck tests on Mac, because a system spellchecker
 // is used on Mac instead of SpellCheck::RequestTextChecking.
 
 // Make sure RequestTextChecking does not crash if input is empty.
 TEST_F(SpellCheckTest, RequestSpellCheckWithEmptyString) {
   MockTextCheckingCompletion completion;
 
-  spell_check()->RequestTextChecking(string16(), &completion);
+  spell_check()->RequestTextChecking(base::string16(), &completion);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(completion.completion_count_, 1U);
 }
 
 // A simple test case having no misspellings.
 TEST_F(SpellCheckTest, RequestSpellCheckWithoutMisspelling) {
   MockTextCheckingCompletion completion;
 
-  const string16 text = ASCIIToUTF16("hello");
+  const base::string16 text = ASCIIToUTF16("hello");
   spell_check()->RequestTextChecking(text, &completion);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(completion.completion_count_, 1U);
 }
 
 // A simple test case having one misspelling.
 TEST_F(SpellCheckTest, RequestSpellCheckWithSingleMisspelling) {
   MockTextCheckingCompletion completion;
 
-  const string16 text = ASCIIToUTF16("apple, zz");
+  const base::string16 text = ASCIIToUTF16("apple, zz");
   spell_check()->RequestTextChecking(text, &completion);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(completion.completion_count_, 1U);
   EXPECT_EQ(completion.last_results_.size(), 1U);
   EXPECT_EQ(completion.last_results_[0].location, 7);
   EXPECT_EQ(completion.last_results_[0].length, 2);
 }
 
 // A simple test case having a few misspellings.
 TEST_F(SpellCheckTest, RequestSpellCheckWithMisspellings) {
   MockTextCheckingCompletion completion;
 
-  const string16 text = ASCIIToUTF16("apple, zz, orange, zz");
+  const base::string16 text = ASCIIToUTF16("apple, zz, orange, zz");
   spell_check()->RequestTextChecking(text, &completion);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(completion.completion_count_, 1U);
   EXPECT_EQ(completion.last_results_.size(), 2U);
   EXPECT_EQ(completion.last_results_[0].location, 7);
   EXPECT_EQ(completion.last_results_[0].length, 2);
   EXPECT_EQ(completion.last_results_[1].location, 19);
   EXPECT_EQ(completion.last_results_[1].length, 2);
 }
 
 // A test case that multiple requests comes at once. Make sure all
 // requests are processed.
 TEST_F(SpellCheckTest, RequestSpellCheckWithMultipleRequests) {
   MockTextCheckingCompletion completion[3];
 
-  const string16 text[3] = {
+  const base::string16 text[3] = {
     ASCIIToUTF16("what, zz"),
     ASCIIToUTF16("apple, zz"),
     ASCIIToUTF16("orange, zz")
   };
 
   for (int i = 0; i < 3; ++i)
     spell_check()->RequestTextChecking(text[i], &completion[i]);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ(completion[i].completion_count_, 1U);
     EXPECT_EQ(completion[i].last_results_.size(), 1U);
     EXPECT_EQ(completion[i].last_results_[0].location, 6 + i);
     EXPECT_EQ(completion[i].last_results_[0].length, 2);
   }
 }
 
 // A test case that spellchecking is requested before initializing.
 // In this case, we postpone to post a request.
 TEST_F(SpellCheckTest, RequestSpellCheckWithoutInitialization) {
   UninitializeSpellCheck();
 
   MockTextCheckingCompletion completion;
-  const string16 text = ASCIIToUTF16("zz");
+  const base::string16 text = ASCIIToUTF16("zz");
 
   spell_check()->RequestTextChecking(text, &completion);
 
   // The task will not be posted yet.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(completion.completion_count_, 0U);
 }
 
 // Requests several spellchecking before initializing. Except the last one,
 // posting requests is cancelled and text is rendered as correct one.
 TEST_F(SpellCheckTest, RequestSpellCheckMultipleTimesWithoutInitialization) {
   UninitializeSpellCheck();
 
   MockTextCheckingCompletion completion[3];
-  const string16 text[3] = {
+  const base::string16 text[3] = {
     ASCIIToUTF16("what, zz"),
     ASCIIToUTF16("apple, zz"),
     ASCIIToUTF16("orange, zz")
   };
 
   // Calls RequestTextchecking a few times.
   for (int i = 0; i < 3; ++i)
     spell_check()->RequestTextChecking(text[i], &completion[i]);
 
   // The last task will be posted after initialization, however the other
@@ skipping 11 matching lines @@
       spell_check()->pending_request_param_.release());
   base::MessageLoop::current()->RunUntilIdle();
   for (int i = 0; i < 3; ++i)
     EXPECT_EQ(completion[i].completion_count_, 1U);
 }
 
 TEST_F(SpellCheckTest, CreateTextCheckingResults) {
   // Verify that the SpellCheck class keeps the spelling marker added to a
   // misspelled word "zz".
   {
-    string16 text = ASCIIToUTF16("zz");
+    base::string16 text = ASCIIToUTF16("zz");
     std::vector<SpellCheckResult> spellcheck_results;
     spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 0, 2, string16()));
+        SpellCheckResult::SPELLING, 0, 2, base::string16()));
     blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
     spell_check()->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER,
                                              0,
                                              text,
                                              spellcheck_results,
                                              &textcheck_results);
     EXPECT_EQ(spellcheck_results.size(), textcheck_results.size());
     EXPECT_EQ(blink::WebTextDecorationTypeSpelling,
               textcheck_results[0].decoration);
     EXPECT_EQ(spellcheck_results[0].location, textcheck_results[0].location);
     EXPECT_EQ(spellcheck_results[0].length, textcheck_results[0].length);
   }
 
   // Verify that the SpellCheck class replaces the spelling marker added to a
   // contextually-misspelled word "bean" with a grammar marker.
   {
-    string16 text = ASCIIToUTF16("I have bean to USA.");
+    base::string16 text = ASCIIToUTF16("I have bean to USA.");
     std::vector<SpellCheckResult> spellcheck_results;
     spellcheck_results.push_back(SpellCheckResult(
-        SpellCheckResult::SPELLING, 7, 4, string16()));
+        SpellCheckResult::SPELLING, 7, 4, base::string16()));
     blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
     spell_check()->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER,
                                              0,
                                              text,
                                              spellcheck_results,
                                              &textcheck_results);
     EXPECT_EQ(spellcheck_results.size(), textcheck_results.size());
     EXPECT_EQ(blink::WebTextDecorationTypeGrammar,
               textcheck_results[0].decoration);
     EXPECT_EQ(spellcheck_results[0].location, textcheck_results[0].location);
@@ skipping 93 matching lines @@
         ASCIIToUTF16(kTestCases[i].suggestion).c_str(),
         static_cast<int>(suggestion_length),
         0,
         &misspelling_start,
         &misspelling_length, NULL);
 
     EXPECT_EQ(kTestCases[i].should_pass, result) << kTestCases[i].suggestion <<
         " in " << kTestCases[i].locale;
 
     // Now verify that this test case does not show up as a suggestion.
-    std::vector<string16> suggestions;
+    std::vector<base::string16> suggestions;
     size_t input_length = 0;
     if (kTestCases[i].input != NULL)
       input_length = strlen(kTestCases[i].input);
     result = spell_check()->SpellCheckWord(
         ASCIIToUTF16(kTestCases[i].input).c_str(),
         static_cast<int>(input_length),
         0,
         &misspelling_start,
         &misspelling_length,
         &suggestions);
@@ skipping 72 matching lines @@
     const char* misspelled;
     const char* suggestion;
   } kTestCases[] = {
     { "hellllo", "hello" },
     { "accidently", "accidentally" }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     int misspelling_start = 0;
     int misspelling_length = 0;
-    std::vector<string16> suggestions;
+    std::vector<base::string16> suggestions;
     EXPECT_FALSE(spell_check()->SpellCheckWord(
         ASCIIToUTF16(kTestCases[i].misspelled).c_str(),
         strlen(kTestCases[i].misspelled),
         0,
         &misspelling_start,
         &misspelling_length,
         &suggestions));
     EXPECT_GE(suggestions.size(), static_cast<size_t>(1));
     if (suggestions.size() > 0)
       EXPECT_EQ(suggestions[0], ASCIIToUTF16(kTestCases[i].suggestion));
   }
 }