Highlight fields we know to be invalid but have no way of locally checking.

chrome/browser/ui/autofill/autofill_dialog_controller_impl.cc

 // Copyright 2013 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 "chrome/browser/ui/autofill/autofill_dialog_controller_impl.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 
@@ skipping 981 matching lines @@
 string16 AutofillDialogControllerImpl::ExtraSuggestionTextForSection(
     DialogSection section) const {
   if (section == SECTION_CC ||
       (section == SECTION_CC_BILLING && IsSubmitPausedOn(wallet::VERIFY_CVV))) {
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_PLACEHOLDER_CVC);
   }
 
   return string16();
 }
 
+const wallet::WalletItems::MaskedInstrument* AutofillDialogControllerImpl::
+    ActiveInstrument() const {
+  if (!IsPayingWithWallet())
+    return NULL;
+
+  const SuggestionsMenuModel* model =
+      SuggestionsMenuModelForSection(SECTION_CC_BILLING);
+  const std::string item_key = model->GetItemKeyForCheckedItem();
+  if (!IsASuggestionItemKey(item_key))
+    return NULL;
+
+  int index;
+  if (!base::StringToInt(item_key, &index) || index < 0 ||
+      static_cast<size_t>(index) >= wallet_items_->instruments().size()) {
+    NOTREACHED();
+    return NULL;
+  }
+
+  return wallet_items_->instruments()[index];
+}
+
+const wallet::Address* AutofillDialogControllerImpl::
+    ActiveShippingAddress() const {
+  if (!IsPayingWithWallet())
+    return NULL;
+
+  const SuggestionsMenuModel* model =
+      SuggestionsMenuModelForSection(SECTION_SHIPPING);
+  const std::string item_key = model->GetItemKeyForCheckedItem();
+  if (!IsASuggestionItemKey(item_key))
+    return NULL;
+
+  int index;
+  if (!base::StringToInt(item_key, &index) || index < 0 ||
+      static_cast<size_t>(index) >= wallet_items_->addresses().size()) {
+    NOTREACHED();
+    return NULL;
+  }
+
+  return wallet_items_->addresses()[index];
+}
+
 scoped_ptr<DataModelWrapper> AutofillDialogControllerImpl::CreateWrapper(
     DialogSection section) {
   if (IsPayingWithWallet() && full_wallet_ &&
       full_wallet_->required_actions().empty()) {
     if (section == SECTION_CC_BILLING) {
       return scoped_ptr<DataModelWrapper>(
           new FullWalletBillingWrapper(full_wallet_.get()));
     }
     if (section == SECTION_SHIPPING) {
       return scoped_ptr<DataModelWrapper>(
           new FullWalletShippingWrapper(full_wallet_.get()));
     }
   }
 
   SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
   std::string item_key = model->GetItemKeyForCheckedItem();
   if (!IsASuggestionItemKey(item_key) || IsManuallyEditingSection(section))
     return scoped_ptr<DataModelWrapper>();
 
   if (IsPayingWithWallet()) {
-    int index;
-    bool success = base::StringToInt(item_key, &index);
-    DCHECK(success);
-
     if (section == SECTION_CC_BILLING) {
       return scoped_ptr<DataModelWrapper>(
-          new WalletInstrumentWrapper(wallet_items_->instruments()[index]));
+          new WalletInstrumentWrapper(ActiveInstrument()));
     }
 
     if (section == SECTION_SHIPPING) {
       return scoped_ptr<DataModelWrapper>(
-          new WalletAddressWrapper(wallet_items_->addresses()[index]));
+          new WalletAddressWrapper(ActiveShippingAddress()));
     }
 
     return scoped_ptr<DataModelWrapper>();
   }
 
   if (section == SECTION_CC) {
     CreditCard* card = GetManager()->GetCreditCardByGUID(item_key);
     DCHECK(card);
     return scoped_ptr<DataModelWrapper>(new AutofillCreditCardWrapper(card));
   }
@@ skipping 181 matching lines @@
     const AutofillFieldType type = iter->first->type;
     string16 message = InputValidityMessage(type, iter->second);
     if (!message.empty())
       invalid_messages[type] = message;
     else
       field_values[type] = iter->second;
   }
 
   // Validate the date formed by month and year field. (Autofill dialog is
   // never supposed to have 2-digit years, so not checked).
