[Payments] Move address normalization code from android to native.

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>
 
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/resource_mapper.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
+#include "chrome/browser/autofill/validation_rules_storage_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
 #include "components/autofill/content/browser/content_autofill_driver.h"
 #include "components/autofill/content/browser/content_autofill_driver_factory.h"
 #include "components/autofill/core/browser/address_i18n.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_data_util.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/country_names.h"
 #include "components/autofill/core/browser/field_types.h"
 #include "components/autofill/core/browser/payments/full_card_request.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/validation.h"
 #include "components/autofill/core/common/autofill_constants.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/grit/components_scaled_resources.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/web_contents.h"
 #include "jni/PersonalDataManager_jni.h"
 #include "third_party/libaddressinput/chromium/chrome_metadata_source.h"
 #include "third_party/libaddressinput/chromium/chrome_storage_impl.h"
-#include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_data.h"
 
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF16ToJavaString;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaParamRef;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace autofill {
 namespace {
@@ skipping 210 matching lines @@
     Java_FullCardRequestDelegate_onFullCardError(env, jdelegate_);
     delete this;
   }
 
   std::unique_ptr<CreditCard> card_;
   ScopedJavaGlobalRef<jobject> jdelegate_;
 
   DISALLOW_COPY_AND_ASSIGN(FullCardRequester);
 };
 
-class AddressNormalizationRequester
-    : public PersonalDataManagerAndroid::Delegate,
-      public base::SupportsWeakPtr<AddressNormalizationRequester> {
+class AndroidAddressNormalizationRequester

[please use gerrit instead, 2017/02/14 21:31:08]

nit: AddressNormalizerDelegate

[sebsg, 2017/02/15 16:18:30]

Done.

+    : public ::payments::AddressNormalizationRequester,
+      public base::SupportsWeakPtr<AndroidAddressNormalizationRequester> {
  public:
-  AddressNormalizationRequester(
+  AndroidAddressNormalizationRequester(
       JNIEnv* env,
-      const base::android::JavaParamRef<jobject>& jdelegate,
-      const std::string& region_code,
-      const std::string& guid,
-      base::WeakPtr<PersonalDataManagerAndroid> personal_data_manager_android) {
+      const base::android::JavaParamRef<jobject>& jdelegate) {
     jdelegate_.Reset(env, jdelegate);
-    region_code_ = region_code;
-    guid_ = guid;
-    personal_data_manager_android_ = personal_data_manager_android;
-    env_ = env;
+  }
+
+  void OnAddressNormalized(AutofillProfile normalized_profile) override {

[please use gerrit instead, 2017/02/14 21:31:08]

const-ref for the normalized proifle.

[sebsg, 2017/02/15 16:18:30]

Done.

+    JNIEnv* env = base::android::AttachCurrentThread();
+    Java_NormalizedAddressRequestDelegate_onAddressNormalized(
+        env, jdelegate_, CreateJavaProfileFromNative(env, normalized_profile));
+    delete this;
   }
 
  private:
-  ~AddressNormalizationRequester() override {}
-
-  void OnRulesSuccessfullyLoaded() override {
-    if (personal_data_manager_android_) {
-      JNIEnv* env = base::android::AttachCurrentThread();
-      Java_NormalizedAddressRequestDelegate_onAddressNormalized(
-          env, jdelegate_, personal_data_manager_android_->NormalizeAddress(
-                               guid_, region_code_, env));
-    }
-  }
+  virtual ~AndroidAddressNormalizationRequester() {}

[please use gerrit instead, 2017/02/14 21:31:08]

override instead of virtual

[sebsg, 2017/02/15 16:18:30]

Done.

 
   ScopedJavaGlobalRef<jobject> jdelegate_;
-  std::string guid_;
-  std::string region_code_;
-  base::WeakPtr<PersonalDataManagerAndroid> personal_data_manager_android_;
-  JNIEnv* env_;
 
-  DISALLOW_COPY_AND_ASSIGN(AddressNormalizationRequester);
+  DISALLOW_COPY_AND_ASSIGN(AndroidAddressNormalizationRequester);
 };
 
-}  // namespace
+} // namespace
 
 PersonalDataManagerAndroid::PersonalDataManagerAndroid(JNIEnv* env, jobject obj)
     : weak_java_obj_(env, obj),
       personal_data_manager_(PersonalDataManagerFactory::GetForProfile(
           ProfileManager::GetActiveUserProfile())),
