Use dropdown list for admin areas in pr form.

chrome/browser/autofill/android/personal_data_manager_android.cc

 // Copyright 2013 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/autofill/android/personal_data_manager_android.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <memory>
 #include <utility>
@@ skipping 292 matching lines @@
 
   ScopedJavaGlobalRef<jobject> jdelegate_;
   std::string guid_;
   std::string region_code_;
   base::WeakPtr<PersonalDataManagerAndroid> personal_data_manager_android_;
   JNIEnv* env_;
 
   DISALLOW_COPY_AND_ASSIGN(AddressNormalizationRequester);
 };
 
+class GetSubKeysRequester : public PersonalDataManagerAndroid::Delegate,
+                            public base::SupportsWeakPtr<GetSubKeysRequester> {
+ public:
+  GetSubKeysRequester(
+      JNIEnv* env,
+      const base::android::JavaParamRef<jobject>& jdelegate,
+      const std::string& region_code,
+      base::WeakPtr<PersonalDataManagerAndroid> personal_data_manager_android) {
+    jdelegate_.Reset(env, jdelegate);
+    region_code_ = region_code;
+    personal_data_manager_android_ = personal_data_manager_android;
+    env_ = env;
+  }
+
+ private:
+  ~GetSubKeysRequester() override {}
+
+  void OnRulesSuccessfullyLoaded() override {
+    if (personal_data_manager_android_) {
+      JNIEnv* env = base::android::AttachCurrentThread();
+      Java_GetSubKeysRequestDelegate_onSubKeysReceived(
+          env, jdelegate_,
+          personal_data_manager_android_->GetSubKeys(env, region_code_));
+    }
+  }
+
+  ScopedJavaGlobalRef<jobject> jdelegate_;
+  std::string region_code_;
+  base::WeakPtr<PersonalDataManagerAndroid> personal_data_manager_android_;
+  JNIEnv* env_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetSubKeysRequester);
+};
+
 }  // namespace
 
 PersonalDataManagerAndroid::PersonalDataManagerAndroid(JNIEnv* env, jobject obj)
     : weak_java_obj_(env, obj),
       personal_data_manager_(PersonalDataManagerFactory::GetForProfile(
           ProfileManager::GetActiveUserProfile())),
       address_validator_(
           std::unique_ptr<::i18n::addressinput::Source>(
               new autofill::ChromeMetadataSource(
                   I18N_ADDRESS_VALIDATION_DATA_URL,
@@ skipping 462 matching lines @@
 
   return CreateJavaProfileFromNative(env, *profile);
 }
 
 void PersonalDataManagerAndroid::CancelPendingAddressNormalizations(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& unused_obj) {
   pending_normalization_.clear();
 }
 
+base::android::ScopedJavaLocalRef<jobjectArray>
+PersonalDataManagerAndroid::GetSubKeys(JNIEnv* env,
+                                       const std::string& region_code) {
+  std::vector<std::string> sub_keys =
+      address_validator_.GetRegionSubKeys(region_code);
+  return base::android::ToJavaArrayOfStrings(env, sub_keys);
+}
+
+void PersonalDataManagerAndroid::OnGettingSubKeysRulesLoaded(

[sebsg, 2017/02/10 16:00:32]

You probably don't need a second function here. When the rules are loaded, you
can go through your 2 maps inside a single function.

[Parastoo, 2017/02/13 21:57:23]

As discussed, we will keep the functions separated, since we will need them both
for further changes (loading rules from non-aggregate server for sub-keys
requests.)

+    const std::string& region_code,
+    bool success) {
+  // Check if there is any sub-key request.
+  auto it = pending_subkeys_request_.find(region_code);
+  if (it != pending_subkeys_request_.end()) {
+    for (size_t i = 0; i < it->second.size(); ++i) {
+      it->second[i]->OnRulesSuccessfullyLoaded();
+    }
+    pending_subkeys_request_.erase(it);
+  }
+}
+
+void PersonalDataManagerAndroid::StartGettingRegionSubKeys(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& unused_obj,
+    const JavaParamRef<jstring>& jregion_code,
+    const JavaParamRef<jobject>& jdelegate) {
+  const std::string region_code = ConvertJavaStringToUTF8(env, jregion_code);
+  std::unique_ptr<Delegate> requester(
+      new GetSubKeysRequester(env, jdelegate, region_code, AsWeakPtr()));
+
+  if (AreRulesLoadedForRegion(region_code)) {
+    requester->OnRulesSuccessfullyLoaded();

[sebsg, 2017/02/10 16:00:32]

Since both RegionSubKeys and ValidationRules requester are implementing the
Delegate interface, you can probably create the "requester" here but then use a
common method for the rest of the function, which identical to
StartAddressNormalization.

[Parastoo, 2017/02/13 21:57:23]

Same here.

+  } else {
+    // Setup the variables so that the sub-keys request is sent, when the rules
+    // are loaded.
+    auto it = pending_subkeys_request_.find(region_code);
+    if (it == pending_subkeys_request_.end()) {
+      // If no entry exists, create the entry and assign it to |it|.
+      it = pending_subkeys_request_
+               .insert(std::make_pair(region_code,
+                                      std::vector<std::unique_ptr<Delegate>>()))
+               .first;
+    }
+    it->second.push_back(std::move(requester));
+  }
+}
+
+void PersonalDataManagerAndroid::CancelPendingGetSubKeys(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& unused_obj) {
+  pending_subkeys_request_.clear();
+}
+
 ScopedJavaLocalRef<jobjectArray> PersonalDataManagerAndroid::GetProfileGUIDs(
     JNIEnv* env,
     const std::vector<AutofillProfile*>& profiles) {
   std::vector<base::string16> guids;
   for (AutofillProfile* profile : profiles)
     guids.push_back(base::UTF8ToUTF16(profile->guid()));
 
   return base::android::ToJavaArrayOfStrings(env, guids);
 }
 
@@ skipping 122 matching lines @@
                base::android::ConvertJavaStringToUTF16(env, jcountry_name)));
 }
 
 static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   PersonalDataManagerAndroid* personal_data_manager_android =
       new PersonalDataManagerAndroid(env, obj);
   return reinterpret_cast<intptr_t>(personal_data_manager_android);
 }
 
 }  // namespace autofill