[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/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 134 matching lines @@
       card->set_record_type(CreditCard::MASKED_SERVER_CARD);
       card->SetTypeForMaskedCard(
           data_util::GetCardTypeForBasicCardPaymentType(ConvertJavaStringToUTF8(
               env, Java_CreditCard_getBasicCardPaymentType(env, jcard))));
     }
   }
 }
 
 // Self-deleting requester of full card details, including full PAN and the CVC
 // number.
 class FullCardRequester : public payments::FullCardRequest::Delegate,

[please use gerrit instead, 2016/09/23 09:04:40]

Is it possible to use this pattern of self-deleting object?

[sebsg, 2016/09/27 18:48:38]

Done.

                           public base::SupportsWeakPtr<FullCardRequester> {
  public:
   FullCardRequester() {}
 
   // Takes ownership of |card|.
   void GetFullCard(JNIEnv* env,
                    const base::android::JavaParamRef<jobject>& jweb_contents,
                    const base::android::JavaParamRef<jobject>& jdelegate,
                    std::unique_ptr<CreditCard> card) {
     card_ = std::move(card);
@@ skipping 56 matching lines @@
 };
 
 }  // namespace
 
 PersonalDataManagerAndroid::PersonalDataManagerAndroid(JNIEnv* env,
                                                        jobject obj)
     : weak_java_obj_(env, obj),
       personal_data_manager_(PersonalDataManagerFactory::GetForProfile(
           ProfileManager::GetActiveUserProfile())) {
   personal_data_manager_->AddObserver(this);
+
+  address_validator_.reset(new AddressValidator(
+      std::unique_ptr<::i18n::addressinput::Source>(
+          new autofill::ChromeMetadataSource(
+              I18N_ADDRESS_VALIDATION_DATA_URL,
+              personal_data_manager_->GetURLRequestContextGetter())),
+      ValidationRulesStorageFactory::CreateStorage(), this));
 }
 
 PersonalDataManagerAndroid::~PersonalDataManagerAndroid() {
   personal_data_manager_->RemoveObserver(this);
 }
 
 jboolean PersonalDataManagerAndroid::IsDataLoaded(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& unused_obj) const {
   return personal_data_manager_->IsDataLoaded();
@@ skipping 310 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::StartAddressNormalizationTask(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& unused_obj,
+    const JavaParamRef<jstring>& jguid,
+    const JavaParamRef<jstring>& jregion_code) {
+  std::string region_code = ConvertJavaStringToUTF8(env, jregion_code);
+
+  // Check if the rules are already done loading.
+  if (AreRulesDoneLoadingForRegion(region_code)) {
+    NormalizeAddress(ConvertJavaStringToUTF8(env, jguid), region_code);
+  } else {
+    // Setup the variables so the profile gets normalized when the rules have
+    // finished loading.
+    pending_normalization_profile_guid_ = ConvertJavaStringToUTF8(env, jguid);
+    pending_normalization_region_code_ = region_code;
+  }
+}
+
+void PersonalDataManagerAndroid::CancelAddressNormalizationTask(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& unused_obj) {
+  pending_normalization_profile_guid_ = "";

[please use gerrit instead, 2016/09/23 09:04:40]

pending_normalization_profile_guid_.clear();

[sebsg, 2016/09/27 18:48:38]

Done.

+  pending_normalization_region_code_ = "";

[please use gerrit instead, 2016/09/23 09:04:40]

pending_normalization_region_code_.clear();

[sebsg, 2016/09/27 18:48:38]

Done.

+}
+
+void PersonalDataManagerAndroid::NormalizeAddress(std::string guid,
+                                                  std::string region_code) {
+  AutofillProfile* profile = personal_data_manager_->GetProfileByGUID(guid);
+
+  if (!profile || !AreRulesDoneLoadingForRegion(region_code) ||
+      !AreRulesSuccessfullyLoadedForRegion(region_code))
+    return;
+
+  // 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));
+  }
+
+  JNIEnv* env = base::android::AttachCurrentThread();
+  if (weak_java_obj_.get(env).is_null())
+    return;
+
+  Java_PersonalDataManager_onAddressNormalized(
+      env, weak_java_obj_.get(env), CreateJavaProfileFromNative(env, *profile));
+}
+
+void PersonalDataManagerAndroid::OnAddressValidationRulesLoaded(
+    const std::string& region_code,
+    bool success) {
+  loaded_rules_[region_code] = success;
+
+  // Check if an address normalization is pending.
+  if (pending_normalization_profile_guid_ != "" &&

[please use gerrit instead, 2016/09/23 09:04:40]

!pending_normalization_profile_guid_.empty()

[sebsg, 2016/09/27 18:48:38]

Done.

+      pending_normalization_region_code_ != "") {

[please use gerrit instead, 2016/09/23 09:04:40]

!pending_normalization_region_code_.empty()

[sebsg, 2016/09/27 18:48:38]

Done.

+    NormalizeAddress(pending_normalization_profile_guid_,
+                     pending_normalization_region_code_);
+    pending_normalization_profile_guid_ = "";

[please use gerrit instead, 2016/09/23 09:04:40]

.clear()

[sebsg, 2016/09/27 18:48:38]

Done.

+    pending_normalization_region_code_ = "";

[please use gerrit instead, 2016/09/23 09:04:40]

.clear()

[sebsg, 2016/09/27 18:48:38]

Done.

+  }
+}
+
 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::AreRulesDoneLoadingForRegion(
+    std::string region_code) {
+  return loaded_rules_.find(region_code) != loaded_rules_.end();
+}
+
+bool PersonalDataManagerAndroid::AreRulesSuccessfullyLoadedForRegion(
+    std::string region_code) {
+  std::map<std::string, bool>::iterator it = loaded_rules_.find(region_code);
+  return it != loaded_rules_.end() ? it->second : false;
+}
+
 // 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