[Payments] Have expiration date be on the same line in CC editor

chrome/browser/ui/views/payments/credit_card_editor_view_controller.cc

 // Copyright 2017 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/views/payments/credit_card_editor_view_controller.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/ui/views/payments/payment_request_dialog_view.h"
 #include "chrome/browser/ui/views/payments/payment_request_dialog_view_ids.h"
 #include "chrome/browser/ui/views/payments/payment_request_views_util.h"
 #include "chrome/browser/ui/views/payments/preselected_combobox_model.h"
 #include "chrome/browser/ui/views/payments/validating_combobox.h"
@@ skipping 57 matching lines @@
   years.reserve(kNumberOfExpirationYears);
 
   base::Time::Exploded now_exploded;
   autofill::AutofillClock::Now().LocalExplode(&now_exploded);
   for (int i = 0; i < kNumberOfExpirationYears; i++) {
     years.push_back(base::UTF8ToUTF16(std::to_string(now_exploded.year + i)));
   }
   return years;
 }
 
+bool IsCardExpired(const base::string16& month,
+                   base::string16& year,
+                   const std::string& app_locale) {
+  autofill::CreditCard card;
+  card.SetExpirationMonthFromString(month, app_locale);
+  card.SetExpirationYearFromString(year);
+  return card.IsExpired(autofill::AutofillClock::Now());
+}
+
+// Validates the two comboboxes used for expiration date.
+class ExpirationDateValidationDelegate : public ValidationDelegate {
+ public:
+  ExpirationDateValidationDelegate(EditorViewController* controller,
+                                   const std::string& app_locale)
+      : controller_(controller), app_locale_(app_locale) {}
+
+  bool IsValidTextfield(views::Textfield* textfield) override {
+    NOTREACHED();
+    return true;
+  }
+
+  bool IsValidCombobox(views::Combobox* combobox) override {
+    // Get the combined date from the month and year dropdowns.
+    views::View* view_parent = combobox->parent();
+
+    views::Combobox* month_combobox = static_cast<views::Combobox*>(
+        view_parent->GetViewByID(EditorViewController::GetInputFieldViewId(
+            autofill::CREDIT_CARD_EXP_MONTH)));
+    base::string16 month =
+        month_combobox->model()->GetItemAt(month_combobox->selected_index());
+
+    views::Combobox* year_combobox = static_cast<views::Combobox*>(
+        view_parent->GetViewByID(EditorViewController::GetInputFieldViewId(
+            autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR)));
+    base::string16 year =
+        year_combobox->model()->GetItemAt(year_combobox->selected_index());
+
+    bool is_expired = IsCardExpired(month, year, app_locale_);
+    month_combobox->SetInvalid(is_expired);
+    year_combobox->SetInvalid(is_expired);
+
+    return !is_expired;
+  }
+
+  bool TextfieldValueChanged(views::Textfield* textfield) override {
+    NOTREACHED();
+    return true;
+  }
+
+  bool ComboboxValueChanged(views::Combobox* combobox) override {
+    bool is_valid = IsValidCombobox(combobox);
+    controller_->DisplayErrorMessageForField(
+        autofill::CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR,
+        is_valid ? base::string16()
+                 : l10n_util::GetStringUTF16(
+                       IDS_PAYMENTS_VALIDATION_INVALID_CREDIT_CARD_EXPIRED));
+    return is_valid;
+  }
+
+  void ComboboxModelChanged(views::Combobox* combobox) override {}
+
+ private:
+  EditorViewController* controller_;
+  const std::string app_locale_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExpirationDateValidationDelegate);
+};
+
 }  // namespace
 
 CreditCardEditorViewController::CreditCardEditorViewController(
     PaymentRequestSpec* spec,
     PaymentRequestState* state,
     PaymentRequestDialogView* dialog,
     BackNavigationType back_navigation,
     int next_ui_tag,
     base::OnceClosure on_edited,
     base::OnceCallback<void(const autofill::CreditCard&)> on_added,
@@ skipping 58 matching lines @@
     card_icon_view->SetImageSize(kCardIconSize);
 
     icons_row->AddChildView(card_icon_view.release());
   }
   view->AddChildView(icons_row.release());
 
   return view;
 }
 
 std::unique_ptr<views::View>
