Use dropdown list for admin areas in pr form.

chrome/android/java/src/org/chromium/chrome/browser/payments/AddressEditor.java

 // Copyright 2016 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.
 
 package org.chromium.chrome.browser.payments;
 
+import android.app.ProgressDialog;
 import android.os.Handler;
 import android.util.Pair;
 
 import org.chromium.base.Callback;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.autofill.PersonalDataManager;
 import org.chromium.chrome.browser.autofill.PersonalDataManager.AutofillProfile;
+import org.chromium.chrome.browser.autofill.PersonalDataManager.GetSubKeysRequestDelegate;
 import org.chromium.chrome.browser.autofill.PhoneNumberUtil;
 import org.chromium.chrome.browser.payments.ui.EditorFieldModel;
 import org.chromium.chrome.browser.payments.ui.EditorFieldModel.EditorFieldValidator;
 import org.chromium.chrome.browser.payments.ui.EditorModel;
 import org.chromium.chrome.browser.preferences.autofill.AutofillProfileBridge;
 import org.chromium.chrome.browser.preferences.autofill.AutofillProfileBridge.AddressField;
 import org.chromium.chrome.browser.preferences.autofill.AutofillProfileBridge.AddressUiComponent;
 
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 
 import javax.annotation.Nullable;
 
 /**
  * An address editor. Can be used for either shipping or billing address editing.
  */
