Convert string16 -> base::string16 in components/

components/autofill/browser/wallet/wallet_items.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 "components/autofill/browser/wallet/wallet_items.h"
 
 #include "base/logging.h"
-#include "base/string_number_conversions.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/autofill/browser/autofill_type.h"
 #include "components/autofill/browser/credit_card.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "grit/webkit_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image.h"
@@ skipping 57 matching lines @@
   if (status_string == "EXPIRED")
     return WalletItems::MaskedInstrument::EXPIRED;
   if (status_string == "BILLING_INCOMPLETE")
     return WalletItems::MaskedInstrument::BILLING_INCOMPLETE;
   return WalletItems::MaskedInstrument::INAPPLICABLE;
 }
 
 }  // anonymous namespace
 
 WalletItems::MaskedInstrument::MaskedInstrument(
-    const string16& descriptive_name,
+    const base::string16& descriptive_name,
     const WalletItems::MaskedInstrument::Type& type,
-    const std::vector<string16>& supported_currencies,
-    const string16& last_four_digits,
+    const std::vector<base::string16>& supported_currencies,
+    const base::string16& last_four_digits,
     int expiration_month,
     int expiration_year,
     scoped_ptr<Address> address,
     const WalletItems::MaskedInstrument::Status& status,
     const std::string& object_id)
     : descriptive_name_(descriptive_name),
       type_(type),
       supported_currencies_(supported_currencies),
       last_four_digits_(last_four_digits),
       expiration_month_(expiration_month),