+CreditCardEditorViewController::CreateCustomFieldView(
+    autofill::ServerFieldType type,
+    views::View** focusable_field,
+    bool* valid) {
+  DCHECK_EQ(type, autofill::CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR);
+
+  std::unique_ptr<views::View> view = base::MakeUnique<views::View>();
+  std::unique_ptr<views::GridLayout> combobox_layout =
+      base::MakeUnique<views::GridLayout>(view.get());
+  views::ColumnSet* columns = combobox_layout->AddColumnSet(0);
+  columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 1,
+                     views::GridLayout::USE_PREF, 0, 0);
+  // Space between the two comboboxes.
+  constexpr int kHorizontalSpacing = 8;
+  columns->AddPaddingColumn(0, kHorizontalSpacing);
+  columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 1,
+                     views::GridLayout::USE_PREF, 0, 0);
+
+  combobox_layout->StartRow(0, 0);
+  constexpr int kInputFieldHeight = 28;
+  EditorField tmp_month{autofill::CREDIT_CARD_EXP_MONTH, base::string16(),
+                        EditorField::LengthHint::HINT_SHORT,
+                        /*required=*/true, EditorField::ControlType::COMBOBOX};
+  std::unique_ptr<ValidatingCombobox> month_combobox =
+      CreateComboboxForField(tmp_month);
+  *focusable_field = month_combobox.get();
+  combobox_layout->AddView(month_combobox.release(), 1, 1,
+                           views::GridLayout::FILL, views::GridLayout::FILL, 0,
+                           kInputFieldHeight);
+
+  EditorField tmp_year{autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR, base::string16(),
+                       EditorField::LengthHint::HINT_SHORT,
+                       /*required=*/true, EditorField::ControlType::COMBOBOX};
+  std::unique_ptr<ValidatingCombobox> year_combobox =
+      CreateComboboxForField(tmp_year);
+  combobox_layout->AddView(year_combobox.release(), 1, 1,
+                           views::GridLayout::FILL, views::GridLayout::FILL, 0,
+                           kInputFieldHeight);
+
+  view->SetLayoutManager(combobox_layout.release());
+
+  // Set the initial validity of the custom view.
+  base::string16 month =
+      GetInitialValueForType(autofill::CREDIT_CARD_EXP_MONTH);
+  base::string16 year =
+      GetInitialValueForType(autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR);
+  *valid = IsCardExpired(month, year, state()->GetApplicationLocale());
+  return view;
+}
+
+std::unique_ptr<views::View>
 CreditCardEditorViewController::CreateExtraViewForField(
     autofill::ServerFieldType type) {
   if (type != kBillingAddressType)
     return nullptr;
 
   std::unique_ptr<views::View> button_view = base::MakeUnique<views::View>();
   button_view->SetLayoutManager(new views::FillLayout);
 
   // The button to add new billing addresses.
   std::unique_ptr<views::Button> add_button(
       views::MdTextButton::Create(this, l10n_util::GetStringUTF16(IDS_ADD)));
   add_button->set_id(
       static_cast<int>(DialogViewID::ADD_BILLING_ADDRESS_BUTTON));
   add_button->set_tag(add_billing_address_button_tag_);
   button_view->AddChildView(add_button.release());
   return button_view;
 }
 
 std::vector<EditorField> CreditCardEditorViewController::GetFieldDefinitions() {
   return std::vector<EditorField>{
       {autofill::CREDIT_CARD_NUMBER,
        l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_CREDIT_CARD_NUMBER),
-       EditorField::LengthHint::HINT_SHORT, /* required= */ true,
+       EditorField::LengthHint::HINT_SHORT, /*required=*/true,
        EditorField::ControlType::TEXTFIELD_NUMBER},
       {autofill::CREDIT_CARD_NAME_FULL,
        l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_NAME_ON_CARD),
-       EditorField::LengthHint::HINT_SHORT, /* required= */ true},
-      {autofill::CREDIT_CARD_EXP_MONTH,
-       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_EXPIRATION_MONTH),
-       EditorField::LengthHint::HINT_SHORT, /* required= */ true,
-       EditorField::ControlType::COMBOBOX},
-      {autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR,
-       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_EXPIRATION_YEAR),
-       EditorField::LengthHint::HINT_SHORT, /* required= */ true,
-       EditorField::ControlType::COMBOBOX},
+       EditorField::LengthHint::HINT_SHORT, /*required=*/true},
+      {autofill::CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR,
+       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_EXPIRATION_DATE),
+       EditorField::LengthHint::HINT_SHORT, /*required=*/true,
+       EditorField::ControlType::CUSTOMFIELD},
       {kBillingAddressType,
        l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_BILLING_ADDRESS),