-      address_validator_(
+      address_validator_helper_(
           std::unique_ptr<::i18n::addressinput::Source>(
               new autofill::ChromeMetadataSource(
                   I18N_ADDRESS_VALIDATION_DATA_URL,
                   personal_data_manager_->GetURLRequestContextGetter())),
-          ValidationRulesStorageFactory::CreateStorage(),
-          this) {
+          ValidationRulesStorageFactory::CreateStorage()) {
   personal_data_manager_->AddObserver(this);
 }
 
 PersonalDataManagerAndroid::~PersonalDataManagerAndroid() {
   personal_data_manager_->RemoveObserver(this);
 }
 
 jboolean PersonalDataManagerAndroid::IsDataLoaded(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& unused_obj) const {
@@ skipping 364 matching lines @@
 jlong PersonalDataManagerAndroid::GetCurrentDateForTesting(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& unused_obj) {
   return base::Time::Now().ToTimeT();
 }
 
 void PersonalDataManagerAndroid::LoadRulesForRegion(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& unused_obj,
     const base::android::JavaParamRef<jstring>& jregion_code) {
-  address_validator_.LoadRules(ConvertJavaStringToUTF8(env, jregion_code));
+  address_validator_helper_.LoadRulesForRegion(
+      ConvertJavaStringToUTF8(env, jregion_code));
 }
 
-void PersonalDataManagerAndroid::OnAddressValidationRulesLoaded(
-    const std::string& region_code,
-    bool success) {
-  // Check if an address normalization is pending.
-  auto it = pending_normalization_.find(region_code);
-  if (it != pending_normalization_.end()) {
-    for (size_t i = 0; i < it->second.size(); ++i)
-      it->second[i]->OnRulesSuccessfullyLoaded();
-    pending_normalization_.erase(it);
-  }
-}
-
-jboolean PersonalDataManagerAndroid::StartAddressNormalization(
+void PersonalDataManagerAndroid::StartAddressNormalization(
     JNIEnv* env,
     const JavaParamRef<jobject>& unused_obj,
     const JavaParamRef<jstring>& jguid,
     const JavaParamRef<jstring>& jregion_code,
     const JavaParamRef<jobject>& jdelegate) {
   const std::string region_code = ConvertJavaStringToUTF8(env, jregion_code);
   const std::string guid = ConvertJavaStringToUTF8(env, jguid);
 
-  std::unique_ptr<Delegate> requester(new AddressNormalizationRequester(
-      env, jdelegate, region_code, guid, AsWeakPtr()));
-
-  // Check if the rules are already loaded.
-  if (AreRulesLoadedForRegion(region_code)) {
-    requester->OnRulesSuccessfullyLoaded();
-    return false;
-  } else {
-    // Setup the variables so the profile gets normalized when the rules have
-    // finished loading.
-    auto it = pending_normalization_.find(region_code);
-    if (it == pending_normalization_.end()) {
-      // If no entry exists yet, create the entry and assign it to |it|.
-      it = pending_normalization_
-               .insert(std::make_pair(region_code,
-                                      std::vector<std::unique_ptr<Delegate>>()))
-               .first;
-    }
-
-    it->second.push_back(std::move(requester));
-
-    return true;
-  }
-}
-
-ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::NormalizeAddress(
-    const std::string& guid,
-    const std::string& region_code,
-    JNIEnv* env) {
+  // Get the profile to normalize.
   AutofillProfile* profile = personal_data_manager_->GetProfileByGUID(guid);
 
-  if (!profile || !AreRulesLoadedForRegion(region_code))
-    return nullptr;
+  // Self-deleting object.
+  AndroidAddressNormalizationRequester* requester =
+      new AndroidAddressNormalizationRequester(env, jdelegate);
 
-  // Create the AddressData from the profile.
-  ::i18n::addressinput::AddressData address_data =
-      *i18n::CreateAddressDataFromAutofillProfile(
-          *profile, personal_data_manager_->app_locale());
-
-  // Normalize the address.
-  if (address_validator_.NormalizeAddress(&address_data)) {
-    profile->SetRawInfo(ADDRESS_HOME_STATE,
-                        base::UTF8ToUTF16(address_data.administrative_area));
-    profile->SetRawInfo(ADDRESS_HOME_CITY,
-                        base::UTF8ToUTF16(address_data.locality));
-    profile->SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
-                        base::UTF8ToUTF16(address_data.dependent_locality));
-  }
-
-  return CreateJavaProfileFromNative(env, *profile);
-}
-
-void PersonalDataManagerAndroid::CancelPendingAddressNormalizations(
-    JNIEnv* env,
-    const base::android::JavaParamRef<jobject>& unused_obj) {
-  pending_normalization_.clear();
+  // Start the normalization.
+  address_validator_helper_.StartAddressNormalization(*profile, region_code,
+                                                      requester);
 }
 
 jboolean PersonalDataManagerAndroid::HasProfiles(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& unused_obj) {
   return !personal_data_manager_->GetProfiles().empty();
 }
 
 jboolean PersonalDataManagerAndroid::HasCreditCards(
     JNIEnv* env,
@@ skipping 16 matching lines @@
     const std::vector<CreditCard*>& credit_cards) {
   std::vector<base::string16> guids;
   for (CreditCard* credit_card : credit_cards)
     guids.push_back(base::UTF8ToUTF16(credit_card->guid()));
 
   return base::android::ToJavaArrayOfStrings(env, guids);
 }
 
 bool PersonalDataManagerAndroid::AreRulesLoadedForRegion(
     const std::string& region_code) {
-  return address_validator_.AreRulesLoadedForRegion(region_code);
+  return address_validator_helper_.AreRulesLoadedForRegion(region_code);
 }
 
 ScopedJavaLocalRef<jobjectArray> PersonalDataManagerAndroid::GetProfileLabels(
     JNIEnv* env,
     bool address_only,
     bool include_name_in_label,
     bool include_organization_in_label,
     bool include_country_in_label,
     std::vector<AutofillProfile*> profiles) {
   std::unique_ptr<std::vector<ServerFieldType>> suggested_fields;
@@ skipping 99 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