Home | History | Annotate | Download | only in wallet 
      1 // Copyright 2013 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 "components/autofill/content/browser/wallet/wallet_items.h"
      6 
      7 #include <limits>
      8 
      9 #include "base/logging.h"
     10 #include "base/strings/string_number_conversions.h"
     11 #include "base/strings/utf_string_conversions.h"
     12 #include "base/values.h"
     13 #include "components/autofill/content/browser/wallet/gaia_account.h"
     14 #include "components/autofill/core/browser/autofill_type.h"
     15 #include "components/autofill/core/browser/credit_card.h"
     16 #include "grit/components_scaled_resources.h"
     17 #include "grit/components_strings.h"
     18 #include "ui/base/l10n/l10n_util.h"
     19 #include "ui/base/resource/resource_bundle.h"
     20 #include "ui/gfx/image/image.h"
     21 #include "url/gurl.h"
     22 
     23 namespace autofill {
     24 namespace wallet {
     25 
     26 namespace {
     27 
     28 const char kLegalDocumentUrl[] =
     29     "https://wallet.google.com/legaldocument?docId=";
     30 const char kPrivacyNoticeUrl[] = "https://wallet.google.com/files/privacy.html";
     31 
     32 // TODO(estade): move to base/.
     33 template<class T>
     34 bool VectorsAreEqual(const std::vector<T*>& a, const std::vector<T*>& b) {
     35   if (a.size() != b.size())
     36     return false;
     37 
     38   for (size_t i = 0; i < a.size(); ++i) {
     39     if (*a[i] != *b[i])
     40       return false;
     41   }
     42 
     43   return true;
     44 }
     45 
     46 WalletItems::MaskedInstrument::Type
     47     TypeFromString(const std::string& type_string) {
     48   if (type_string == "VISA")
     49     return WalletItems::MaskedInstrument::VISA;
     50   if (type_string == "MASTER_CARD")
     51     return WalletItems::MaskedInstrument::MASTER_CARD;
     52   if (type_string == "AMEX")
     53     return WalletItems::MaskedInstrument::AMEX;
     54   if (type_string == "DISCOVER")
     55     return WalletItems::MaskedInstrument::DISCOVER;
     56   if (type_string == "SOLO")
     57     return WalletItems::MaskedInstrument::SOLO;
     58   if (type_string == "MAESTRO")
     59     return WalletItems::MaskedInstrument::MAESTRO;
     60   if (type_string == "SWITCH")
     61     return WalletItems::MaskedInstrument::SWITCH;
     62   return WalletItems::MaskedInstrument::UNKNOWN;
     63 }
     64 
     65 WalletItems::MaskedInstrument::Status
     66     StatusFromString(const std::string& status_string) {
     67   if (status_string == "AMEX_NOT_SUPPORTED")
     68     return WalletItems::MaskedInstrument::AMEX_NOT_SUPPORTED;
     69   if (status_string == "PENDING")
     70     return WalletItems::MaskedInstrument::PENDING;
     71   if (status_string == "VALID")
     72     return WalletItems::MaskedInstrument::VALID;
     73   if (status_string == "DECLINED")
     74     return WalletItems::MaskedInstrument::DECLINED;
     75   if (status_string == "DISABLED_FOR_THIS_MERCHANT")
     76     return WalletItems::MaskedInstrument::DISABLED_FOR_THIS_MERCHANT;
     77   if (status_string == "UNSUPPORTED_COUNTRY")
     78     return WalletItems::MaskedInstrument::UNSUPPORTED_COUNTRY;
     79   if (status_string == "EXPIRED")
     80     return WalletItems::MaskedInstrument::EXPIRED;
     81   if (status_string == "BILLING_INCOMPLETE")
     82     return WalletItems::MaskedInstrument::BILLING_INCOMPLETE;
     83   return WalletItems::MaskedInstrument::INAPPLICABLE;
     84 }
     85 
     86 base::string16 DisplayStringFromType(WalletItems::MaskedInstrument::Type type) {
     87   switch (type) {
     88     case WalletItems::MaskedInstrument::AMEX:
     89       return CreditCard::TypeForDisplay(kAmericanExpressCard);
     90     case WalletItems::MaskedInstrument::DISCOVER:
     91       return CreditCard::TypeForDisplay(kDiscoverCard);
     92     case WalletItems::MaskedInstrument::MASTER_CARD:
     93       return CreditCard::TypeForDisplay(kMasterCard);
     94     case WalletItems::MaskedInstrument::VISA:
     95       return CreditCard::TypeForDisplay(kVisaCard);
     96     default:
     97       return CreditCard::TypeForDisplay(kGenericCard);
     98   }
     99 }
    100 
    101 }  // anonymous namespace
    102 
    103 WalletItems::MaskedInstrument::MaskedInstrument(
    104     const base::string16& descriptive_name,
    105     const WalletItems::MaskedInstrument::Type& type,
    106     const base::string16& last_four_digits,
    107     int expiration_month,
    108     int expiration_year,
    109     scoped_ptr<Address> address,
    110     const WalletItems::MaskedInstrument::Status& status,
    111     const std::string& object_id)
    112     : descriptive_name_(descriptive_name),
    113       type_(type),
    114       last_four_digits_(last_four_digits),
    115       expiration_month_(expiration_month),
    116       expiration_year_(expiration_year),
    117       address_(address.Pass()),
    118       status_(status),
    119       object_id_(object_id) {
    120   DCHECK(address_);
    121 }
    122 
    123 WalletItems::MaskedInstrument::~MaskedInstrument() {}
    124 
    125 scoped_ptr<WalletItems::MaskedInstrument>
    126     WalletItems::MaskedInstrument::CreateMaskedInstrument(
    127     const base::DictionaryValue& dictionary) {
    128   std::string type_string;
    129   Type type;
    130   if (dictionary.GetString("type", &type_string)) {
    131     type = TypeFromString(type_string);
    132   } else {
    133     DLOG(ERROR) << "Response from Google Wallet missing card type";
    134     return scoped_ptr<MaskedInstrument>();
    135   }
    136 
    137   base::string16 last_four_digits;
    138   if (!dictionary.GetString("last_four_digits", &last_four_digits)) {
    139     DLOG(ERROR) << "Response from Google Wallet missing last four digits";
    140     return scoped_ptr<MaskedInstrument>();
    141   }
    142 
    143   std::string status_string;
    144   Status status;
    145   if (dictionary.GetString("status", &status_string)) {
    146     status = StatusFromString(status_string);
    147   } else {
    148     DLOG(ERROR) << "Response from Google Wallet missing status";
    149     return scoped_ptr<MaskedInstrument>();
    150   }
    151 
    152   std::string object_id;
    153   if (!dictionary.GetString("object_id", &object_id)) {
    154     DLOG(ERROR) << "Response from Google Wallet missing object id";
    155     return scoped_ptr<MaskedInstrument>();
    156   }
    157 
    158   const base::DictionaryValue* address_dict;
    159   if (!dictionary.GetDictionary("billing_address", &address_dict)) {
    160     DLOG(ERROR) << "Response from Google wallet missing address";
    161     return scoped_ptr<MaskedInstrument>();
    162   }
    163   scoped_ptr<Address> address = Address::CreateDisplayAddress(*address_dict);
    164 
    165   if (!address) {
    166     DLOG(ERROR) << "Response from Google wallet contained malformed address";
    167     return scoped_ptr<MaskedInstrument>();
    168   }
    169 
    170   int expiration_month;
    171   if (!dictionary.GetInteger("expiration_month", &expiration_month))
    172     DVLOG(1) << "Response from Google Wallet missing expiration month";
    173 
    174   int expiration_year;
    175   if (!dictionary.GetInteger("expiration_year", &expiration_year))
    176     DVLOG(1) << "Response from Google Wallet missing expiration year";
    177 
    178   base::string16 descriptive_name;
    179   if (!dictionary.GetString("descriptive_name", &descriptive_name))
    180     DVLOG(1) << "Response from Google Wallet missing descriptive name";
    181 
    182   return scoped_ptr<MaskedInstrument>(new MaskedInstrument(descriptive_name,
    183                                                            type,
    184                                                            last_four_digits,
    185                                                            expiration_month,
    186                                                            expiration_year,
    187                                                            address.Pass(),
    188                                                            status,
    189                                                            object_id));
    190 }
    191 
    192 bool WalletItems::MaskedInstrument::operator==(
    193     const WalletItems::MaskedInstrument& other) const {
    194   if (descriptive_name_ != other.descriptive_name_)
    195     return false;
    196   if (type_ != other.type_)
    197     return false;
    198   if (last_four_digits_ != other.last_four_digits_)
    199     return false;
    200   if (expiration_month_ != other.expiration_month_)
    201     return false;
    202   if (expiration_year_ != other.expiration_year_)
    203     return false;
    204   if (address_) {
    205     if (other.address_) {
    206       if (*address_ != *other.address_)
    207         return false;
    208     } else {
    209       return false;
    210     }
    211   } else if (other.address_) {
    212     return false;
    213   }
    214   if (status_ != other.status_)
    215     return false;
    216   if (object_id_ != other.object_id_)
    217     return false;
    218   return true;
    219 }
    220 
    221 bool WalletItems::MaskedInstrument::operator!=(
    222     const WalletItems::MaskedInstrument& other) const {
    223   return !(*this == other);
    224 }
    225 
    226 const WalletItems::MaskedInstrument* WalletItems::GetInstrumentById(
    227     const std::string& object_id) const {
    228   if (object_id.empty())
    229     return NULL;
    230 
    231   for (size_t i = 0; i < instruments_.size(); ++i) {
    232     if (instruments_[i]->object_id() == object_id)
    233       return instruments_[i];
    234   }
    235 
    236   return NULL;
    237 }
    238 
    239 bool WalletItems::HasRequiredAction(RequiredAction action) const {
    240   DCHECK(ActionAppliesToWalletItems(action));
    241   return std::find(required_actions_.begin(),
    242                    required_actions_.end(),
    243                    action) != required_actions_.end();
    244 }
    245 
    246 bool WalletItems::SupportsCard(const base::string16& card_number,
    247                                base::string16* message) const {
    248   const char* const card_type = CreditCard::GetCreditCardType(card_number);
    249 
    250   if (card_type == kVisaCard ||
    251       card_type == kMasterCard ||
    252       card_type == kDiscoverCard) {
    253     return true;
    254   }
    255 
    256   if (card_type == kAmericanExpressCard) {
    257     if (amex_permission_ == AMEX_ALLOWED)
    258       return true;
    259 
    260     *message = l10n_util::GetStringUTF16(
    261         IDS_AUTOFILL_CREDIT_CARD_NOT_SUPPORTED_BY_WALLET_FOR_MERCHANT);
    262     return false;
    263   }
    264 
    265   *message = l10n_util::GetStringUTF16(
    266       IDS_AUTOFILL_CREDIT_CARD_NOT_SUPPORTED_BY_WALLET);
    267    return false;
    268 }
    269 
    270 std::string WalletItems::ObfuscatedGaiaId() const {
    271   if (active_account_index_ >= gaia_accounts_.size())
    272     return std::string();
    273 
    274   return gaia_accounts_[active_account_index_]->obfuscated_id();
    275 }
    276 
    277 base::string16 WalletItems::MaskedInstrument::DisplayName() const {
    278 #if defined(OS_ANDROID)
    279   // TODO(aruslan): improve this stub implementation.
    280   return descriptive_name();
    281 #else
    282   return descriptive_name();
    283 #endif
    284 }
    285 
    286 base::string16 WalletItems::MaskedInstrument::DisplayNameDetail() const {
    287 #if defined(OS_ANDROID)
    288   // TODO(aruslan): improve this stub implementation.
    289   return address().DisplayName();
    290 #else
    291   return base::string16();
    292 #endif
    293 }
    294 
    295 base::string16 WalletItems::MaskedInstrument::TypeAndLastFourDigits() const {
    296   // TODO(dbeam): i18n.
    297   return DisplayStringFromType(type_) + base::ASCIIToUTF16(" - ") +
    298          last_four_digits();
    299 }
    300 
    301 const gfx::Image& WalletItems::MaskedInstrument::CardIcon() const {
    302   int idr = 0;
    303   switch (type_) {
    304     case AMEX:
    305       idr = IDR_AUTOFILL_CC_AMEX;
    306       break;
    307 
    308     case DISCOVER:
    309       idr = IDR_AUTOFILL_CC_DISCOVER;
    310       break;
    311 
    312     case MASTER_CARD:
    313       idr = IDR_AUTOFILL_CC_MASTERCARD;
    314       break;
    315 
    316     case VISA:
    317       idr = IDR_AUTOFILL_CC_VISA;
    318       break;
    319 
    320     case SOLO:
    321     case MAESTRO:
    322     case SWITCH:
    323     case UNKNOWN:
    324       idr = IDR_AUTOFILL_CC_GENERIC;
    325       break;
    326   }
    327 
    328   return ResourceBundle::GetSharedInstance().GetImageNamed(idr);
    329 }
    330 
    331 base::string16 WalletItems::MaskedInstrument::GetInfo(
    332     const AutofillType& type,
    333     const std::string& app_locale) const {
    334   if (type.group() != CREDIT_CARD)
    335     return address().GetInfo(type, app_locale);
    336 
    337   switch (type.GetStorableType()) {
    338     case CREDIT_CARD_NAME:
    339       return address().recipient_name();
    340 
    341     case CREDIT_CARD_NUMBER:
    342       return DisplayName();
    343 
    344     case CREDIT_CARD_EXP_4_DIGIT_YEAR:
    345       return base::IntToString16(expiration_year());
    346 
    347     case CREDIT_CARD_VERIFICATION_CODE:
    348       break;
    349 
    350     case CREDIT_CARD_TYPE:
    351       return DisplayStringFromType(type_);
    352 
    353     default:
    354       NOTREACHED();
    355   }
    356 
    357   return base::string16();
    358 }
    359 
    360 WalletItems::LegalDocument::~LegalDocument() {}
    361 
    362 scoped_ptr<WalletItems::LegalDocument>
    363     WalletItems::LegalDocument::CreateLegalDocument(
    364     const base::DictionaryValue& dictionary) {
    365   std::string id;
    366   if (!dictionary.GetString("legal_document_id", &id)) {
    367     DLOG(ERROR) << "Response from Google Wallet missing legal document id";
    368     return scoped_ptr<LegalDocument>();
    369   }
    370 
    371   base::string16 display_name;
    372   if (!dictionary.GetString("display_name", &display_name)) {
    373     DLOG(ERROR) << "Response from Google Wallet missing display name";
    374     return scoped_ptr<LegalDocument>();
    375   }
    376 
    377   return scoped_ptr<LegalDocument>(new LegalDocument(id, display_name));
    378 }
    379 
    380 scoped_ptr<WalletItems::LegalDocument>
    381     WalletItems::LegalDocument::CreatePrivacyPolicyDocument() {
    382   return scoped_ptr<LegalDocument>(new LegalDocument(
    383       GURL(kPrivacyNoticeUrl),
    384       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_PRIVACY_POLICY_LINK)));
    385 }
    386 
    387 bool WalletItems::LegalDocument::operator==(const LegalDocument& other) const {
    388   return id_ == other.id_ &&
    389          url_ == other.url_ &&
    390          display_name_ == other.display_name_;
    391 }
    392 
    393 bool WalletItems::LegalDocument::operator!=(const LegalDocument& other) const {
    394   return !(*this == other);
    395 }
    396 
    397 WalletItems::LegalDocument::LegalDocument(const std::string& id,
    398                                           const base::string16& display_name)
    399     : id_(id),
    400       url_(kLegalDocumentUrl + id),
    401       display_name_(display_name) {}
    402 
    403 WalletItems::LegalDocument::LegalDocument(const GURL& url,
    404                                           const base::string16& display_name)
    405     : url_(url),
    406       display_name_(display_name) {}
    407 
    408 WalletItems::WalletItems(const std::vector<RequiredAction>& required_actions,
    409                          const std::string& google_transaction_id,
    410                          const std::string& default_instrument_id,
    411                          const std::string& default_address_id,
    412                          AmexPermission amex_permission)
    413     : required_actions_(required_actions),
    414       google_transaction_id_(google_transaction_id),
    415       default_instrument_id_(default_instrument_id),
    416       default_address_id_(default_address_id),
    417       active_account_index_(std::numeric_limits<size_t>::max()),
    418       amex_permission_(amex_permission) {}
    419 
    420 WalletItems::~WalletItems() {}
    421 
    422 scoped_ptr<WalletItems>
    423     WalletItems::CreateWalletItems(const base::DictionaryValue& dictionary) {
    424   std::vector<RequiredAction> required_action;
    425   const base::ListValue* required_action_list;
    426   if (dictionary.GetList("required_action", &required_action_list)) {
    427     for (size_t i = 0; i < required_action_list->GetSize(); ++i) {
    428       std::string action_string;
    429       if (required_action_list->GetString(i, &action_string)) {
    430         RequiredAction action = ParseRequiredActionFromString(action_string);
    431         if (!ActionAppliesToWalletItems(action)) {
    432           DLOG(ERROR) << "Response from Google wallet with bad required action:"
    433                          " \"" << action_string << "\"";
    434           return scoped_ptr<WalletItems>();
    435         }
    436         required_action.push_back(action);
    437       }
    438     }
    439   } else {
    440     DVLOG(1) << "Response from Google wallet missing required actions";
    441   }
    442 
    443   std::string google_transaction_id;
    444   if (!dictionary.GetString("google_transaction_id", &google_transaction_id) &&
    445       required_action.empty()) {
    446     DLOG(ERROR) << "Response from Google wallet missing google transaction id";
    447     return scoped_ptr<WalletItems>();
    448   }
    449 
    450   std::string default_instrument_id;
    451   if (!dictionary.GetString("default_instrument_id", &default_instrument_id))
    452     DVLOG(1) << "Response from Google wallet missing default instrument id";
    453 
    454   std::string default_address_id;
    455   if (!dictionary.GetString("default_address_id", &default_address_id))
    456     DVLOG(1) << "Response from Google wallet missing default_address_id";
    457 
    458   // obfuscated_gaia_id is deprecated.
    459 
    460   bool amex_disallowed = true;
    461   if (!dictionary.GetBoolean("amex_disallowed", &amex_disallowed))
    462     DVLOG(1) << "Response from Google wallet missing the amex_disallowed field";
    463   AmexPermission amex_permission =
    464       amex_disallowed ? AMEX_DISALLOWED : AMEX_ALLOWED;
    465 
    466   scoped_ptr<WalletItems> wallet_items(new WalletItems(required_action,
    467                                                        google_transaction_id,
    468                                                        default_instrument_id,
    469                                                        default_address_id,
    470                                                        amex_permission));
    471   std::vector<std::string> gaia_accounts;
    472   const base::ListValue* gaia_profiles;
    473   if (dictionary.GetList("gaia_profile", &gaia_profiles)) {
    474     for (size_t i = 0; i < gaia_profiles->GetSize(); ++i) {
    475       const base::DictionaryValue* account_dict;
    476       std::string email;
    477       if (!gaia_profiles->GetDictionary(i, &account_dict))
    478         continue;
    479 
    480       scoped_ptr<GaiaAccount> gaia_account(
    481           GaiaAccount::Create(*account_dict));
    482       if (gaia_account)
    483         wallet_items->AddAccount(gaia_account.Pass());
    484     }
    485   } else {
    486     DVLOG(1) << "Response from Google wallet missing GAIA accounts";
    487   }
    488 
    489   const base::ListValue* legal_docs;
    490   if (dictionary.GetList("required_legal_document", &legal_docs)) {
    491     for (size_t i = 0; i < legal_docs->GetSize(); ++i) {
    492       const base::DictionaryValue* legal_doc_dict;
    493       if (legal_docs->GetDictionary(i, &legal_doc_dict)) {
    494         scoped_ptr<LegalDocument> legal_doc(
    495             LegalDocument::CreateLegalDocument(*legal_doc_dict));
    496         if (legal_doc)
    497           wallet_items->AddLegalDocument(legal_doc.Pass());
    498         else
    499           return scoped_ptr<WalletItems>();
    500       }
    501     }
    502 
    503     if (!legal_docs->empty()) {
    504       // Always append the privacy policy link as well.
    505       wallet_items->AddLegalDocument(
    506           LegalDocument::CreatePrivacyPolicyDocument());
    507     }
    508   } else {
    509     DVLOG(1) << "Response from Google wallet missing legal docs";
    510   }
    511 
    512   const base::ListValue* instruments;
    513   if (dictionary.GetList("instrument", &instruments)) {
    514     for (size_t i = 0; i < instruments->GetSize(); ++i) {
    515       const base::DictionaryValue* instrument_dict;
    516       if (instruments->GetDictionary(i, &instrument_dict)) {
    517         scoped_ptr<MaskedInstrument> instrument(
    518             MaskedInstrument::CreateMaskedInstrument(*instrument_dict));
    519         if (instrument)
    520           wallet_items->AddInstrument(instrument.Pass());
    521       }
    522     }
    523   } else {
    524     DVLOG(1) << "Response from Google wallet missing instruments";
    525   }
    526 
    527   const base::ListValue* addresses;
    528   if (dictionary.GetList("address", &addresses)) {
    529     for (size_t i = 0; i < addresses->GetSize(); ++i) {
    530       const base::DictionaryValue* address_dict;
    531       if (addresses->GetDictionary(i, &address_dict)) {
    532         scoped_ptr<Address> address(
    533             Address::CreateAddressWithID(*address_dict));
    534         if (address)
    535           wallet_items->AddAddress(address.Pass());
    536       }
    537     }
    538   } else {
    539     DVLOG(1) << "Response from Google wallet missing addresses";
    540   }
    541 
    542   const base::ListValue* allowed_shipping_countries;
    543   if (dictionary.GetList("allowed_shipping_spec_by_country",
    544                          &allowed_shipping_countries)) {
    545     for (size_t i = 0; i < allowed_shipping_countries->GetSize(); ++i) {
    546       const base::DictionaryValue* country_spec;
    547       std::string country_code;
    548       if (allowed_shipping_countries->GetDictionary(i, &country_spec) &&
    549           country_spec->GetString("country_code", &country_code)) {
    550         wallet_items->AddAllowedShippingCountry(country_code);
    551       }
    552     }
    553   } else {
    554     DVLOG(1) << "Response from Google wallet missing allowed shipping"
    555                 " countries";
    556   }
    557 
    558   return wallet_items.Pass();
    559 }
    560 
    561 void WalletItems::AddAccount(scoped_ptr<GaiaAccount> account) {
    562   if (account->index() != gaia_accounts_.size()) {
    563     DVLOG(1) << "Tried to add account out of order";
    564     return;
    565   }
    566 
    567   if (account->is_active())
    568     active_account_index_ = account->index();
    569 
    570   gaia_accounts_.push_back(account.release());
    571 }
    572 
    573 bool WalletItems::operator==(const WalletItems& other) const {
    574   return google_transaction_id_ == other.google_transaction_id_ &&
    575          default_instrument_id_ == other.default_instrument_id_ &&
    576          default_address_id_ == other.default_address_id_ &&
    577          required_actions_ == other.required_actions_ &&
    578          // This check is technically redundant, but is useful for tests.
    579          ObfuscatedGaiaId() == other.ObfuscatedGaiaId() &&
    580          active_account_index() == other.active_account_index() &&
    581          VectorsAreEqual<GaiaAccount>(gaia_accounts(),
    582                                       other.gaia_accounts()) &&
    583          VectorsAreEqual<MaskedInstrument>(instruments(),
    584                                             other.instruments()) &&
    585          VectorsAreEqual<Address>(addresses(), other.addresses()) &&
    586          VectorsAreEqual<LegalDocument>(legal_documents(),
    587                                          other.legal_documents()) &&
    588          allowed_shipping_countries() == other.allowed_shipping_countries();
    589 }
    590 
    591 bool WalletItems::operator!=(const WalletItems& other) const {
    592   return !(*this == other);
    593 }
    594 
    595 }  // namespace wallet
    596 }  // namespace autofill
    597