-public class AddressEditor extends EditorBase<AutofillAddress> {
+public class AddressEditor
+        extends EditorBase<AutofillAddress> implements GetSubKeysRequestDelegate {
     private final Handler mHandler = new Handler();
     private final Map<Integer, EditorFieldModel> mAddressFields = new HashMap<>();
     private final Set<CharSequence> mPhoneNumbers = new HashSet<>();
-    @Nullable private AutofillProfileBridge mAutofillProfileBridge;
-    @Nullable private EditorFieldModel mCountryField;
-    @Nullable private EditorFieldModel mPhoneField;
-    @Nullable private EditorFieldValidator mPhoneValidator;
-    @Nullable private List<AddressUiComponent> mAddressUiComponents;
+    @Nullable
+    private AutofillProfileBridge mAutofillProfileBridge;
+    @Nullable
+    private EditorFieldModel mCountryField;
+    @Nullable
+    private EditorFieldModel mPhoneField;
+    @Nullable
+    private EditorFieldValidator mPhoneValidator;
+    @Nullable
+    private List<AddressUiComponent> mAddressUiComponents;
+    private boolean mAdminAreasLoaded;
+    private String mRecentlySelectedCountry;
+    private Runnable mCountryChangeCallback;
+    private AutofillProfile mProfile;
+    private EditorModel mEditor;
+    private ProgressDialog mProgressDialog;
 
     /**
      * Adds the given phone number to the autocomplete set, if it's valid.
      *
      * @param phoneNumber The phone number to possibly add.
      */
     public void addPhoneNumberIfValid(@Nullable CharSequence phoneNumber) {
         if (getPhoneValidator().isValid(phoneNumber)) mPhoneNumbers.add(phoneNumber);
     }
 
@@ skipping 12 matching lines @@
     public void edit(
             @Nullable final AutofillAddress toEdit, final Callback<AutofillAddress> callback) {
         super.edit(toEdit, callback);
 
         if (mAutofillProfileBridge == null) mAutofillProfileBridge = new AutofillProfileBridge();
 
         // If |toEdit| is null, we're creating a new autofill profile with the country code of the
         // default locale on this device.
         boolean isNewAddress = toEdit == null;
 
-        // Ensure that |address| and |profile| are always not null.
+        // Ensure that |address| and |mProfile| are always not null.
         final AutofillAddress address =
                 isNewAddress ? new AutofillAddress(mContext, new AutofillProfile()) : toEdit;
-        final AutofillProfile profile = address.getProfile();
+        mProfile = address.getProfile();
 
         // The title of the editor depends on whether we're adding a new address or editing an
         // existing address.
-        final EditorModel editor =
-                new EditorModel(isNewAddress
-                        ? mContext.getString(R.string.autofill_create_profile)
-                        : toEdit.getEditTitle());
+        mEditor =
+                new EditorModel(isNewAddress ? mContext.getString(R.string.autofill_create_profile)
+                                             : toEdit.getEditTitle());
+
+        // When edit is called, a new form is started, so the country on the
+        // drop-down list is not changed. => mRecentlySelectedCountry should be null.
+        mRecentlySelectedCountry = null;
 
         // The country dropdown is always present on the editor.
         if (mCountryField == null) {
             mCountryField = EditorFieldModel.createDropdown(
                     mContext.getString(R.string.autofill_profile_editor_country),
                     AutofillProfileBridge.getSupportedCountries(),
                     null /* hint */);
         }
 
         // Changing the country will update which fields are in the model. The actual fields are not
         // discarded, so their contents are preserved.
         mCountryField.setDropdownCallback(new Callback<Pair<String, Runnable>>() {
             @Override
+            /*
+             * If the selected country on the country dropdown list is changed,

[gone, 2017/04/05 00:14:21]

1) Javadoc comments start with /** and end with */.  Fix here and everywhere
else in your CL.

2) Indent at 100, not at 80.

[Parastoo, 2017/04/05 19:49:06]

Done.

+             * the first element of eventData is the recently selected dropdown key,
+             * the second element is the callback to invoke for when the dropdown
+             * change has been processed.
+             */
             public void onResult(Pair<String, Runnable> eventData) {
-                editor.removeAllFields();
-                editor.addField(mCountryField);
-                addAddressTextFieldsToEditor(editor, eventData.first,
-                        Locale.getDefault().getLanguage());
-                editor.addField(mPhoneField);
-
-                // Notify EditorView that the fields in the model have changed. EditorView should
-                // re-read the model and update the UI accordingly.
-                mHandler.post(eventData.second);
+                mEditor.removeAllFields();
+                showProgressDialog();
+                mRecentlySelectedCountry = eventData.first;
+                mCountryChangeCallback = eventData.second;
+                loadAdminAreasForCountry(mRecentlySelectedCountry);
             }
         });
 
         // Country dropdown is cached, so the selected item needs to be updated for the new profile
         // that's being edited. This will not fire the dropdown callback.
-        mCountryField.setValue(AutofillAddress.getCountryCode(profile));
-        editor.addField(mCountryField);
+        mCountryField.setValue(AutofillAddress.getCountryCode(mProfile));
 
         // There's a finite number of fields for address editing. Changing the country will re-order
         // and relabel the fields. The meaning of each field remains the same.
         if (mAddressFields.isEmpty()) {
             // City, dependent locality, and organization don't have any special formatting hints.
             mAddressFields.put(AddressField.LOCALITY, EditorFieldModel.createTextInput());
             mAddressFields.put(AddressField.DEPENDENT_LOCALITY, EditorFieldModel.createTextInput());
             mAddressFields.put(AddressField.ORGANIZATION, EditorFieldModel.createTextInput());
 
-            // State should be formatted in all capitals.
-            mAddressFields.put(AddressField.ADMIN_AREA, EditorFieldModel.createTextInput(
-                        EditorFieldModel.INPUT_TYPE_HINT_REGION));
-
             // Sorting code and postal code (a.k.a. ZIP code) should show both letters and digits on
             // the keyboard, if possible.
             mAddressFields.put(AddressField.SORTING_CODE, EditorFieldModel.createTextInput(
                     EditorFieldModel.INPUT_TYPE_HINT_ALPHA_NUMERIC));
             mAddressFields.put(AddressField.POSTAL_CODE, EditorFieldModel.createTextInput(
                     EditorFieldModel.INPUT_TYPE_HINT_ALPHA_NUMERIC));
 
             // Street line field can contain \n to indicate line breaks.
             mAddressFields.put(AddressField.STREET_ADDRESS, EditorFieldModel.createTextInput(
                     EditorFieldModel.INPUT_TYPE_HINT_STREET_LINES));
 
             // Android has special formatting rules for names.
             mAddressFields.put(AddressField.RECIPIENT, EditorFieldModel.createTextInput(
                     EditorFieldModel.INPUT_TYPE_HINT_PERSON_NAME));
         }
 
-        // Address fields are cached, so their values need to be updated for every new profile
-        // that's being edited.
-        for (Map.Entry<Integer, EditorFieldModel> entry : mAddressFields.entrySet()) {
-            entry.getValue().setValue(AutofillAddress.getProfileField(profile, entry.getKey()));
-        }
-
-        // Both country code and language code dictate which fields should be added to the editor.
-        // For example, "US" will not add dependent locality to the editor. A "JP" address will
-        // start with a person's full name or a with a prefecture name, depending on whether the
-        // language code is "ja-Latn" or "ja".
-        addAddressTextFieldsToEditor(editor, profile.getCountryCode(), profile.getLanguageCode());
 
         // Phone number is present and required for all countries.
         if (mPhoneField == null) {
             mPhoneField = EditorFieldModel.createTextInput(EditorFieldModel.INPUT_TYPE_HINT_PHONE,
                     mContext.getString(R.string.autofill_profile_editor_phone_number),
                     mPhoneNumbers, getPhoneValidator(), null,
                     mContext.getString(R.string.payments_field_required_validation_message),
                     mContext.getString(R.string.payments_phone_invalid_validation_message), null);
         }
 
         // Phone number field is cached, so its value needs to be updated for every new profile
         // that's being edited.
-        mPhoneField.setValue(profile.getPhoneNumber());
-        editor.addField(mPhoneField);
+        mPhoneField.setValue(mProfile.getPhoneNumber());
 
         // If the user clicks [Cancel], send |toEdit| address back to the caller, which was the
         // original state (could be null, a complete address, a partial address).
-        editor.setCancelCallback(new Runnable() {
+        mEditor.setCancelCallback(new Runnable() {
             @Override
             public void run() {
+                /* This makes sure that onSubKeysReceived returns early if it's

[gone, 2017/04/05 00:14:21]

Java-land uses // for non-javadoc comments.  See the rest of the file.

[Parastoo, 2017/04/05 19:49:06]

Done.

+                   ever called when Cancel has already occurred.*/
+                mAdminAreasLoaded = true;
+                PersonalDataManager.getInstance().cancelPendingGetSubKeys();
                 callback.onResult(toEdit);
             }
         });
 
         // If the user clicks [Done], save changes on disk, mark the address "complete," and send it
         // back to the caller.
-        editor.setDoneCallback(new Runnable() {
+        mEditor.setDoneCallback(new Runnable() {
             @Override
             public void run() {
-                commitChanges(profile);
-                address.completeAddress(profile);
+                mAdminAreasLoaded = true;
+                PersonalDataManager.getInstance().cancelPendingGetSubKeys();
+                commitChanges(mProfile);
+                address.completeAddress(mProfile);
                 callback.onResult(address);
             }
         });
 
-        mEditorView.show(editor);
+        loadAdminAreasForCountry(mProfile.getCountryCode());
+    }
+
+    private void showProgressDialog() {
+        mProgressDialog = new ProgressDialog(mContext);
+        mProgressDialog.setMessage(mContext.getText(R.string.payments_loading_message));
+        mProgressDialog.show();
+    }
+
+    private void dismissProgressDialog() {
+        if (mProgressDialog != null && mProgressDialog.isShowing()) {
+            mProgressDialog.dismiss();
+        }
+        mProgressDialog = null;
     }
 
     /** Saves the edited profile on disk. */
     private void commitChanges(AutofillProfile profile) {
         // Country code and phone number are always required and are always collected from the
         // editor model.
         profile.setCountryCode(mCountryField.getValue().toString());
         profile.setPhoneNumber(mPhoneField.getValue().toString());
 
         // Autofill profile bridge normalizes the language code for the autofill profile.
@@ skipping 11 matching lines @@
 
         // Clear the fields that are hidden from the user interface, so
         // AutofillAddress.toPaymentAddress() will send them to the renderer as empty strings.
         for (Map.Entry<Integer, EditorFieldModel> entry : mAddressFields.entrySet()) {
             if (!visibleFields.contains(entry.getKey())) {
                 setProfileField(profile, entry.getKey(), "");
             }
         }
 
         // Save the edited autofill profile locally.
-        profile.setGUID(PersonalDataManager.getInstance().setProfileToLocal(profile));
+        profile.setGUID(PersonalDataManager.getInstance().setProfileToLocal(mProfile));
         profile.setIsLocal(true);
     }
 
     /** Writes the given value into the specified autofill profile field. */
     private static void setProfileField(
             AutofillProfile profile, int field, @Nullable CharSequence value) {
         assert profile != null;
         switch (field) {
             case AddressField.COUNTRY:
                 profile.setCountryCode(ensureNotNull(value));
@@ skipping 24 matching lines @@
                 return;
         }
 
         assert false;
     }
 
     private static String ensureNotNull(@Nullable CharSequence value) {
         return value == null ? "" : value.toString();
     }
 
+    private void setAddressFieldValuesFromCache() {
+        // Address fields are cached, so their values need to be updated for every new profile
+        // that's being edited.
+        for (Map.Entry<Integer, EditorFieldModel> entry : mAddressFields.entrySet()) {
+            entry.getValue().setValue(AutofillAddress.getProfileField(mProfile, entry.getKey()));
+        }
+    }
+
+    /* Callback of the sub keys request that is called when the sub keys are loaded.

[gone, 2017/04/05 00:14:21]

/**
 * Callback of the sub keys request that is called when the sub keys are loaded.
 * Here the sub keys are admin areas (sub keys of the region=country).
 */

Is this different from how the other onSubKeysReceived calls are implemented? 
Does this comment apply to everywhere that makes this callback?  If so, this
detail should be put in the interface itself.

[Parastoo, 2017/04/05 19:49:07]

It isn't different. The comment was moved to the interface.
Done.

+       Here the sub keys are admin areas (sub keys of the region=country.) */
+    @Override
+    public void onSubKeysReceived(String[] adminAreas) {
+        if (mAdminAreasLoaded) return;
+        mAdminAreasLoaded = true;
+
+        // If can't get admin areas from server or there is no admin area on the

[gone, 2017/04/05 00:14:20]

1) be consistent about whether you use "Admin Areas" or "admin areas".
2) If Chrome can't get admin areas...
   then use the text field
   drop-down

[Parastoo, 2017/04/05 19:49:06]

Done.

+        // server, then use text field. Otherwise, use drop down list.
+        if (adminAreas == null || adminAreas.length == 0) {
+            mAddressFields.put(AddressField.ADMIN_AREA, EditorFieldModel.createTextInput());
+        } else {
+            mAddressFields.put(AddressField.ADMIN_AREA, EditorFieldModel.createDropdown());
+        }
+
+        /* Admin Areas need to be fetched in two cases.

[gone, 2017/04/05 00:14:21]

1) Use //.
2) two cases. -> two cases:

[Parastoo, 2017/04/05 19:49:06]

Done.

+           1. Initial loading of the form.
+           2. When the selected country is changed in the form.
+           mRecentlySelectedCountry is not null <=> the 2nd case */

[gone, 2017/04/05 00:14:20]

What does this line mean specifically?  Expand your "<=>".

[Parastoo, 2017/04/05 19:49:06]

Done.

+        if (mRecentlySelectedCountry != null) {
+            dismissProgressDialog();
+            // Both country code and language code dictate which fields should be added to the
+            // editor.
+            // For example, "US" will not add dependent locality to the editor. A "JP" address will
+            // start with a person's full name or a with a prefecture name, depending on whether the
+            // language code is "ja-Latn" or "ja".
+            addAddressFieldsToEditor(
+                    mRecentlySelectedCountry, Locale.getDefault().getLanguage(), adminAreas);
+            // Notify EditorView that the fields in the model have changed. EditorView should
+            // re-read the model and update the UI accordingly.
+            mHandler.post(mCountryChangeCallback);
+        } else {
+            // This should be called when all required fields are put in mAddressField.
+            setAddressFieldValuesFromCache();
+            addAddressFieldsToEditor(
+                    mProfile.getCountryCode(), mProfile.getLanguageCode(), adminAreas);
+            mEditorView.show(mEditor);
+        }
+    }
+
+    /** Requests the list of admin areas. */
+    private void loadAdminAreasForCountry(String countryCode) {
+        // Used to check if the callback is called (for time-out).
+        mAdminAreasLoaded = false;
+
+        // In each rule, admin area keys are saved under sub keys of country.

[gone, 2017/04/05 00:14:21]

sub-keys

[Parastoo, 2017/04/05 19:49:06]

Done.

+        PersonalDataManager.getInstance().loadRulesForSubKeys(countryCode);
+        PersonalDataManager.getInstance().getRegionSubKeys(countryCode, this);
+        onAdminAreasLoading();
+    }
+
+    /* In case the the admin areas are not loaded yet, starts a timer to cancel the request. */

[gone, 2017/04/05 00:14:20]

If it fits on a single line, then:

/** In case the the admin areas are not loaded yet, starts a timer to cancel the
request. */

Otherwise:

/**
 * In case the the admin areas are not loaded yet, starts a timer to cancel the
request.
 */

[Parastoo, 2017/04/05 19:49:06]

Done.

+    public void onAdminAreasLoading() {

[gone, 2017/04/05 00:14:21]

save a level of indentation by early returning.

if (mAdminAreasLoaded) return;

[Parastoo, 2017/04/05 19:49:07]

Done.

+        if (!mAdminAreasLoaded) {
+            if (PersonalDataManager.getInstance().getRequestTimeoutMS() == 0) {
+                onSubKeysReceived(null);
+                PersonalDataManager.getInstance().cancelPendingGetSubKeys();
+            } else {
+                new Handler().postDelayed(new Runnable() {
+                    @Override
+                    public void run() {
+                        if (!mAdminAreasLoaded) {

[gone, 2017/04/05 00:14:21]

This is exactly the code above with a delay.  Don't duplicate it; make another
function and pull it out.

[Parastoo, 2017/04/05 19:49:06]

Done.

+                            onSubKeysReceived(null);
+                            PersonalDataManager.getInstance().cancelPendingGetSubKeys();
+                        }
+                    }
+                }, PersonalDataManager.getInstance().getRequestTimeoutMS());
+            }

[gone, 2017/04/05 00:14:21]

One of these pathways is asynchronous and one is not.  Doesn't that complicate
the pathway?  Can you just always post?

[Parastoo, 2017/04/05 19:49:06]

Done.

+        }
+    }
+
     /**
-     * Adds text fields to the editor model based on the country and language code of the profile
-     * that's being edited.
+     * Adds fields to the editor model based on the country and language code of
+     * the profile that's being edited.
      */
-    private void addAddressTextFieldsToEditor(
-            EditorModel container, String countryCode, String languageCode) {
-        mAddressUiComponents = mAutofillProfileBridge.getAddressUiComponents(countryCode,
-                languageCode);
-
+    private void addAddressFieldsToEditor(
+            String countryCode, String languageCode, String[] adminAreas) {
+        mAddressUiComponents =
+                mAutofillProfileBridge.getAddressUiComponents(countryCode, languageCode);
+        // In terms of order, country must be the first field.
+        mEditor.addField(mCountryField);
         for (int i = 0; i < mAddressUiComponents.size(); i++) {
             AddressUiComponent component = mAddressUiComponents.get(i);
 
-            // The country field is a dropdown, so there's no need to add a text field for it.
-            if (component.id == AddressField.COUNTRY) continue;
-
             EditorFieldModel field = mAddressFields.get(component.id);
             // Labels depend on country, e.g., state is called province in some countries. These are
             // already localized.
             field.setLabel(component.label);
             field.setIsFullLine(component.isFullLine);
 
+            if (component.id == AddressField.ADMIN_AREA && field.isDropdownField()) {
+                field.setDropdownKeyValues(
+                        mAutofillProfileBridge.getAdminAreaDropdownList(adminAreas));
+            }
+
             // Libaddressinput formats do not always require the full name (RECIPIENT), but
             // PaymentRequest does.
             if (component.isRequired || component.id == AddressField.RECIPIENT) {
                 field.setRequiredErrorMessage(mContext.getString(
                         R.string.payments_field_required_validation_message));
             } else {
                 field.setRequiredErrorMessage(null);
             }
-
-            container.addField(field);
+            mEditor.addField(field);
         }
+        // Phone number must be the last field.
+        mEditor.addField(mPhoneField);
     }
 
     private EditorFieldValidator getPhoneValidator() {
         if (mPhoneValidator == null) {
             mPhoneValidator = new EditorFieldValidator() {
                 @Override
                 public boolean isValid(@Nullable CharSequence value) {
                     return value != null && PhoneNumberUtil.isValidNumber(value.toString());
                 }
 
                 @Override
                 public boolean isLengthMaximum(@Nullable CharSequence value) {
                     return false;
                 }
             };
         }
         return mPhoneValidator;
     }
 }