[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 <map>
 #include <memory>
 #include <utility>
 
@@ skipping 25 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),
       first_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();
 }
 
 std::unique_ptr<views::View> EditorViewController::CreateHeaderView() {
   return nullptr;
 }
 
 std::unique_ptr<views::View> EditorViewController::CreateCustomFieldView(
     autofill::ServerFieldType type) {
@@ skipping 59 matching lines @@
       break;
   }
 }
 
 views::View* EditorViewController::GetFirstFocusedView() {
   if (first_field_view_)
     return first_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(static_cast<int>(field.type));

[anthonyvd, 2017/05/19 19:16:59]

That's probably not a good idea because it'll cause conflicts with other IDs
down the line and so we can't have any guarantee about what GetViewById is going
to return. Those bugs are probably going to be super hard to diagnose when they
break tests.

Maybe we can have an entry in DialogViewID for an offset where we start field
IDs at?

[Mathieu, 2017/05/19 21:13:46]

Done.

+  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 128 matching lines @@
 
     // TODO(crbug.com/718582): Make the initial focus the first incomplete/empty
     // field.
     if (!first_field_view_)
       first_field_view_ = text_field;
 
     // |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));
+    std::unique_ptr<ValidatingCombobox> combobox =
+        CreateComboboxForField(field);
 
     if (!first_field_view_)
-      first_field_view_ = combobox;
+      first_field_view_ = combobox.get();
 
     // |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.
     std::unique_ptr<views::View> field_view = CreateCustomFieldView(field.type);
     DCHECK(field_view);
-    layout->AddView(field_view.release());
+
+    if (!first_field_view_)
+      first_field_view_ = field_view.get();
+
+    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);
 }
 
 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