[Payments] Normalize addresses before passing them to merchants.

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/memory/weak_ptr.h"
 #include "base/strings/stringprintf.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/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 203 matching lines @@
     Java_FullCardRequestDelegate_onFullCardError(env, jdelegate_);
     delete this;
   }
 
   std::unique_ptr<CreditCard> card_;
   ScopedJavaGlobalRef<jobject> jdelegate_;
 
   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_) {

[gone, 2016/09/28 18:04:31]

The only place the personal_data_manager_android_ seems to be set is in the
constructor.  If it's null before this thing is created, does this object need
to be created at all?  Did you mean to hold a weak pointer here, instead?

[sebsg, 2016/09/28 18:50:39]

Done.

+      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,
-                                                       jobject obj)
+PersonalDataManagerAndroid::PersonalDataManagerAndroid(JNIEnv* env, jobject obj)
     : weak_java_obj_(env, obj),
       personal_data_manager_(PersonalDataManagerFactory::GetForProfile(
-          ProfileManager::GetActiveUserProfile())) {
+          ProfileManager::GetActiveUserProfile())),
+      address_validator_(
+          std::unique_ptr<::i18n::addressinput::Source>(
+              new autofill::ChromeMetadataSource(
+                  I18N_ADDRESS_VALIDATION_DATA_URL,
+                  personal_data_manager_->GetURLRequestContextGetter())),
+          ValidationRulesStorageFactory::CreateStorage(),
+          this) {
   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 311 matching lines @@
   return card->use_date().ToTimeT();
 }
 
 // TODO(crbug.com/629507): Use a mock clock for testing.
 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));
+}
+
+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 Delegate will self delete after normalizing.
+    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) {
+  const std::string region_code = ConvertJavaStringToUTF8(env, jregion_code);
+  const 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.

[gone, 2016/09/28 18:04:31]

Don't know if this comment's too helpful; seems pretty obvious from the lines
below.

[sebsg, 2016/09/28 18:50:39]

Done.

+    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) {
   std::vector<base::string16> guids;
   for (AutofillProfile* profile : profiles)
     guids.push_back(base::UTF8ToUTF16(profile->guid()));
 
   return base::android::ToJavaArrayOfStrings(env, guids);
 }
 
@@ skipping 33 matching lines @@
   ServerFieldType excluded_field = include_name ? UNKNOWN_TYPE : NAME_FULL;
 
   std::vector<base::string16> labels;
   AutofillProfile::CreateInferredLabels(
       profiles, suggested_fields.get(), excluded_field, minimal_fields_shown,
       g_browser_process->GetApplicationLocale(), &labels);
 
   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) {
   return GetPrefs()->GetBoolean(autofill::prefs::kAutofillEnabled);
 }
 
 // Enables or disables the Autofill feature.
 static void SetAutofillEnabled(JNIEnv* env,
                                const JavaParamRef<jclass>& clazz,
                                jboolean enable) {
@@ skipping 31 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