[Payments] Normalize addresses before passing them to merchants.

chrome/browser/autofill/android/personal_data_manager_android.cc

Index: chrome/browser/autofill/android/personal_data_manager_android.cc
diff --git a/chrome/browser/autofill/android/personal_data_manager_android.cc b/chrome/browser/autofill/android/personal_data_manager_android.cc
index 519f4e138d54fa6e037e865aa50bdf36971f7cc2..cb1ee076db043a62754585171cc5686a1e1f501c 100644
--- a/chrome/browser/autofill/android/personal_data_manager_android.cc
+++ b/chrome/browser/autofill/android/personal_data_manager_android.cc
@@ -25,6 +25,7 @@
 #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"
@@ -40,6 +41,9 @@
 #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;
@@ -263,6 +267,47 @@ class FullCardRequester : public payments::FullCardRequest::Delegate,
   DISALLOW_COPY_AND_ASSIGN(FullCardRequester);
 };
 
+// Self-deleting requester of address normalization.
+class AddressNormalizationRequester
+    : public PersonalDataManagerAndroid::Delegate,
+      public base::SupportsWeakPtr<AddressNormalizationRequester> {
+ public:
+  AddressNormalizationRequester(
+      JNIEnv* env,
+      const base::android::JavaParamRef<jobject>& jdelegate,
+      const std::string& region_code,
+      const std::string& guid,
+      PersonalDataManagerAndroid* personal_data_manager_android) {
+    jdelegate_.Reset(env, jdelegate);
+    region_code_ = region_code;
+    guid_ = guid;
+    personal_data_manager_android_ = personal_data_manager_android;
+    env_ = env;
+  }
+
+ private:
+  virtual ~AddressNormalizationRequester() {}
+
+  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));
+    }
+
+    delete this;
+  }
+
+  ScopedJavaGlobalRef<jobject> jdelegate_;
+  std::string guid_;
+  std::string region_code_;
+  PersonalDataManagerAndroid* personal_data_manager_android_;
+  JNIEnv* env_;
+
+  DISALLOW_COPY_AND_ASSIGN(AddressNormalizationRequester);
+};
+
 }  // namespace
 
 PersonalDataManagerAndroid::PersonalDataManagerAndroid(JNIEnv* env,
@@ -271,6 +316,13 @@ PersonalDataManagerAndroid::PersonalDataManagerAndroid(JNIEnv* env,
       personal_data_manager_(PersonalDataManagerFactory::GetForProfile(
           ProfileManager::GetActiveUserProfile())) {
   personal_data_manager_->AddObserver(this);
+
+  address_validator_.reset(new AddressValidator(

[vabr (Chromium), 2016/09/28 08:41:36]

Unless |address_validator_| needs to be constructed after the call on line 318
(does not look so to me), then please consider aggregating it directly into
PersonalDataManagerAndroid instead of indirectly via unique_ptr. Avoiding the
extra heap allocation is a good practice for performance and memory efficiency,
and it also clarifies the life-span of the object.

If you do need unique_ptr, please use assignment and base::MakeUnique instead of
reset and new, for both code readability and safety (see recent chromium-dev
discussion on this topic).

[sebsg, 2016/09/28 16:15:24]

Thanks, coming from C# this was an interesting read!

+      std::unique_ptr<::i18n::addressinput::Source>(
+          new autofill::ChromeMetadataSource(
+              I18N_ADDRESS_VALIDATION_DATA_URL,
+              personal_data_manager_->GetURLRequestContextGetter())),
+      ValidationRulesStorageFactory::CreateStorage(), this));
 }
 
 PersonalDataManagerAndroid::~PersonalDataManagerAndroid() {
@@ -601,6 +653,82 @@ jlong PersonalDataManagerAndroid::GetCurrentDateForTesting(
   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));
+}
+
+void PersonalDataManagerAndroid::OnAddressValidationRulesLoaded(
+    const std::string& region_code,
+    bool success) {
+  // Check if an address normalization is pending.
+  std::map<std::string, Delegate*>::iterator it =
+      pending_normalization_.find(region_code);
+  if (it != pending_normalization_.end()) {
+    // The AddressNormalizationRequester will self delete after normalizing.

[vabr (Chromium), 2016/09/28 08:41:36]

optional nit: Perhaps call it Delegate instead of AddressNormalizationRequester.
While the latter is an implementation of the former, it might not be clear here
without looking at line 685.

[sebsg, 2016/09/28 16:15:25]

Done.

+    it->second->OnRulesSuccessfullyLoaded();
+    pending_normalization_.erase(it);
+  }
+}
+
+void PersonalDataManagerAndroid::StartAddressNormalizationTask(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& unused_obj,
+    const JavaParamRef<jstring>& jguid,
+    const JavaParamRef<jstring>& jregion_code,
+    const JavaParamRef<jobject>& jdelegate) {
+  std::string region_code = ConvertJavaStringToUTF8(env, jregion_code);

[vabr (Chromium), 2016/09/28 08:41:36]

optional: Mark both strings as const?

[sebsg, 2016/09/28 16:15:25]

Done.

+  std::string guid = ConvertJavaStringToUTF8(env, jguid);
+
+  Delegate* requester = new AddressNormalizationRequester(
+      env, jdelegate, region_code, guid, this);
+
+  // Check if the rules are already loaded.
+  if (AreRulesLoadedForRegion(region_code)) {
+    requester->OnRulesSuccessfullyLoaded();
+  } else {
+    // Setup the variables so the profile gets normalized when the rules have
+    // finished loading.
+    pending_normalization_.insert(
+        std::pair<std::string, Delegate*>(region_code, requester));
+  }
+}
+
+ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::NormalizeAddress(
+    const std::string& guid,
+    const std::string& region_code,
+    JNIEnv* env) {
+  AutofillProfile* profile = personal_data_manager_->GetProfileByGUID(guid);
+
+  if (!profile || !AreRulesLoadedForRegion(region_code))
+    return nullptr;
+
+  // 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)) {
+    // Set the normalized state, city and dependent locality.
+    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::CancelPendingAddressNormalization(JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& unused_obj) {
+  pending_normalization_.clear();
+}
+
 ScopedJavaLocalRef<jobjectArray> PersonalDataManagerAndroid::GetProfileGUIDs(
     JNIEnv* env,
     const std::vector<AutofillProfile*>& profiles) {
@@ -654,6 +782,11 @@ ScopedJavaLocalRef<jobjectArray> PersonalDataManagerAndroid::GetProfileLabels(
   return base::android::ToJavaArrayOfStrings(env, labels);
 }
 
+bool PersonalDataManagerAndroid::AreRulesLoadedForRegion(
+    const std::string& region_code) {
+  return address_validator_->AreRulesLoadedForRegion(region_code);
+}
+
 // Returns whether the Autofill feature is enabled.
 static jboolean IsAutofillEnabled(JNIEnv* env,
                                   const JavaParamRef<jclass>& clazz) {