[Payments] Changes to validation in the Credit Card 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>
@@ skipping 36 matching lines @@
 #include "ui/views/view.h"
 
 namespace payments {
 
 namespace {
 
 // Number of years (including the current one) to be shown in the expiration
 // year dropdown.
 const int kNumberOfExpirationYears = 10;
 
+// Opacity of card network icons when they are not selected and are displayed
+// alongside a selected icon.
+const float kDimmedCardIconOpacity = 0.33f;

[anthonyvd, 2017/05/23 15:59:42]

Didn't Bruno specify 50%?

+
 // This is not quite right but is the closest server type that wasn't already
 // used.
 const auto kBillingAddressType = autofill::ADDRESS_BILLING_LINE1;
 
 // Returns the items that are in the expiration month dropdown. Will return the
 // months in order starting at "01" until "12". Uses a clock so that the
 // |default_index| is set to the current month.
 std::vector<base::string16> GetExpirationMonthItems(int* default_index) {
   std::vector<base::string16> months;
   months.reserve(12);
@@ skipping 27 matching lines @@
   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) {}
+                                   const std::string& app_locale,
+                                   bool initially_valid)
+      : controller_(controller),
+        app_locale_(app_locale),
+        initially_valid_(initially_valid) {}
 
   bool IsValidTextfield(views::Textfield* textfield) override {
     NOTREACHED();
     return true;
   }
 
   bool IsValidCombobox(views::Combobox* combobox) override {
+    // View will have no parent if it's not been attached yet. Use initial
+    // validity state.
+    views::View* view_parent = combobox->parent();
+    if (!view_parent)
+      return initially_valid_;
+
     // 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 {
+  bool TextfieldValueChanged(views::Textfield* textfield,
+                             bool was_blurred) 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_;
+  bool initially_valid_;
 
   DISALLOW_COPY_AND_ASSIGN(ExpirationDateValidationDelegate);
 };
 
 }  // namespace
 
 CreditCardEditorViewController::CreditCardEditorViewController(
     PaymentRequestSpec* spec,
     PaymentRequestState* state,
     PaymentRequestDialogView* dialog,
@@ skipping 42 matching lines @@
   label->SetEnabled(false);
   view->AddChildView(label.release());
 
   // 8dp padding is required between icons.
   constexpr int kPaddingBetweenCardIcons = 8;
   std::unique_ptr<views::View> icons_row = base::MakeUnique<views::View>();
   views::BoxLayout* icons_layout = new views::BoxLayout(
       views::BoxLayout::kHorizontal, 0, 0, kPaddingBetweenCardIcons);
   icons_row->SetLayoutManager(icons_layout);
 
+  std::string selected_network =
+      credit_card_to_edit_ ? autofill::data_util::GetPaymentRequestData(
+                                 credit_card_to_edit_->network())
+                                 .basic_card_issuer_network
+                           : "";
   constexpr gfx::Size kCardIconSize = gfx::Size(30, 18);
   for (const std::string& supported_network :
        spec()->supported_card_networks()) {
     const std::string autofill_card_type =
         autofill::data_util::GetIssuerNetworkForBasicCardIssuerNetwork(
             supported_network);
+    // Icon is fully opaque if no network is selected, or if it is the selected
+    // network.
+    float opacity =
+        selected_network.empty() || selected_network == supported_network
+            ? 1.0f
+            : kDimmedCardIconOpacity;
     std::unique_ptr<views::ImageView> card_icon_view = CreateInstrumentIconView(
         autofill::data_util::GetPaymentRequestData(autofill_card_type)
             .icon_resource_id,
-        base::UTF8ToUTF16(supported_network));
+        base::UTF8ToUTF16(supported_network), opacity);
     card_icon_view->SetImageSize(kCardIconSize);
 
+    // Keep track of this card icon to later adjust opacity.
+    card_icons_[supported_network] = card_icon_view.get();
+
     icons_row->AddChildView(card_icon_view.release());
   }
   view->AddChildView(icons_row.release());
 
   return view;
 }
 
 std::unique_ptr<views::View>
 CreditCardEditorViewController::CreateCustomFieldView(
     autofill::ServerFieldType type,
@@ skipping 34 matching lines @@
                            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());