-       EditorField::LengthHint::HINT_SHORT, /* required= */ true,
+       EditorField::LengthHint::HINT_SHORT, /*required=*/true,
        EditorField::ControlType::COMBOBOX}};
 }
 
 base::string16 CreditCardEditorViewController::GetInitialValueForType(
     autofill::ServerFieldType type) {
   if (!credit_card_to_edit_ || type == kBillingAddressType)
     return base::string16();
 
   return credit_card_to_edit_->GetInfo(autofill::AutofillType(type),
                                        state()->GetApplicationLocale());
@@ skipping 16 matching lines @@
                         field.first->text(), locale);
   }
   for (const auto& field : comboboxes()) {
     // ValidatingCombobox* is the key, EditorField is the value.
     ValidatingCombobox* combobox = field.first;
     if (combobox->invalid())
       return false;
 
     if (field.second.type == kBillingAddressType) {
       views::Combobox* address_combobox = static_cast<views::Combobox*>(
-          dialog()->GetViewByID(kBillingAddressType));
+          dialog()->GetViewByID(GetInputFieldViewId(kBillingAddressType)));
       autofill::AddressComboboxModel* model =
           static_cast<autofill::AddressComboboxModel*>(
               address_combobox->model());
 
       credit_card.set_billing_address_id(
           model->GetItemIdentifierAt(address_combobox->selected_index()));
     } else {
       credit_card.SetInfo(autofill::AutofillType(field.second.type),
                           combobox->GetTextForRow(combobox->selected_index()),
                           locale);
@@ skipping 40 matching lines @@
   }
 
   return true;
 }
 
 std::unique_ptr<ValidationDelegate>
 CreditCardEditorViewController::CreateValidationDelegate(
     const EditorField& field) {
   // The supported card networks for non-cc-number types are not passed to avoid
   // the data copy in the delegate.
+  if (field.type == autofill::CREDIT_CARD_EXP_MONTH ||
+      field.type == autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR)
+    return base::MakeUnique<ExpirationDateValidationDelegate>(
+        this, state()->GetApplicationLocale());
   return base::MakeUnique<
       CreditCardEditorViewController::CreditCardValidationDelegate>(
       field, this,
       field.type == autofill::CREDIT_CARD_NUMBER
           ? spec()->supported_card_networks()
           : std::vector<std::string>());
 }
 
 std::unique_ptr<ui::ComboboxModel>
 CreditCardEditorViewController::GetComboboxModelForType(
@@ skipping 22 matching lines @@
   }
   return std::unique_ptr<ui::ComboboxModel>();
 }
 
 void CreditCardEditorViewController::FillContentView(
     views::View* content_view) {
   EditorViewController::FillContentView(content_view);
   // We need to search from the content view here, since the dialog may not have
   // the content view added to it yet.
   views::Combobox* combobox = static_cast<views::Combobox*>(
-      content_view->GetViewByID(kBillingAddressType));
+      content_view->GetViewByID(GetInputFieldViewId(kBillingAddressType)));
   // When the combobox has a single item, it's because it has no addresses
   // (otherwise, it would have the select header, and a separator before the
   // first address to choose from).
   DCHECK(combobox);
   combobox->SetEnabled(combobox->GetRowCount() > 1);
 }
 
 base::string16 CreditCardEditorViewController::GetSheetTitle() {
   if (!credit_card_to_edit_)
     return l10n_util::GetStringUTF16(IDS_PAYMENTS_ADD_CARD);
@@ skipping 19 matching lines @@
             &CreditCardEditorViewController::AddAndSelectNewBillingAddress,
             base::Unretained(this)),
         /*profile=*/nullptr);
   } else {
     EditorViewController::ButtonPressed(sender, event);
   }
 }
 
 void CreditCardEditorViewController::AddAndSelectNewBillingAddress(
     const autofill::AutofillProfile& profile) {
-  views::Combobox* address_combobox =
-      static_cast<views::Combobox*>(dialog()->GetViewByID(kBillingAddressType));
+  views::Combobox* address_combobox = static_cast<views::Combobox*>(
+      dialog()->GetViewByID(GetInputFieldViewId(kBillingAddressType)));
   autofill::AddressComboboxModel* model =
       static_cast<autofill::AddressComboboxModel*>(address_combobox->model());
   int index = model->AddNewProfile(profile);
   // SetSelectedIndex doesn't trigger a perform action notification, which is
   // needed to update the valid state.
   address_combobox->SetSelectedRow(index);
   // But it needs to be blured at least once.
   address_combobox->OnBlur();
 }
 
@@ skipping 16 matching lines @@
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     IsValidCombobox(views::Combobox* combobox) {
   return ValidateCombobox(combobox, nullptr);
 }
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     TextfieldValueChanged(views::Textfield* textfield) {
   base::string16 error_message;
   bool is_valid = ValidateValue(textfield->text(), &error_message);
-  controller_->DisplayErrorMessageForField(field_, error_message);
+  controller_->DisplayErrorMessageForField(field_.type, error_message);
   return is_valid;
 }
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     ComboboxValueChanged(views::Combobox* combobox) {
   base::string16 error_message;
   bool is_valid = ValidateCombobox(combobox, nullptr);
-  controller_->DisplayErrorMessageForField(field_, error_message);
+  controller_->DisplayErrorMessageForField(field_.type, error_message);
   return is_valid;
 }
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     ValidateValue(const base::string16& value, base::string16* error_message) {
   if (!value.empty()) {
     base::string16 local_error_message;
     bool is_valid =
         field_.type == autofill::CREDIT_CARD_NUMBER
             ? autofill::IsValidCreditCardNumberForBasicCardNetworks(
@@ skipping 33 matching lines @@
   return ValidateValue(combobox->GetTextForRow(combobox->selected_index()),
                        error_message);
 }
 
 bool CreditCardEditorViewController::GetSheetId(DialogViewID* sheet_id) {
   *sheet_id = DialogViewID::CREDIT_CARD_EDITOR_SHEET;
   return true;
 }
 
 }  // namespace payments