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

chrome/browser/ui/views/payments/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/editor_view_controller.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <utility>
@@ skipping 27 matching lines @@
 
 constexpr int kFirstTagValue = static_cast<int>(
     payments::PaymentRequestCommonTags::PAYMENT_REQUEST_COMMON_TAG_MAX);
 
 enum class EditorViewControllerTags : int {
   // The tag for the button that saves the model being edited. Starts at
   // |kFirstTagValue| not to conflict with tags common to all views.
   SAVE_BUTTON = kFirstTagValue,
 };
 
-std::unique_ptr<views::View> CreateErrorLabelView(const base::string16& error,
-                                                  const EditorField& field) {
+std::unique_ptr<views::View> CreateErrorLabelView(
+    const base::string16& error,
+    autofill::ServerFieldType type) {
   std::unique_ptr<views::View> view = base::MakeUnique<views::View>();
 
   std::unique_ptr<views::BoxLayout> layout =
       base::MakeUnique<views::BoxLayout>(views::BoxLayout::kVertical, 0, 0, 0);
   layout->set_main_axis_alignment(views::BoxLayout::MAIN_AXIS_ALIGNMENT_START);
   layout->set_cross_axis_alignment(
       views::BoxLayout::CROSS_AXIS_ALIGNMENT_STRETCH);
   // This is the space between the input field and the error label.
   constexpr int kErrorLabelTopPadding = 6;
   layout->set_inside_border_insets(gfx::Insets(kErrorLabelTopPadding, 0, 0, 0));
   view->SetLayoutManager(layout.release());
 
   std::unique_ptr<views::Label> error_label =
       base::MakeUnique<views::Label>(error);
   error_label->set_id(static_cast<int>(DialogViewID::ERROR_LABEL_OFFSET) +
-                      field.type);
+                      type);
   error_label->SetFontList(
       error_label->GetDefaultFontList().DeriveWithSizeDelta(-1));
   error_label->SetEnabledColor(error_label->GetNativeTheme()->GetSystemColor(
       ui::NativeTheme::kColorId_AlertSeverityHigh));
 
   view->AddChildView(error_label.release());
   return view;
 }
 
 }  // namespace
 
 EditorViewController::EditorViewController(
     PaymentRequestSpec* spec,
     PaymentRequestState* state,
     PaymentRequestDialogView* dialog,
     BackNavigationType back_navigation_type)
     : PaymentRequestSheetController(spec, state, dialog),
       initial_focus_field_view_(nullptr),
       back_navigation_type_(back_navigation_type) {}
 
 EditorViewController::~EditorViewController() {}
 
 void EditorViewController::DisplayErrorMessageForField(
-    const EditorField& field,
+    autofill::ServerFieldType type,
     const base::string16& error_message) {
-  const auto& label_view_it = error_labels_.find(field);
+  const auto& label_view_it = error_labels_.find(type);
   DCHECK(label_view_it != error_labels_.end());
 
   label_view_it->second->RemoveAllChildViews(/*delete_children=*/true);
   if (!error_message.empty()) {
     label_view_it->second->AddChildView(
-        CreateErrorLabelView(error_message, field).release());
+        CreateErrorLabelView(error_message, type).release());
   }
   RelayoutPane();
 }
 
+// static
+int EditorViewController::GetInputFieldViewId(autofill::ServerFieldType type) {
+  return static_cast<int>(DialogViewID::INPUT_FIELD_TYPE_OFFSET) +
+         static_cast<int>(type);
+}
+
 std::unique_ptr<views::View> EditorViewController::CreateHeaderView() {
   return nullptr;
 }
 
 std::unique_ptr<views::View> EditorViewController::CreateCustomFieldView(
     autofill::ServerFieldType type,
-    views::View** focusable_field) {
+    views::View** focusable_field,
+    bool* valid) {
   return nullptr;
 }
 
 std::unique_ptr<views::View> EditorViewController::CreateExtraViewForField(
     autofill::ServerFieldType type) {
   return nullptr;
 }
 
 std::unique_ptr<views::Button> EditorViewController::CreatePrimaryButton() {
   std::unique_ptr<views::Button> button(
@@ skipping 48 matching lines @@
       break;
   }
 }
 
 views::View* EditorViewController::GetFirstFocusedView() {
   if (initial_focus_field_view_)
     return initial_focus_field_view_;
   return PaymentRequestSheetController::GetFirstFocusedView();
 }
 