@@ skipping 11 matching lines @@
     const base::DictionaryValue& dictionary) {
   std::string type_string;
   Type type;
   if (dictionary.GetString("type", &type_string)) {
     type = TypeFromString(type_string);
   } else {
     DLOG(ERROR) << "Response from Google Wallet missing card type";
     return scoped_ptr<MaskedInstrument>();
   }
 
-  string16 last_four_digits;
+  base::string16 last_four_digits;
   if (!dictionary.GetString("last_four_digits", &last_four_digits)) {
     DLOG(ERROR) << "Response from Google Wallet missing last four digits";
     return scoped_ptr<MaskedInstrument>();
   }
 
   std::string status_string;
   Status status;
   if (dictionary.GetString("status", &status_string)) {
     status = StatusFromString(status_string);
   } else {
@@ skipping 12 matching lines @@
     DLOG(ERROR) << "Response from Google wallet missing address";
     return scoped_ptr<MaskedInstrument>();
   }
   scoped_ptr<Address> address = Address::CreateDisplayAddress(*address_dict);
 
   if (!address.get()) {
     DLOG(ERROR) << "Response from Google wallet contained malformed address";
     return scoped_ptr<MaskedInstrument>();
   }
 
-  std::vector<string16> supported_currencies;
+  std::vector<base::string16> supported_currencies;
   const ListValue* supported_currency_list;
   if (dictionary.GetList("supported_currency", &supported_currency_list)) {
     for (size_t i = 0; i < supported_currency_list->GetSize(); ++i) {
-      string16 currency;
+      base::string16 currency;
       if (supported_currency_list->GetString(i, &currency))
         supported_currencies.push_back(currency);
     }
   } else {
     DVLOG(1) << "Response from Google Wallet missing supported currency";
   }
 
   int expiration_month;
   if (!dictionary.GetInteger("expiration_month", &expiration_month))
     DVLOG(1) << "Response from Google Wallet missing expiration month";
 
   int expiration_year;
   if (!dictionary.GetInteger("expiration_year", &expiration_year))
     DVLOG(1) << "Response from Google Wallet missing expiration year";
 
-  string16 descriptive_name;
+  base::string16 descriptive_name;
   if (!dictionary.GetString("descriptive_name", &descriptive_name))
     DVLOG(1) << "Response from Google Wallet missing descriptive name";
 
   return scoped_ptr<MaskedInstrument>(new MaskedInstrument(descriptive_name,
                                                            type,
                                                            supported_currencies,
                                                            last_four_digits,
                                                            expiration_month,
                                                            expiration_year,
                                                            address.Pass(),
@@ skipping 50 matching lines @@
     return NULL;
 
   for (size_t i = 0; i < instruments_.size(); ++i) {
     if (instruments_[i]->object_id() == object_id)
       return instruments_[i];
   }
 
   return NULL;
 }
 
-string16 WalletItems::MaskedInstrument::DisplayName() const {
+base::string16 WalletItems::MaskedInstrument::DisplayName() const {
 #if defined(OS_ANDROID)
   // TODO(aruslan): improve this stub implementation.
   return descriptive_name();
 #else
   return descriptive_name();
 #endif
 }
 
-string16 WalletItems::MaskedInstrument::DisplayNameDetail() const {
+base::string16 WalletItems::MaskedInstrument::DisplayNameDetail() const {
 #if defined(OS_ANDROID)
   // TODO(aruslan): improve this stub implementation.
   return address().DisplayName();
 #else
-  return string16();
+  return base::string16();
 #endif
 }
 
-string16 WalletItems::MaskedInstrument::TypeAndLastFourDigits() const {
-  string16 display_type;
+base::string16 WalletItems::MaskedInstrument::TypeAndLastFourDigits() const {
+  base::string16 display_type;
 
   if (type_ == AMEX)
     display_type = CreditCard::TypeForDisplay(kAmericanExpressCard);
   else if (type_ == DISCOVER)
     display_type = CreditCard::TypeForDisplay(kDiscoverCard);
   else if (type_ == MASTER_CARD)
     display_type = CreditCard::TypeForDisplay(kMasterCard);
   else if (type_ == SOLO)
     display_type = CreditCard::TypeForDisplay(kSoloCard);
   else if (type_ == VISA)
@@ skipping 31 matching lines @@
     case MAESTRO:
     case SWITCH:
     case UNKNOWN:
       idr = IDR_AUTOFILL_CC_GENERIC;
       break;
   }
 
   return ResourceBundle::GetSharedInstance().GetImageNamed(idr);
 }
 
-string16 WalletItems::MaskedInstrument::GetInfo(
+base::string16 WalletItems::MaskedInstrument::GetInfo(
     AutofillFieldType type,
     const std::string& app_locale) const {
   if (AutofillType(type).group() != AutofillType::CREDIT_CARD)
     return address().GetInfo(type, app_locale);
 
   switch (type) {
     case CREDIT_CARD_NAME:
       return address().recipient_name();
 
     case CREDIT_CARD_NUMBER:
       // TODO(dbeam): show these as XXXX-#### and non-editable in the UI.
       return last_four_digits();
 
     case CREDIT_CARD_EXP_4_DIGIT_YEAR:
       return base::IntToString16(expiration_year());
 
     case CREDIT_CARD_VERIFICATION_CODE:
       break;
 
     default:
       NOTREACHED();
   }
 
-  return string16();
+  return base::string16();
 }
 
 WalletItems::LegalDocument::~LegalDocument() {}
 
 scoped_ptr<WalletItems::LegalDocument>
     WalletItems::LegalDocument::CreateLegalDocument(
     const base::DictionaryValue& dictionary) {
   std::string id;
   if (!dictionary.GetString("legal_document_id", &id)) {
     DLOG(ERROR) << "Response from Google Wallet missing legal document id";
     return scoped_ptr<LegalDocument>();
   }
 
-  string16 display_name;
+  base::string16 display_name;
   if (!dictionary.GetString("display_name", &display_name)) {
     DLOG(ERROR) << "Response from Google Wallet missing display name";
     return scoped_ptr<LegalDocument>();
   }
 
   return scoped_ptr<LegalDocument>(new LegalDocument(id, display_name));
 }
 
 scoped_ptr<WalletItems::LegalDocument>
     WalletItems::LegalDocument::CreatePrivacyPolicyDocument() {
   return scoped_ptr<LegalDocument>(new LegalDocument(
       GURL(kPrivacyNoticeUrl),
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_PRIVACY_POLICY_LINK)));
 }
 
 bool WalletItems::LegalDocument::operator==(const LegalDocument& other) const {
   return id_ == other.id_ &&
          url_ == other.url_ &&
          display_name_ == other.display_name_;
 }
 
 bool WalletItems::LegalDocument::operator!=(const LegalDocument& other) const {
   return !(*this == other);
 }
 
 WalletItems::LegalDocument::LegalDocument(const std::string& id,
-                                          const string16& display_name)
+                                          const base::string16& display_name)
     : id_(id),
       url_(kLegalDocumentUrl + id),
       display_name_(display_name) {}
 
 WalletItems::LegalDocument::LegalDocument(const GURL& url,
-                                          const string16& display_name)
+                                          const base::string16& display_name)
     : url_(url),
       display_name_(display_name) {}
 
 WalletItems::WalletItems(const std::vector<RequiredAction>& required_actions,
                          const std::string& google_transaction_id,
                          const std::string& default_instrument_id,
                          const std::string& default_address_id,
                          const std::string& obfuscated_gaia_id)
     : required_actions_(required_actions),
       google_transaction_id_(google_transaction_id),
@@ skipping 124 matching lines @@
          VectorsAreEqual<LegalDocument>(legal_documents(),
                                         other.legal_documents());
 }
 
 bool WalletItems::operator!=(const WalletItems& other) const {
   return !(*this == other);
 }
 
 }  // namespace wallet
 }  // namespace autofill