Home | History | Annotate | Download | only in autofill 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/ui/autofill/data_model_wrapper.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/callback.h"
      9 #include "base/strings/string_util.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 #include "chrome/browser/browser_process.h"
     12 #include "chrome/browser/ui/autofill/autofill_dialog_i18n_input.h"
     13 #include "chrome/browser/ui/autofill/autofill_dialog_models.h"
     14 #include "components/autofill/content/browser/wallet/full_wallet.h"
     15 #include "components/autofill/content/browser/wallet/wallet_address.h"
     16 #include "components/autofill/content/browser/wallet/wallet_items.h"
     17 #include "components/autofill/core/browser/address_i18n.h"
     18 #include "components/autofill/core/browser/autofill_country.h"
     19 #include "components/autofill/core/browser/autofill_data_model.h"
     20 #include "components/autofill/core/browser/autofill_field.h"
     21 #include "components/autofill/core/browser/autofill_profile.h"
     22 #include "components/autofill/core/browser/autofill_type.h"
     23 #include "components/autofill/core/browser/credit_card.h"
     24 #include "components/autofill/core/browser/form_structure.h"
     25 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_data.h"
     26 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_field.h"
     27 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_formatter.h"
     28 #include "ui/base/resource/resource_bundle.h"
     29 #include "ui/gfx/image/image.h"
     30 
     31 namespace autofill {
     32 
     33 DataModelWrapper::~DataModelWrapper() {}
     34 
     35 void DataModelWrapper::FillInputs(DetailInputs* inputs) {
     36   for (size_t i = 0; i < inputs->size(); ++i) {
     37     (*inputs)[i].initial_value =
     38         GetInfoForDisplay(AutofillType((*inputs)[i].type));
     39   }
     40 }
     41 
     42 base::string16 DataModelWrapper::GetInfoForDisplay(const AutofillType& type)
     43     const {
     44   return GetInfo(type);
     45 }
     46 
     47 gfx::Image DataModelWrapper::GetIcon() {
     48   return gfx::Image();
     49 }
     50 
     51 bool DataModelWrapper::GetDisplayText(
     52     base::string16* vertically_compact,
     53     base::string16* horizontally_compact) {
     54   base::string16 phone =
     55       GetInfoForDisplay(AutofillType(PHONE_HOME_WHOLE_NUMBER));
     56   if (phone.empty())
     57     return false;
     58 
     59   // Format the address.
     60   scoped_ptr< ::i18n::addressinput::AddressData> address_data =
     61       i18n::CreateAddressData(
     62           base::Bind(&DataModelWrapper::GetInfo, base::Unretained(this)));
     63   address_data->language_code = GetLanguageCode();
     64   // Interactive autofill dialog does not display organization field.
     65   address_data->organization.clear();
     66   std::vector<std::string> lines;
     67   ::i18n::addressinput::GetFormattedNationalAddress(*address_data, &lines);
     68 
     69   std::string single_line;
     70   ::i18n::addressinput::GetFormattedNationalAddressLine(
     71        *address_data, &single_line);
     72 
     73   // Email and phone number aren't part of address formatting.
     74   base::string16 non_address_info;
     75   base::string16 email = GetInfoForDisplay(AutofillType(EMAIL_ADDRESS));
     76   if (!email.empty())
     77     non_address_info += base::ASCIIToUTF16("\n") + email;
     78 
     79   non_address_info += base::ASCIIToUTF16("\n") + phone;
     80 
     81   *vertically_compact = base::UTF8ToUTF16(single_line) + non_address_info;
     82   *horizontally_compact = base::UTF8ToUTF16(JoinString(lines, "\n")) +
     83       non_address_info;
     84 
     85   return true;
     86 }
     87 
     88 bool DataModelWrapper::FillFormStructure(
     89     const std::vector<ServerFieldType>& types,
     90     const FormStructure::InputFieldComparator& compare,
     91     FormStructure* form_structure) const {
     92   return form_structure->FillFields(
     93       types,
     94       compare,
     95       base::Bind(&DataModelWrapper::GetInfo, base::Unretained(this)),
     96       GetLanguageCode(),
     97       g_browser_process->GetApplicationLocale());
     98 }
     99 
    100 DataModelWrapper::DataModelWrapper() {}
    101 
    102 // AutofillProfileWrapper
    103 
    104 AutofillProfileWrapper::AutofillProfileWrapper(const AutofillProfile* profile)
    105     : profile_(profile),
    106       variant_group_(NO_GROUP),
    107       variant_(0) {}
    108 
    109 AutofillProfileWrapper::AutofillProfileWrapper(
    110     const AutofillProfile* profile,
    111     const AutofillType& type,
    112     size_t variant)
    113     : profile_(profile),
    114       variant_group_(type.group()),
    115       variant_(variant) {}
    116 
    117 AutofillProfileWrapper::~AutofillProfileWrapper() {}
    118 
    119 base::string16 AutofillProfileWrapper::GetInfo(const AutofillType& type) const {
    120   // Requests for the user's credit card are filled from the billing address,
    121   // but the AutofillProfile class doesn't know how to fill credit card
    122   // fields. So, request for the corresponding profile type instead.
    123   AutofillType effective_type = type;
    124   if (type.GetStorableType() == CREDIT_CARD_NAME)
    125     effective_type = AutofillType(NAME_BILLING_FULL);
    126 
    127   size_t variant = GetVariantForType(effective_type);
    128   const std::string& app_locale = g_browser_process->GetApplicationLocale();
    129   return profile_->GetInfoForVariant(effective_type, variant, app_locale);
    130 }
    131 
    132 base::string16 AutofillProfileWrapper::GetInfoForDisplay(
    133     const AutofillType& type) const {
    134   // We display the "raw" phone number which contains user-defined formatting.
    135   if (type.GetStorableType() == PHONE_HOME_WHOLE_NUMBER) {
    136     std::vector<base::string16> values;
    137     profile_->GetRawMultiInfo(type.GetStorableType(), &values);
    138     const base::string16& phone_number = values[GetVariantForType(type)];
    139 
    140     // If there is no user-defined formatting at all, add some standard
    141     // formatting.
    142     if (base::ContainsOnlyChars(phone_number,
    143                                 base::ASCIIToUTF16("+0123456789"))) {
    144       std::string region = base::UTF16ToASCII(
    145           GetInfo(AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE)));
    146       i18n::PhoneObject phone(phone_number, region);
    147       base::string16 formatted_number = phone.GetFormattedNumber();
    148       // Formatting may fail.
    149       if (!formatted_number.empty())
    150         return formatted_number;
    151     }
    152 
    153     return phone_number;
    154   }
    155 
    156   return DataModelWrapper::GetInfoForDisplay(type);
    157 }
    158 
    159 const std::string& AutofillProfileWrapper::GetLanguageCode() const {
    160   return profile_->language_code();
    161 }
    162 
    163 size_t AutofillProfileWrapper::GetVariantForType(const AutofillType& type)
    164     const {
    165   if (type.group() == variant_group_)
    166     return variant_;
    167 
    168   return 0;
    169 }
    170 
    171 // AutofillShippingAddressWrapper
    172 
    173 AutofillShippingAddressWrapper::AutofillShippingAddressWrapper(
    174     const AutofillProfile* profile)
    175     : AutofillProfileWrapper(profile) {}
    176 
    177 AutofillShippingAddressWrapper::~AutofillShippingAddressWrapper() {}
    178 
    179 base::string16 AutofillShippingAddressWrapper::GetInfo(
    180     const AutofillType& type) const {
    181   // Shipping addresses don't have email addresses associated with them.
    182   if (type.GetStorableType() == EMAIL_ADDRESS)
    183     return base::string16();
    184 
    185   return AutofillProfileWrapper::GetInfo(type);
    186 }
    187 
    188 // AutofillCreditCardWrapper
    189 
    190 AutofillCreditCardWrapper::AutofillCreditCardWrapper(const CreditCard* card)
    191     : card_(card) {}
    192 
    193 AutofillCreditCardWrapper::~AutofillCreditCardWrapper() {}
    194 
    195 base::string16 AutofillCreditCardWrapper::GetInfo(const AutofillType& type)
    196     const {
    197   if (type.group() != CREDIT_CARD)
    198     return base::string16();
    199 
    200   if (type.GetStorableType() == CREDIT_CARD_EXP_MONTH)
    201     return MonthComboboxModel::FormatMonth(card_->expiration_month());
    202 
    203   return card_->GetInfo(type, g_browser_process->GetApplicationLocale());
    204 }
    205 
    206 gfx::Image AutofillCreditCardWrapper::GetIcon() {
    207   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
    208   return rb.GetImageNamed(CreditCard::IconResourceId(card_->type()));
    209 }
    210 
    211 bool AutofillCreditCardWrapper::GetDisplayText(
    212     base::string16* vertically_compact,
    213     base::string16* horizontally_compact) {
    214   if (!card_->IsValid())
    215     return false;
    216 
    217   *vertically_compact = *horizontally_compact = card_->TypeAndLastFourDigits();
    218   return true;
    219 }
    220 
    221 const std::string& AutofillCreditCardWrapper::GetLanguageCode() const {
    222   // Formatting a credit card for display does not depend on language code.
    223   return base::EmptyString();
    224 }
    225 
    226 // WalletAddressWrapper
    227 
    228 WalletAddressWrapper::WalletAddressWrapper(
    229     const wallet::Address* address) : address_(address) {}
    230 
    231 WalletAddressWrapper::~WalletAddressWrapper() {}
    232 
    233 base::string16 WalletAddressWrapper::GetInfo(const AutofillType& type) const {
    234   // Reachable from DataModelWrapper::GetDisplayText().
    235   if (type.GetStorableType() == EMAIL_ADDRESS)
    236     return base::string16();
    237 
    238   return address_->GetInfo(type, g_browser_process->GetApplicationLocale());
    239 }
    240 
    241 base::string16 WalletAddressWrapper::GetInfoForDisplay(const AutofillType& type)
    242     const {
    243   if (type.GetStorableType() == PHONE_HOME_WHOLE_NUMBER)
    244     return address_->DisplayPhoneNumber();
    245 
    246   return DataModelWrapper::GetInfoForDisplay(type);
    247 }
    248 
    249 bool WalletAddressWrapper::GetDisplayText(
    250     base::string16* vertically_compact,
    251     base::string16* horizontally_compact) {
    252   if (!address_->is_complete_address())
    253     return false;
    254 
    255   return DataModelWrapper::GetDisplayText(vertically_compact,
    256                                           horizontally_compact);
    257 }
    258 
    259 const std::string& WalletAddressWrapper::GetLanguageCode() const {
    260   return address_->language_code();
    261 }
    262 
    263 // WalletInstrumentWrapper
    264 
    265 WalletInstrumentWrapper::WalletInstrumentWrapper(
    266     const wallet::WalletItems::MaskedInstrument* instrument)
    267     : instrument_(instrument) {}
    268 
    269 WalletInstrumentWrapper::~WalletInstrumentWrapper() {}
    270 
    271 base::string16 WalletInstrumentWrapper::GetInfo(const AutofillType& type)
    272     const {
    273   // Reachable from DataModelWrapper::GetDisplayText().
    274   if (type.GetStorableType() == EMAIL_ADDRESS)
    275     return base::string16();
    276 
    277   if (type.GetStorableType() == CREDIT_CARD_EXP_MONTH)
    278     return MonthComboboxModel::FormatMonth(instrument_->expiration_month());
    279 
    280   return instrument_->GetInfo(type, g_browser_process->GetApplicationLocale());
    281 }
    282 
    283 base::string16 WalletInstrumentWrapper::GetInfoForDisplay(
    284     const AutofillType& type) const {
    285   if (type.GetStorableType() == PHONE_HOME_WHOLE_NUMBER)
    286     return instrument_->address().DisplayPhoneNumber();
    287 
    288   return DataModelWrapper::GetInfoForDisplay(type);
    289 }
    290 
    291 gfx::Image WalletInstrumentWrapper::GetIcon() {
    292   return instrument_->CardIcon();
    293 }
    294 
    295 bool WalletInstrumentWrapper::GetDisplayText(
    296     base::string16* vertically_compact,
    297     base::string16* horizontally_compact) {
    298   // TODO(dbeam): handle other instrument statuses? http://crbug.com/233048
    299   if (instrument_->status() == wallet::WalletItems::MaskedInstrument::EXPIRED ||
    300       !instrument_->address().is_complete_address()) {
    301     return false;
    302   }
    303 
    304   if (!DataModelWrapper::GetDisplayText(vertically_compact,
    305                                         horizontally_compact)) {
    306     return false;
    307   }
    308 
    309   // TODO(estade): descriptive_name() is user-provided. Should we use it or
    310   // just type + last 4 digits?
    311   base::string16 line1 =
    312       instrument_->descriptive_name() + base::ASCIIToUTF16("\n");
    313   *vertically_compact = line1 + *vertically_compact;
    314   *horizontally_compact = line1 + *horizontally_compact;
    315   return true;
    316 }
    317 
    318 const std::string& WalletInstrumentWrapper::GetLanguageCode() const {
    319   return instrument_->address().language_code();
    320 }
    321 
    322 // FullWalletBillingWrapper
    323 
    324 FullWalletBillingWrapper::FullWalletBillingWrapper(
    325     wallet::FullWallet* full_wallet)
    326     : full_wallet_(full_wallet) {
    327   DCHECK(full_wallet_);
    328 }
    329 
    330 FullWalletBillingWrapper::~FullWalletBillingWrapper() {}
    331 
    332 base::string16 FullWalletBillingWrapper::GetInfo(const AutofillType& type)
    333     const {
    334   return full_wallet_->GetInfo(g_browser_process->GetApplicationLocale(), type);
    335 }
    336 
    337 bool FullWalletBillingWrapper::GetDisplayText(
    338     base::string16* vertically_compact,
    339     base::string16* horizontally_compact) {
    340   // TODO(dbeam): handle other required actions? http://crbug.com/163508
    341   if (full_wallet_->HasRequiredAction(wallet::UPDATE_EXPIRATION_DATE))
    342     return false;
    343 
    344   return DataModelWrapper::GetDisplayText(vertically_compact,
    345                                           horizontally_compact);
    346 }
    347 
    348 const std::string& FullWalletBillingWrapper::GetLanguageCode() const {
    349   // Can be NULL if there are required actions.
    350   return full_wallet_->billing_address() ?
    351       full_wallet_->billing_address()->language_code() : base::EmptyString();
    352 }
    353 
    354 // FullWalletShippingWrapper
    355 
    356 FullWalletShippingWrapper::FullWalletShippingWrapper(
    357     wallet::FullWallet* full_wallet)
    358     : full_wallet_(full_wallet) {
    359   DCHECK(full_wallet_);
    360 }
    361 
    362 FullWalletShippingWrapper::~FullWalletShippingWrapper() {}
    363 
    364 base::string16 FullWalletShippingWrapper::GetInfo(
    365     const AutofillType& type) const {
    366   return full_wallet_->shipping_address()->GetInfo(
    367       type, g_browser_process->GetApplicationLocale());
    368 }
    369 
    370 const std::string& FullWalletShippingWrapper::GetLanguageCode() const {
    371   // Can be NULL if there are required actions or shipping address is not
    372   // required.
    373   return full_wallet_->shipping_address() ?
    374       full_wallet_->shipping_address()->language_code() : base::EmptyString();
    375 }
    376 
    377 // I18nAddressDataWrapper
    378 
    379 I18nAddressDataWrapper::I18nAddressDataWrapper(
    380     const ::i18n::addressinput::AddressData* address)
    381     : address_(address) {}
    382 
    383 I18nAddressDataWrapper::~I18nAddressDataWrapper() {}
    384 
    385 base::string16 I18nAddressDataWrapper::GetInfo(const AutofillType& type) const {
    386   ::i18n::addressinput::AddressField field;
    387   if (!i18n::FieldForType(type.GetStorableType(), &field))
    388     return base::string16();
    389 
    390   if (field == ::i18n::addressinput::STREET_ADDRESS)
    391     return base::string16();
    392 
    393   if (field == ::i18n::addressinput::COUNTRY) {
    394     return AutofillCountry(address_->region_code,
    395                            g_browser_process->GetApplicationLocale()).name();
    396   }
    397 
    398   return base::UTF8ToUTF16(address_->GetFieldValue(field));
    399 }
    400 
    401 const std::string& I18nAddressDataWrapper::GetLanguageCode() const {
    402   return address_->language_code;
    403 }
    404 
    405 }  // namespace autofill
    406