+std::unique_ptr<ValidatingCombobox>
+EditorViewController::CreateComboboxForField(const EditorField& field) {
+  std::unique_ptr<ValidatingCombobox> combobox =
+      base::MakeUnique<ValidatingCombobox>(GetComboboxModelForType(field.type),
+                                           CreateValidationDelegate(field));
+  base::string16 initial_value = GetInitialValueForType(field.type);
+  if (!initial_value.empty())
+    combobox->SelectValue(initial_value);
+  // Using autofill field type as a view ID.
+  combobox->set_id(GetInputFieldViewId(field.type));
+  combobox->set_listener(this);
+  comboboxes_.insert(std::make_pair(combobox.get(), field));
+  return combobox;
+}
+
 void EditorViewController::ContentsChanged(views::Textfield* sender,
                                            const base::string16& new_contents) {
   static_cast<ValidatingTextfield*>(sender)->OnContentsChanged();
 }
 
 void EditorViewController::OnPerformAction(views::Combobox* sender) {
   static_cast<ValidatingCombobox*>(sender)->OnContentsChanged();
 }
 
 std::unique_ptr<views::View> EditorViewController::CreateEditorView() {
@@ skipping 123 matching lines @@
   constexpr int kInputRowSpacing = 6;
   layout->StartRowWithPadding(0, column_set, 0, kInputRowSpacing);
 
   std::unique_ptr<views::Label> label = base::MakeUnique<views::Label>(
       field.required ? field.label + base::ASCIIToUTF16("*") : field.label);
 
   label->SetMultiLine(true);
   layout->AddView(label.release());
 
   views::View* focusable_field = nullptr;
-
   constexpr int kInputFieldHeight = 28;
   if (field.control_type == EditorField::ControlType::TEXTFIELD ||
       field.control_type == EditorField::ControlType::TEXTFIELD_NUMBER) {
     ValidatingTextfield* text_field =
         new ValidatingTextfield(CreateValidationDelegate(field));
     text_field->SetText(GetInitialValueForType(field.type));
     if (field.control_type == EditorField::ControlType::TEXTFIELD_NUMBER)
       text_field->SetTextInputType(ui::TextInputType::TEXT_INPUT_TYPE_NUMBER);
     text_field->set_controller(this);
     // Using autofill field type as a view ID (for testing).
-    text_field->set_id(static_cast<int>(field.type));
+    text_field->set_id(GetInputFieldViewId(field.type));
     text_fields_.insert(std::make_pair(text_field, field));
     focusable_field = text_field;
     *valid = text_field->IsValid();
 
     // |text_field| will now be owned by |row|.
     layout->AddView(text_field, 1, 1, views::GridLayout::FILL,
                     views::GridLayout::FILL, 0, kInputFieldHeight);
   } else if (field.control_type == EditorField::ControlType::COMBOBOX) {
-    ValidatingCombobox* combobox = new ValidatingCombobox(
-        GetComboboxModelForType(field.type), CreateValidationDelegate(field));
-    base::string16 initial_value = GetInitialValueForType(field.type);
-    if (!initial_value.empty())
-      combobox->SelectValue(initial_value);
-    // Using autofill field type as a view ID.
-    combobox->set_id(static_cast<int>(field.type));
-    combobox->set_listener(this);
-    comboboxes_.insert(std::make_pair(combobox, field));
-    focusable_field = combobox;
+    std::unique_ptr<ValidatingCombobox> combobox =
+        CreateComboboxForField(field);
+
+    focusable_field = combobox.get();
     *valid = combobox->IsValid();
 
     // |combobox| will now be owned by |row|.
-    layout->AddView(combobox, 1, 1, views::GridLayout::FILL,
+    layout->AddView(combobox.release(), 1, 1, views::GridLayout::FILL,
                     views::GridLayout::FILL, 0, kInputFieldHeight);
   } else {
     // Custom field view will now be owned by |row|. And it must be valid since
     // the derived class specified a custom view for this field.
-    DCHECK(!focusable_field);
     std::unique_ptr<views::View> field_view =
-        CreateCustomFieldView(field.type, &focusable_field);
+        CreateCustomFieldView(field.type, &focusable_field, valid);
     DCHECK(field_view);
-    layout->AddView(field_view.release());
+
+    layout->AddView(field_view.release(), 1, 1, views::GridLayout::FILL,
+                    views::GridLayout::FILL, 0, kInputFieldHeight);
   }
 
   // If an extra view needs to go alongside the input field view, add it to the
   // last column.
   std::unique_ptr<views::View> extra_view = CreateExtraViewForField(field.type);
   if (extra_view)
     layout->AddView(extra_view.release());
 
   layout->StartRow(0, column_set);
   layout->SkipColumns(1);
   std::unique_ptr<views::View> error_label_view =
       base::MakeUnique<views::View>();
   error_label_view->SetLayoutManager(new views::FillLayout);
-  error_labels_[field] = error_label_view.get();
+  error_labels_[field.type] = error_label_view.get();
   layout->AddView(error_label_view.release());
 
   // Bottom padding for the row.
   layout->AddPaddingRow(0, kInputRowSpacing);
   return focusable_field;
 }
 
 int EditorViewController::ComputeWidestExtraViewWidth(
     EditorField::LengthHint size) {
   int widest_column_width = 0;
 
   for (const auto& field : GetFieldDefinitions()) {
     if (field.length_hint != size)
       continue;
 
     std::unique_ptr<views::View> extra_view =
         CreateExtraViewForField(field.type);
     if (!extra_view)
       continue;
     widest_column_width =
         std::max(extra_view->GetPreferredSize().width(), widest_column_width);
   }
   return widest_column_width;
 }
 
 }  // namespace payments