-  if (field_values.count(CREDIT_CARD_EXP_MONTH) &&
-      field_values.count(CREDIT_CARD_EXP_4_DIGIT_YEAR)) {
-    if (!autofill::IsValidCreditCardExpirationDate(
-            field_values[CREDIT_CARD_EXP_4_DIGIT_YEAR],
-            field_values[CREDIT_CARD_EXP_MONTH],
-            base::Time::Now())) {
-      invalid_messages[CREDIT_CARD_EXP_MONTH] =
-          ASCIIToUTF16("more complicated message");
-      invalid_messages[CREDIT_CARD_EXP_4_DIGIT_YEAR] =
-          ASCIIToUTF16("more complicated message");
-    }
+  if (field_values.count(CREDIT_CARD_EXP_4_DIGIT_YEAR) &&
+      field_values.count(CREDIT_CARD_EXP_MONTH) &&
+      !IsCreditCardExpirationValid(field_values[CREDIT_CARD_EXP_4_DIGIT_YEAR],
+                                   field_values[CREDIT_CARD_EXP_MONTH])) {
+    invalid_messages[CREDIT_CARD_EXP_4_DIGIT_YEAR] =
+        ASCIIToUTF16("more complicated message");
+    invalid_messages[CREDIT_CARD_EXP_MONTH] =
+        ASCIIToUTF16("more complicated message");
   }
 
   // If there is a credit card number and a CVC, validate them together.
   if (field_values.count(CREDIT_CARD_NUMBER) &&
       field_values.count(CREDIT_CARD_VERIFICATION_CODE) &&
       InputValidityMessage(CREDIT_CARD_NUMBER,
-                           field_values[CREDIT_CARD_NUMBER]).empty()) {
-    if (!autofill::IsValidCreditCardSecurityCode(
-            field_values[CREDIT_CARD_VERIFICATION_CODE],
-            field_values[CREDIT_CARD_NUMBER])) {
-      invalid_messages[CREDIT_CARD_VERIFICATION_CODE] =
-          ASCIIToUTF16("CVC doesn't match card type!");
-    }
+                           field_values[CREDIT_CARD_NUMBER]).empty() &&
+      !autofill::IsValidCreditCardSecurityCode(
+          field_values[CREDIT_CARD_VERIFICATION_CODE],
+          field_values[CREDIT_CARD_NUMBER])) {
+    invalid_messages[CREDIT_CARD_VERIFICATION_CODE] =
+        ASCIIToUTF16("CVC doesn't match card type!");
   }
 
   // Validate the phone number against the country code of the address.
   if (field_values.count(ADDRESS_HOME_COUNTRY) &&
       field_values.count(PHONE_HOME_WHOLE_NUMBER)) {
     i18n::PhoneObject phone_object(
         field_values[PHONE_HOME_WHOLE_NUMBER],
         AutofillCountry::GetCountryCode(
             field_values[ADDRESS_HOME_COUNTRY],
             g_browser_process->GetApplicationLocale()));
@@ skipping 1117 matching lines @@
 }
 
 bool AutofillDialogControllerImpl::IsManuallyEditingSection(
     DialogSection section) const {
   return IsEditingExistingData(section) ||
          SuggestionsMenuModelForSection(section)->
              GetItemKeyForCheckedItem() == kAddNewItemKey;
 }
 
 bool AutofillDialogControllerImpl::IsASuggestionItemKey(
-    const std::string& key) {
+    const std::string& key) const {
   return !key.empty() &&
       key != kAddNewItemKey &&
       key != kManageItemsKey &&
       key != kSameAsBillingKey;
 }
 
 bool AutofillDialogControllerImpl::IsManuallyEditingAnySection() const {
   for (size_t section = SECTION_MIN; section <= SECTION_MAX; ++section) {
     if (IsManuallyEditingSection(static_cast<DialogSection>(section)))
       return true;
@@ skipping 24 matching lines @@
 bool AutofillDialogControllerImpl::SectionIsValid(
     DialogSection section) const {
   if (!IsManuallyEditingSection(section))
     return true;
 
   DetailOutputMap detail_outputs;
   view_->GetUserInput(section, &detail_outputs);
   return InputsAreValid(detail_outputs, VALIDATE_EDIT).empty();
 }
 
+bool AutofillDialogControllerImpl::IsCreditCardExpirationValid(
+    const base::string16& year,
+    const base::string16& month) const {
+  // If the expiration is in the past as per the local clock, it's invalid.
+  base::Time now = base::Time::Now();
+  if (!autofill::IsValidCreditCardExpirationDate(year, month, now))
+    return false;
+
+  if (IsPayingWithWallet() && IsEditingExistingData(SECTION_CC_BILLING)) {
+    const wallet::WalletItems::MaskedInstrument* instrument =
+        ActiveInstrument();
+    const std::string& locale = g_browser_process->GetApplicationLocale();
+    int month_int;
+    if (base::StringToInt(month, &month_int) &&
+        instrument->status() ==
+            wallet::WalletItems::MaskedInstrument::EXPIRED &&
+        year == instrument->GetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, locale) &&
+        month_int == instrument->expiration_month()) {
+      // Otherwise, if the user is editing an instrument that's deemed expired
+      // by the Online Wallet server, mark it invalid on selection.
+      return false;
+    }
+  }
+
+  return true;
+}
+
 bool AutofillDialogControllerImpl::ShouldUseBillingForShipping() {
   return SectionIsActive(SECTION_SHIPPING) &&
       suggested_shipping_.GetItemKeyForCheckedItem() == kSameAsBillingKey;
 }
 
 bool AutofillDialogControllerImpl::ShouldSaveDetailsLocally() {
   // It's possible that the user checked [X] Save details locally before
   // switching payment methods, so only ask the view whether to save details
   // locally if that checkbox is showing (currently if not paying with wallet).
   // Also, if the user isn't editing any sections, there's no data to save
@@ skipping 31 matching lines @@
      base::Bind(&UserDidOptIntoLocationServices));
 
   GetWalletClient()->AcceptLegalDocuments(
       wallet_items_->legal_documents(),
       wallet_items_->google_transaction_id(),
       source_url_);
 
   if (AreLegalDocumentsCurrent())
     LoadRiskFingerprintData();
 
-  SuggestionsMenuModel* billing =
-      SuggestionsMenuModelForSection(SECTION_CC_BILLING);
-  int instrument_index = -1;
-  base::StringToInt(billing->GetItemKeyForCheckedItem(), &instrument_index);
-
+  const wallet::WalletItems::MaskedInstrument* active_instrument =
+      ActiveInstrument();
   if (!IsManuallyEditingSection(SECTION_CC_BILLING)) {
-    active_instrument_id_ =
-        wallet_items_->instruments()[instrument_index]->object_id();
+    active_instrument_id_ = active_instrument->object_id();
     DCHECK(!active_instrument_id_.empty());
   }
 
-  SuggestionsMenuModel* shipping =
-      SuggestionsMenuModelForSection(SECTION_SHIPPING);
-  int address_index = -1;
-  base::StringToInt(shipping->GetItemKeyForCheckedItem(), &address_index);
-
+  const wallet::Address* active_address = ActiveShippingAddress();
   if (!IsManuallyEditingSection(SECTION_SHIPPING) &&
       !ShouldUseBillingForShipping()) {
-    active_address_id_ =
-        wallet_items_->addresses()[address_index]->object_id();
+    active_address_id_ = active_address->object_id();
     DCHECK(!active_address_id_.empty());
   }
 
   scoped_ptr<wallet::Instrument> inputted_instrument =
       CreateTransientInstrument();
   scoped_ptr<wallet::WalletClient::UpdateInstrumentRequest> update_request =
       CreateUpdateInstrumentRequest(
           inputted_instrument.get(),
           !IsEditingExistingData(SECTION_CC_BILLING) ? std::string() :
-              wallet_items_->instruments()[instrument_index]->object_id());
+              active_instrument->object_id());
 
   scoped_ptr<wallet::Address> inputted_address;
   if (active_address_id_.empty()) {
     if (ShouldUseBillingForShipping()) {
       const wallet::Address& address = inputted_instrument ?
-          inputted_instrument->address() :
-          wallet_items_->instruments()[instrument_index]->address();
+          inputted_instrument->address() : active_instrument->address();
       // Try to find an exact matched shipping address and use it for shipping,
       // otherwise save it as a new shipping address. http://crbug.com/225442
       const wallet::Address* duplicated_address =
           FindDuplicateAddress(wallet_items_->addresses(), address);
       if (duplicated_address) {
         active_address_id_ = duplicated_address->object_id();
         DCHECK(!active_address_id_.empty());
       } else {
         inputted_address.reset(new wallet::Address(address));
         DCHECK(inputted_address->object_id().empty());
       }
     } else {
       inputted_address = CreateTransientAddress();
       if (IsEditingExistingData(SECTION_SHIPPING)) {
-        inputted_address->set_object_id(
-            wallet_items_->addresses()[address_index]->object_id());
+        inputted_address->set_object_id(active_address->object_id());
         DCHECK(!inputted_address->object_id().empty());
       }
     }
   }
 
   // If there's neither an address nor instrument to save, |GetFullWallet()|
   // is called when the risk fingerprint is loaded.
   if (!active_instrument_id_.empty() && !active_address_id_.empty())
     return;
 
@@ skipping 354 matching lines @@
         AutofillMetrics::DIALOG_USER_SIGNED_IN_NO_WALLET_NO_AUTOFILL;
   }
 
   // Has Wallet items.
   return has_autofill_profiles ?
       AutofillMetrics::DIALOG_USER_SIGNED_IN_HAS_WALLET_HAS_AUTOFILL :
       AutofillMetrics::DIALOG_USER_SIGNED_IN_HAS_WALLET_NO_AUTOFILL;
 }
 
 }  // namespace autofill