Convert string16 -> base::string16 in components/

components/autofill/browser/address.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 "components/autofill/browser/address.h"
 
 #include <stddef.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 33 matching lines @@
 
 void Address::GetSupportedTypes(FieldTypeSet* supported_types) const {
   supported_types->insert(ADDRESS_HOME_LINE1);
   supported_types->insert(ADDRESS_HOME_LINE2);
   supported_types->insert(ADDRESS_HOME_CITY);
   supported_types->insert(ADDRESS_HOME_STATE);
   supported_types->insert(ADDRESS_HOME_ZIP);
   supported_types->insert(ADDRESS_HOME_COUNTRY);
 }
 
-string16 Address::GetRawInfo(AutofillFieldType type) const {
+base::string16 Address::GetRawInfo(AutofillFieldType type) const {
   type = AutofillType::GetEquivalentFieldType(type);
   if (type == ADDRESS_HOME_LINE1)
     return line1_;
 
   if (type == ADDRESS_HOME_LINE2)
     return line2_;
 
   if (type == ADDRESS_HOME_CITY)
     return city_;
 
   if (type == ADDRESS_HOME_STATE)
     return state_;
 
   if (type ==  ADDRESS_HOME_ZIP)
     return zip_code_;
 
   if (type == ADDRESS_HOME_COUNTRY)
     return country_code_;
 
-  return string16();
+  return base::string16();
 }
 
-void Address::SetRawInfo(AutofillFieldType type, const string16& value) {
+void Address::SetRawInfo(AutofillFieldType type, const base::string16& value) {
   type = AutofillType::GetEquivalentFieldType(type);
   if (type == ADDRESS_HOME_LINE1) {
     line1_ = value;
   } else if (type == ADDRESS_HOME_LINE2) {
     line2_ = value;
   } else if (type == ADDRESS_HOME_CITY) {
     city_ = value;
   } else if (type == ADDRESS_HOME_STATE) {
     state_ = value;
   } else if (type == ADDRESS_HOME_COUNTRY) {
     DCHECK(value.empty() || value.length() == 2u);
     country_code_ = value;
   } else if (type == ADDRESS_HOME_ZIP) {
     zip_code_ = value;
   } else {
     NOTREACHED();
   }
 }
 
-string16 Address::GetInfo(AutofillFieldType type,
-                          const std::string& app_locale) const {
+base::string16 Address::GetInfo(AutofillFieldType type,
+                                const std::string& app_locale) const {
   type = AutofillType::GetEquivalentFieldType(type);
   if (type == ADDRESS_HOME_COUNTRY && !country_code_.empty())
     return AutofillCountry(UTF16ToASCII(country_code_), app_locale).name();
 
   return GetRawInfo(type);
 }
 
 bool Address::SetInfo(AutofillFieldType type,
-                      const string16& value,
+                      const base::string16& value,
                       const std::string& app_locale) {
   type = AutofillType::GetEquivalentFieldType(type);
   if (type == ADDRESS_HOME_COUNTRY && !value.empty()) {
     country_code_ =
         ASCIIToUTF16(AutofillCountry::GetCountryCode(value, app_locale));
     return !country_code_.empty();
   }
 
   SetRawInfo(type, value);
   return true;
 }
 
-void Address::GetMatchingTypes(const string16& text,
+void Address::GetMatchingTypes(const base::string16& text,
                                const std::string& app_locale,
                                FieldTypeSet* matching_types) const {
   FormGroup::GetMatchingTypes(text, app_locale, matching_types);
 
   // Check to see if the |text| canonicalized as a country name is a match.
   std::string country_code = AutofillCountry::GetCountryCode(text, app_locale);
   if (!country_code.empty() && country_code_ == ASCIIToUTF16(country_code))
     matching_types->insert(ADDRESS_HOME_COUNTRY);
 }