Add base:: to string16s in chrome/.

chrome/tools/convert_dict/convert_dict_unittest.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 <map>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 44 matching lines @@
 
 // Implements the test process used by ConvertDictTest.
 // This function encapsulates all complicated operations used by
 // ConvertDictTest so we can conceal them from the tests themselves.
 // This function consists of the following parts:
 // * Creates a dummy affix file and a dictionary file.
 // * Reads the dummy files.
 // * Creates bdict data.
 // * Verify the bdict data.
 void RunDictionaryTest(const char* codepage,
-                       const std::map<string16, bool>& word_list) {
+                       const std::map<base::string16, bool>& word_list) {
   // Create an affix data and a dictionary data.
   std::string aff_data(base::StringPrintf("SET %s\n", codepage));
 
   std::string dic_data(base::StringPrintf("%" PRIuS "\n", word_list.size()));
-  for (std::map<string16, bool>::const_iterator it = word_list.begin();
+  for (std::map<base::string16, bool>::const_iterator it = word_list.begin();
        it != word_list.end(); ++it) {
     std::string encoded_word;
     EXPECT_TRUE(UTF16ToCodepage(it->first,
                                 codepage,
                                 base::OnStringConversionError::FAIL,
                                 &encoded_word));
     dic_data += encoded_word;
     dic_data += "\n";
   }
 
@@ skipping 13 matching lines @@
     EXPECT_TRUE(aff_reader.Read());
 
     convert_dict::DicReader dic_reader(dic_file);
     EXPECT_TRUE(dic_reader.Read(&aff_reader));
 
     // Verify this DicReader includes all the input words.
     EXPECT_EQ(word_list.size(), dic_reader.words().size());
     for (size_t i = 0; i < dic_reader.words().size(); ++i) {
       SCOPED_TRACE(base::StringPrintf("dic_reader.words()[%" PRIuS "]: %s",
                                       i, dic_reader.words()[i].first.c_str()));
-      string16 word(UTF8ToUTF16(dic_reader.words()[i].first));
+      base::string16 word(UTF8ToUTF16(dic_reader.words()[i].first));
       EXPECT_TRUE(word_list.find(word) != word_list.end());
     }
 
     // Create BDICT data and verify it.
     hunspell::BDictWriter writer;
     writer.SetComment(aff_reader.comments());
     writer.SetAffixRules(aff_reader.affix_rules());
     writer.SetAffixGroups(aff_reader.GetAffixGroups());
     writer.SetReplacements(aff_reader.replacements());
     writer.SetOtherCommands(aff_reader.other_commands());
@@ skipping 27 matching lines @@
   const wchar_t* kWords[] = {
     L"I",
     L"he",
     L"she",
     L"it",
     L"we",
     L"you",
     L"they",
   };
 
-  std::map<string16, bool> word_list;
+  std::map<base::string16, bool> word_list;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kWords); ++i)
-    word_list.insert(std::make_pair<string16, bool>(WideToUTF16(kWords[i]),
-                                                    true));
+    word_list.insert(
+        std::make_pair<base::string16, bool>(WideToUTF16(kWords[i]), true));
 
   RunDictionaryTest(kCodepage, word_list);
 }
 
 // Tests whether or not our DicReader can read all the input Russian words.
 TEST(ConvertDictTest, Russian) {
   const char kCodepage[] = "KOI8-R";
   const wchar_t* kWords[] = {
     L"\x044f",
     L"\x0442\x044b",
     L"\x043e\x043d",
     L"\x043e\x043d\x0430",
     L"\x043e\x043d\x043e",
     L"\x043c\x044b",
     L"\x0432\x044b",
     L"\x043e\x043d\x0438",
   };
 
-  std::map<string16, bool> word_list;
+  std::map<base::string16, bool> word_list;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kWords); ++i)
-    word_list.insert(std::make_pair<string16, bool>(WideToUTF16(kWords[i]),
-                                                    true));
+    word_list.insert(
+        std::make_pair<base::string16, bool>(WideToUTF16(kWords[i]), true));
 
   RunDictionaryTest(kCodepage, word_list);
 }
 
 // Tests whether or not our DicReader can read all the input Hungarian words.
 TEST(ConvertDictTest, Hungarian) {
   const char kCodepage[] = "ISO8859-2";
   const wchar_t* kWords[] = {
     L"\x00e9\x006e",
     L"\x0074\x0065",
     L"\x0151",
     L"\x00f6\x006e",
     L"\x006d\x0061\x0067\x0061",
     L"\x006d\x0069",
     L"\x0074\x0069",
     L"\x0151\x006b",
     L"\x00f6\x006e\x00f6\x006b",
     L"\x006d\x0061\x0067\x0075\x006b",
   };
 
-  std::map<string16, bool> word_list;
+  std::map<base::string16, bool> word_list;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kWords); ++i)
-    word_list.insert(std::make_pair<string16, bool>(WideToUTF16(kWords[i]),
-                                                    true));
+    word_list.insert(
+        std::make_pair<base::string16, bool>(WideToUTF16(kWords[i]), true));
 
   RunDictionaryTest(kCodepage, word_list);
 }