Add billing address as a mandatory field of Payments credit cards.

chrome/browser/ui/views/payments/shipping_address_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/shipping_address_editor_view_controller.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.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/validating_combobox.h"
 #include "chrome/browser/ui/views/payments/validating_textfield.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/autofill/core/browser/autofill_address_util.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/country_combobox_model.h"
 #include "components/autofill/core/browser/field_types.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/region_combobox_model.h"
@@ skipping 35 matching lines @@
   NOTREACHED();
   return autofill::UNKNOWN_TYPE;
 }
 
 }  // namespace
 
 ShippingAddressEditorViewController::ShippingAddressEditorViewController(
     PaymentRequestSpec* spec,
     PaymentRequestState* state,
     PaymentRequestDialogView* dialog,
+    BackNavigationType back_navigation_type,
     base::OnceClosure on_edited,
     base::OnceCallback<void(const autofill::AutofillProfile&)> on_added,
     autofill::AutofillProfile* profile)
-    : EditorViewController(spec, state, dialog),
+    : EditorViewController(spec, state, dialog, back_navigation_type),
       on_edited_(std::move(on_edited)),
       on_added_(std::move(on_added)),
       profile_to_edit_(profile),
       chosen_country_index_(0),
       failed_to_load_region_data_(false) {
   UpdateEditorFields();
 }
 
 ShippingAddressEditorViewController::~ShippingAddressEditorViewController() {}
 
 std::unique_ptr<views::View>
 ShippingAddressEditorViewController::CreateHeaderView() {
   return base::MakeUnique<views::View>();
 }
 
+std::unique_ptr<views::View>
+ShippingAddressEditorViewController::CreateCustomFieldsView() {

[Mathieu, 2017/05/04 20:29:19]

A pattern that we sometimes use is that you could have the base implementation
of this return nullptr in EditorViewController, and when it's time to use it,
do.

... custom_view = CreateCustomFieldsView();
if (custom_view) {
  view->AddChildView(custom_view);
}

You would then avoid these empty implementations.

[MAD, 2017/05/05 00:50:07]

I was following the pattern used by other similar methods (e.g.,
CreateHeaderView). Should we change those other too?

[Mathieu, 2017/05/05 13:51:33]

I have a slightly preference for what I suggested because otherwise you are
adding empty views to the layout, which is theoretically more work. But I agree
with you it's not done consistently.

Also this way, it makes it so that some subclasses don't have to override
CreateCustomFieldsView if they don't need to.

[MAD, 2017/05/05 18:32:34]

OK, then I'll change all the others too.
Note that for the custom fields, it should only be called when a derived class
has explicitly specified it needed one.

+  return base::MakeUnique<views::View>();
+}
+
 std::vector<EditorField>
 ShippingAddressEditorViewController::GetFieldDefinitions() {
   return editor_fields_;
 }
 
 base::string16 ShippingAddressEditorViewController::GetInitialValueForType(
     autofill::ServerFieldType type) {
   // Temporary profile has precedence over profile to edit since its existence
   // is based on having unsaved stated to restore.
   if (temporary_profile_.get()) {
     return temporary_profile_->GetInfo(autofill::AutofillType(type),
                                        state()->GetApplicationLocale());
   }
 
   if (!profile_to_edit_)
     return base::string16();
 
   return profile_to_edit_->GetInfo(autofill::AutofillType(type),
                                    state()->GetApplicationLocale());
 }
 
 bool ShippingAddressEditorViewController::ValidateModelAndSave() {
   // To validate the profile first, we use a temporary object.
   autofill::AutofillProfile profile;
   if (!SaveFieldsToProfile(&profile, /*ignore_errors=*/false))
     return false;
-
   if (!profile_to_edit_) {
     // Add the profile (will not add a duplicate).
     profile.set_origin(autofill::kSettingsOrigin);
     state()->GetPersonalDataManager()->AddProfile(profile);
     std::move(on_added_).Run(profile);
     on_edited_.Reset();
   } else {
     // Copy the temporary object's data to the object to be edited. Prefer this
     // method to copying |profile| into |profile_to_edit_|, because the latter
     // object needs to retain other properties (use count, use date, guid,
@@ skipping 89 matching lines @@
   temporary_profile_.reset(nullptr);
 }
 
 base::string16 ShippingAddressEditorViewController::GetSheetTitle() {
   // TODO(crbug.com/712074): Editor title should reflect the missing information
   // in the case that one or more fields are missing.
   return profile_to_edit_ ? l10n_util::GetStringUTF16(IDS_PAYMENTS_EDIT_ADDRESS)
                           : l10n_util::GetStringUTF16(IDS_PAYMENTS_ADD_ADDRESS);
 }
 
+std::unique_ptr<views::Button>
+ShippingAddressEditorViewController::CreatePrimaryButton() {
+  std::unique_ptr<views::Button> button(
+      EditorViewController::CreatePrimaryButton());
+  button->set_id(static_cast<int>(DialogViewID::SAVE_ADDRESS_BUTTON));
+  return button;
+}
+
 void ShippingAddressEditorViewController::UpdateEditorFields() {
   editor_fields_.clear();
   std::string chosen_country_code;
   if (chosen_country_index_ < country_codes_.size())
     chosen_country_code = country_codes_[chosen_country_index_];
 
   std::unique_ptr<base::ListValue> components(new base::ListValue);
   std::string unused;
   autofill::GetAddressComponents(chosen_country_code,
                                  state()->GetApplicationLocale(),
@@ skipping 169 matching lines @@
             controller_->country_codes_[controller_->chosen_country_index_])) {
       controller_->DisplayErrorMessageForField(
           field_, l10n_util::GetStringUTF16(
                       IDS_PAYMENTS_PHONE_INVALID_VALIDATION_MESSAGE));
       return false;
     }
     // As long as other field types are non-empty, they are valid.
     controller_->DisplayErrorMessageForField(field_, base::ASCIIToUTF16(""));
     return true;
   }
-
   bool is_required_valid = !field_.required;
   const base::string16 displayed_message =
       is_required_valid ? base::ASCIIToUTF16("")
                         : l10n_util::GetStringUTF16(
                               IDS_PAYMENTS_FIELD_REQUIRED_VALIDATION_MESSAGE);
   controller_->DisplayErrorMessageForField(field_, displayed_message);
   return is_required_valid;
 }
 
 }  // namespace payments