Payment request shipping address editor now properly handles countries

chrome/browser/ui/views/payments/shipping_address_editor_view_controller_browsertest.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 <algorithm>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/views/payments/payment_request_browsertest_base.h"
 #include "chrome/browser/ui/views/payments/payment_request_dialog_view_ids.h"
 #include "chrome/browser/ui/views/payments/validating_textfield.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/country_combobox_model.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/region_combobox_model.h"
 #include "components/autofill/core/browser/test_region_data_loader.h"
 #include "components/payments/content/payment_request_spec.h"
 #include "content/public/test/browser_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/null_storage.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/source.h"
 #include "ui/views/controls/combobox/combobox.h"
 
 namespace payments {
 
 namespace {
 
+const char kLocale[] = "en_US";
 const char kNameFull[] = "Bob Jones";
 const char kHomeAddress[] = "42 Answers-All Avenue";
 const char kHomeCity[] = "Question-City";
 const char kHomeZip[] = "ziiiiiip";
 const char kHomePhone[] = "5755555555";  // 5555555555 is invalid :-(.
 const char kFormattedHomePhone[] = "(575) 555-5555";
 const char kAnyState[] = "any state";
+const char kCountryWithoutStates[] = "Albania";
+const char kCountryWithoutStatesPhoneNumber[] = "42223446";
 
 }  // namespace
 
 class PaymentRequestShippingAddressEditorTest
     : public PaymentRequestBrowserTestBase {
  protected:
   PaymentRequestShippingAddressEditorTest()
       : PaymentRequestBrowserTestBase(
             "/payment_request_dynamic_shipping_test.html") {}
 
@@ skipping 31 matching lines @@
   }
 
   void SetCommonFields() {
     SetFieldTestValue(autofill::NAME_FULL);
     SetFieldTestValue(autofill::ADDRESS_HOME_STREET_ADDRESS);
     SetFieldTestValue(autofill::ADDRESS_HOME_CITY);
     SetFieldTestValue(autofill::ADDRESS_HOME_ZIP);
     SetFieldTestValue(autofill::PHONE_HOME_WHOLE_NUMBER);
   }
 
-  // First check if the requested field of |type| exists, if so set it's value
-  // in |textfield_text| and return true.
+  // First check if the requested field of |type| exists, if so, set its value
+  // in |textfield_text| if it's not null, and return true.
   bool GetEditorTextfieldValueIfExists(autofill::ServerFieldType type,
                                        base::string16* textfield_text) {
     ValidatingTextfield* textfield = static_cast<ValidatingTextfield*>(
         dialog_view()->GetViewByID(static_cast<int>(type)));
     if (!textfield)
       return false;
-    *textfield_text = textfield->text();
+    if (textfield_text)
+      *textfield_text = textfield->text();
     return true;
   }
 
   // |unset_types| can be null, but when it's not, the fields that are not set
   // get their type added to it, so that the caller can tell which types are not
   // set for a given country. |accept_empty_phone_number| can be set to true to
   // accept a phone type field set to empty, and mark it as unset.
   void ExpectExistingRequiredFields(
       std::set<autofill::ServerFieldType>* unset_types,
       bool accept_empty_phone_number) {
@@ skipping 224 matching lines @@
   std::set<autofill::ServerFieldType> unset_types;
   for (size_t country_index = 10; country_index < num_countries;
        country_index += num_countries / 10) {
     // The editor updates asynchronously when the country changes.
     ResetEventObserver(DialogEvent::EDITOR_VIEW_UPDATED);
 
     views::Combobox* region_combobox =
         static_cast<views::Combobox*>(dialog_view()->GetViewByID(
             static_cast<int>(autofill::ADDRESS_HOME_STATE)));
     autofill::RegionComboboxModel* region_model = nullptr;
-    // Some countries don't have a state combo box.
+    // Some countries don't have a state combobox.
     if (region_combobox) {
       autofill::RegionComboboxModel* region_model =
           static_cast<autofill::RegionComboboxModel*>(region_combobox->model());
       if (use_regions1) {
         ASSERT_EQ(1, region_model->GetItemCount());
         EXPECT_EQ(base::ASCIIToUTF16("region1a"), region_model->GetItemAt(0));
       } else {
         ASSERT_EQ(2, region_model->GetItemCount());
         EXPECT_EQ(base::ASCIIToUTF16("region2a"), region_model->GetItemAt(0));
         EXPECT_EQ(base::ASCIIToUTF16("region2b"), region_model->GetItemAt(1));
@@ skipping 20 matching lines @@
       if (textfield) {
         EXPECT_TRUE(textfield->text().empty()) << type;
         SetFieldTestValue(type);
         set_types.insert(type);
       }
     }
     for (auto type : set_types) {
       unset_types.erase(type);
     }
 
-    // Make sure the country combo box was properly reset to the chosen country.
+    // Make sure the country combobox was properly reset to the chosen country.
     country_combobox = static_cast<views::Combobox*>(dialog_view()->GetViewByID(
         static_cast<int>(autofill::ADDRESS_HOME_COUNTRY)));
     DCHECK(country_combobox);
     EXPECT_EQ(country_index,
               static_cast<size_t>(country_combobox->GetSelectedRow()));
     country_model =
         static_cast<autofill::CountryComboboxModel*>(country_combobox->model());
     ASSERT_EQ(num_countries, country_model->countries().size());
 
     // Update regions.
@@ skipping 83 matching lines @@
             profile->GetRawInfo(autofill::ADDRESS_HOME_STATE));
   ExpectExistingRequiredFields(/*unset_types=*/nullptr,
                                /*accept_empty_phone_number=*/false);
 }
 
 IN_PROC_BROWSER_TEST_F(PaymentRequestShippingAddressEditorTest,
                        SelectingIncompleteAddress) {
   // Add incomplete address.
   autofill::AutofillProfile profile;
   profile.SetInfo(autofill::AutofillType(autofill::NAME_FULL),
-                  base::ASCIIToUTF16(kNameFull), "fr_CA");
+                  base::ASCIIToUTF16(kNameFull), kLocale);
+  // Also set non-default country, to make sure proper fields will be used.
+  profile.SetInfo(autofill::AutofillType(autofill::ADDRESS_HOME_COUNTRY),
+                  base::ASCIIToUTF16(kCountryWithoutStates), kLocale);
   AddAutofillProfile(profile);
 
   InvokePaymentRequestUI();
 
   // One shipping address is available, but it's not selected.
   PaymentRequest* request = GetPaymentRequests(GetActiveWebContents()).front();
   EXPECT_EQ(1U, request->state()->shipping_profiles().size());
   EXPECT_EQ(nullptr, request->state()->selected_shipping_profile());
 
   OpenShippingAddressSectionScreen();
 
   ResetEventObserver(DialogEvent::SHIPPING_ADDRESS_EDITOR_OPENED);
   ClickOnChildInListViewAndWait(/*child_index=*/0, /*num_children=*/1,
                                 DialogViewID::SHIPPING_ADDRESS_SHEET_LIST_VIEW);
 
   EXPECT_EQ(base::ASCIIToUTF16(kNameFull),
             GetEditorTextfieldValue(autofill::NAME_FULL));
-  EXPECT_EQ(base::ASCIIToUTF16(""),
-            GetEditorTextfieldValue(autofill::ADDRESS_HOME_ZIP));
+  // There are no state field in |kCountryWithoutStates|.
+  EXPECT_FALSE(
+      GetEditorTextfieldValueIfExists(autofill::ADDRESS_HOME_STATE, nullptr));
 
   // Set all required fields.
   SetCommonFields();
+  // The phone number must be replaced by one that is valid for
+  // |kCountryWithoutStates|.
+  SetEditorTextfieldValue(base::ASCIIToUTF16(kCountryWithoutStatesPhoneNumber),
+                          autofill::PHONE_HOME_WHOLE_NUMBER);
 
   // Verifying the data is in the DB.
   autofill::PersonalDataManager* personal_data_manager = GetDataManager();
   personal_data_manager->AddObserver(&personal_data_observer_);
 
   ResetEventObserver(DialogEvent::BACK_TO_PAYMENT_SHEET_NAVIGATION);
 
   // Wait until the web database has been updated and the notification sent.
   base::RunLoop data_loop;
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMessageLoop(&data_loop));
   ClickOnDialogViewAndWait(DialogViewID::SAVE_ADDRESS_BUTTON);
   data_loop.Run();
 
+  ASSERT_EQ(1UL, personal_data_manager->GetProfiles().size());
+  autofill::AutofillProfile* saved_profile =
+      personal_data_manager->GetProfiles()[0];
+  DCHECK(saved_profile);
+  EXPECT_EQ(
+      base::ASCIIToUTF16(kCountryWithoutStates),
+      saved_profile->GetInfo(
+          autofill::AutofillType(autofill::ADDRESS_HOME_COUNTRY), kLocale));
   ExpectExistingRequiredFields(/*unset_types=*/nullptr,
                                /*accept_empty_phone_number=*/false);
 
   // Still have one shipping address, but now it's selected.
   EXPECT_EQ(1U, request->state()->shipping_profiles().size());
   EXPECT_EQ(request->state()->shipping_profiles().back(),
             request->state()->selected_shipping_profile());
 }
 
 }  // namespace payments