+  *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>();
@@ skipping 113 matching lines @@
     state()->GetPersonalDataManager()->UpdateCreditCard(*credit_card_to_edit_);
     std::move(on_edited_).Run();
   }
 
   return true;
 }
 
 std::unique_ptr<ValidationDelegate>
 CreditCardEditorViewController::CreateValidationDelegate(
     const EditorField& field) {
+  if (field.type == autofill::CREDIT_CARD_EXP_MONTH ||
+      field.type == autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR) {
+    bool initially_valid =
+        credit_card_to_edit_
+            ? !credit_card_to_edit_->IsExpired(autofill::AutofillClock::Now())
+            : true;
+    return base::MakeUnique<ExpirationDateValidationDelegate>(
+        this, state()->GetApplicationLocale(), initially_valid);
+  }
   // 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 16 matching lines @@
           *state()->GetPersonalDataManager(), state()->GetApplicationLocale(),
           credit_card_to_edit_ ? credit_card_to_edit_->billing_address_id()
                                : "");
     default:
       NOTREACHED();
       break;
   }
   return std::unique_ptr<ui::ComboboxModel>();
 }
 
+void CreditCardEditorViewController::SelectBasicCardNetworkIcon(
+    const std::string& basic_card_network) {
+  // If empty string was passed or if the icon representing |basic_card_network|
+  // is not present (i.e. not supported), all icons have full opacity.
+  bool full_opacity =
+      card_icons_.find(basic_card_network) == card_icons_.end() ||
+      basic_card_network.empty();
+  for (auto network_icon_it : card_icons_) {
+    float target_opacity =
+        full_opacity || network_icon_it.first == basic_card_network
+            ? 1.0f
+            : kDimmedCardIconOpacity;
+    network_icon_it.second->layer()->SetOpacity(target_opacity);
+    network_icon_it.second->layer()->ScheduleDraw();
+  }
+}
+
 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(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).
@@ skipping 41 matching lines @@
   // 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();
 }
 
 CreditCardEditorViewController::CreditCardValidationDelegate::
     CreditCardValidationDelegate(
         const EditorField& field,
-        EditorViewController* controller,
+        CreditCardEditorViewController* controller,
         const std::vector<std::string>& supported_card_networks)
     : field_(field),
       controller_(controller),
       supported_card_networks_(supported_card_networks.begin(),
                                supported_card_networks.end()) {}
 CreditCardEditorViewController::CreditCardValidationDelegate::
     ~CreditCardValidationDelegate() {}
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     IsValidTextfield(views::Textfield* textfield) {
   return ValidateValue(textfield->text(), nullptr);
 }
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
     IsValidCombobox(views::Combobox* combobox) {
   return ValidateCombobox(combobox, nullptr);
 }
 
 bool CreditCardEditorViewController::CreditCardValidationDelegate::
-    TextfieldValueChanged(views::Textfield* textfield) {
+    TextfieldValueChanged(views::Textfield* textfield, bool was_blurred) {
+  // The only behavior pre-blur is selecting the card icon.
+  if (field_.type == autofill::CREDIT_CARD_NUMBER) {
+    std::string basic_card_network =
+        autofill::data_util::GetPaymentRequestData(
+            autofill::CreditCard::GetCardNetwork(textfield->text()))
+            .basic_card_issuer_network;
+    controller_->SelectBasicCardNetworkIcon(basic_card_network);
+  }
+
+  // We return true if the field was not yet blurred, because validation should
+  // not occur yet.
+  if (!was_blurred)
+    return true;
+
   base::string16 error_message;
   bool is_valid = ValidateValue(textfield->text(), &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_.type, error_message);
   return is_valid;
 }
@@ skipping 41 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