Convert string16 to base::string16 in content.

content/common/android/address_parser_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/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/android/address_parser.h"
 #include "content/common/android/address_parser_internal.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using namespace content::address_parser;
 using namespace content::address_parser::internal;
 
 class AddressParserTest : public testing::Test {
  public:
   AddressParserTest() {}
 
   void TokenizeWords(const base::string16& content, WordList* words) const {
     String16Tokenizer tokenizer(content.begin(), content.end(),
                                 base::kWhitespaceUTF16);
     while (tokenizer.GetNext()) {
       words->push_back(Word(tokenizer.token_begin(), tokenizer.token_end()));
     }
   }
 
   std::string GetHouseNumber(const std::string& content) const {
-    string16 content_16 = UTF8ToUTF16(content);
-    string16 result;
+    base::string16 content_16 = UTF8ToUTF16(content);
+    base::string16 result;
 
     HouseNumberParser parser;
     Word word;
     if (parser.Parse(content_16.begin(), content_16.end(), &word))
-      result = string16(word.begin, word.end);
+      result = base::string16(word.begin, word.end);
     return UTF16ToUTF8(result);
   }
 
   bool ContainsHouseNumber(const std::string& content) const {
     return !GetHouseNumber(content).empty();
   }
 
   bool GetState(const std::string& state, size_t* state_index) const {
     base::string16 state_16 = UTF8ToUTF16(state);
     String16Tokenizer tokenizer(state_16.begin(), state_16.end(),
@@ skipping 10 matching lines @@
 
   bool IsState(const std::string& state) const {
     size_t state_index;
     return GetState(state, &state_index);
   }
 
   bool IsZipValid(const std::string& zip, const std::string& state) const {
     size_t state_index;
     EXPECT_TRUE(GetState(state, &state_index));
 
-    string16 zip_16 = UTF8ToUTF16(zip);
+    base::string16 zip_16 = UTF8ToUTF16(zip);
     WordList words;
     TokenizeWords(zip_16, &words);
     EXPECT_TRUE(words.size() == 1);
     return ::IsZipValid(words.front(), state_index);
   }
 
   bool IsLocationName(const std::string& street) const {
-    string16 street_16 = UTF8ToUTF16(street);
+    base::string16 street_16 = UTF8ToUTF16(street);
     WordList words;
     TokenizeWords(street_16, &words);
     EXPECT_TRUE(words.size() == 1);
     return IsValidLocationName(words.front());
   }
 
   std::string FindAddress(const std::string& content) const {
-    string16 content_16 = UTF8ToUTF16(content);
-    string16 result_16;
+    base::string16 content_16 = UTF8ToUTF16(content);
+    base::string16 result_16;
     size_t start, end;
     if (::FindAddress(content_16.begin(), content_16.end(), &start, &end))
       result_16 = content_16.substr(start, end - start);
     return UTF16ToUTF8(result_16);
   }
 
   bool ContainsAddress(const std::string& content) const {
     return !FindAddress(content).empty();
   }
 
@@ skipping 492 matching lines @@
   EXPECT_TRUE(IsAddress("79th Street 1st Floor New York City, NY 10024-5192"));
 
   EXPECT_FALSE(ContainsAddress("123 Fake Street, Springfield, Springfield"));
   EXPECT_FALSE(ContainsAddress("999 Street Avenue, City, ZZ 98765"));
   EXPECT_FALSE(ContainsAddress("76 Here be dragons, CA 94043"));
   EXPECT_FALSE(ContainsAddress("1 This, has, too* many, lines, to, be* valid"));
   EXPECT_FALSE(ContainsAddress(
       "1 Supercalifragilisticexpialidocious is too long, CA 90000"));
   EXPECT_FALSE(ContainsAddress(""));
 }