Adds address normalization to iOS.

ios/chrome/browser/ui/payments/payment_request_manager.mm

 // Copyright 2016 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.
 
 #import "ios/chrome/browser/ui/payments/payment_request_manager.h"
 
 #include "base/ios/block_types.h"
 #include "base/ios/ios_util.h"
 #import "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #import "base/values.h"
+#include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_data_util.h"
 #include "components/autofill/core/browser/autofill_manager.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/ios/browser/autofill_driver_ios.h"
+#include "components/payments/core/address_normalization_manager.h"
+#include "components/payments/core/address_normalizer_impl.h"
 #include "components/payments/core/payment_address.h"
 #include "components/payments/core/payment_request_data_util.h"
 #include "ios/chrome/browser/application_context.h"
 #include "ios/chrome/browser/autofill/personal_data_manager_factory.h"
+#include "ios/chrome/browser/autofill/validation_rules_storage_factory.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/payments/payment_request.h"
 #include "ios/chrome/browser/procedural_block_types.h"
 #import "ios/chrome/browser/ui/commands/UIKit+ChromeExecuteCommand.h"
 #import "ios/chrome/browser/ui/commands/generic_chrome_command.h"
 #import "ios/chrome/browser/ui/commands/ios_command_ids.h"
 #import "ios/chrome/browser/ui/payments/js_payment_request_manager.h"
 #import "ios/chrome/browser/ui/payments/payment_request_coordinator.h"
 #include "ios/web/public/favicon_status.h"
 #include "ios/web/public/navigation_item.h"
 #include "ios/web/public/navigation_manager.h"
 #include "ios/web/public/payments/payment_request.h"
 #include "ios/web/public/ssl_status.h"
 #import "ios/web/public/url_scheme_util.h"
 #import "ios/web/public/web_state/js/crw_js_injection_receiver.h"
 #import "ios/web/public/web_state/ui/crw_web_view_proxy.h"
 #include "ios/web/public/web_state/url_verification_constants.h"
 #include "ios/web/public/web_state/web_state.h"
 #import "ios/web/public/web_state/web_state_observer_bridge.h"
+#include "third_party/libaddressinput/chromium/chrome_metadata_source.h"
+#include "third_party/libaddressinput/chromium/chrome_storage_impl.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
 namespace {
 
 // Command prefix for injected JavaScript.
 const char kCommandPrefix[] = "paymentRequest";
 
 // Time interval between attempts to unblock the webview's JS event queue.
 const NSTimeInterval kNoopInterval = 0.1;
 
 // Time interval before closing the UI if the page has not yet called
 // PaymentResponse.complete().
 const NSTimeInterval kTimeoutInterval = 60.0;
 
 NSString* kAbortMessage = @"The payment request was aborted.";
 NSString* kCancelMessage = @"The payment request was canceled.";
 
+struct FullCard {
+  autofill::CreditCard creditCard;
+  base::string16 verificationCode;
+  autofill::AutofillProfile billingAddress;
+};
+
 }  // namespace
 
 @interface PaymentRequestManager ()<CRWWebStateObserver,
                                     PaymentRequestCoordinatorDelegate> {
   // View controller used to present the PaymentRequest view controller.
   __weak UIViewController* _baseViewController;
 
   // PersonalDataManager used to manage user credit cards and addresses.
   autofill::PersonalDataManager* _personalDataManager;
 
@@ skipping 23 matching lines @@
   // Timer used to periodically unblock the webview's JS event queue.
   NSTimer* _unblockEventQueueTimer;
 
   // Timer used to complete the Payment Request flow and close the UI if the
   // page does not call PaymentResponse.complete() in a timely fashion.
   NSTimer* _paymentResponseTimeoutTimer;
 
   // Timer used to cancel the Payment Request flow and close the UI if the
   // page does not settle the pending update promise in a timely fashion.
   NSTimer* _updateEventTimeoutTimer;
+
+  // AddressNormalizationManager used to normalize the various addresses (e.g.
+  // shipping, contact, billing).
+  std::unique_ptr<payments::AddressNormalizationManager>
+      _addressNormalizationManager;
+
+  // Storage for the full card.
+  FullCard _fullCard;
 }
 
 // Object that manages JavaScript injection into the web view.
 @property(nonatomic, weak) JSPaymentRequestManager* paymentRequestJsManager;
 
 // Synchronous method executed by -asynchronouslyEnablePaymentRequest:
 - (void)doEnablePaymentRequest:(BOOL)enabled;
 
 // Terminates the pending request with an error message and dismisses the UI.
 // Invokes the callback once the request has been terminated.
@@ skipping 11 matching lines @@
 // Handles invocations of PaymentRequest.abort(). Returns YES if the invocation
 // was successful.
 - (BOOL)handleRequestAbort:(const base::DictionaryValue&)message;
 
 // Handles invocations of PaymentRequest.canMakePayment(). Returns YES if the
 // invocation was successful.
 - (BOOL)handleCanMakePayment:(const base::DictionaryValue&)message;
 
 // Called by |_updateEventTimeoutTimer|, displays an error message. Upon
 // dismissal of the error message, cancels the Payment Request as if it was
-// performend by the user.
+// performed by the user.
 - (BOOL)displayErrorThenCancelRequest;
 
 // Called by |_paymentResponseTimeoutTimer|, invokes handleResponseComplete:
 // as if PaymentResponse.complete() was invoked with the default "unknown"
 // argument.
 - (BOOL)doResponseComplete;
 
 // Handles invocations of PaymentResponse.complete(). Returns YES if the
 // invocation was successful.
 - (BOOL)handleResponseComplete:(const base::DictionaryValue&)message;
@@ skipping 13 matching lines @@
 // called with no arguments.
 - (void)setPaymentResponseTimeoutTimer;
 
 // Establishes a timer that dismisses the Payment Request UI when it times out.
 // Per the spec, implementations may choose to consider a timeout for the
 // promise provided with the PaymentRequestUpdateEvent.updateWith() call. If the
 // promise doesn't get settled in a reasonable amount of time, it is as if it
 // was rejected.
 - (void)setUpdateEventTimeoutTimer;
 
+// Called when the relevant addresses from a Payment Request have been
+// normalized. Resolves the request promise with a PaymentResponse.
+- (void)paymentRequestAddressNormalizationDidComplete;
+
 @end
 
 @implementation PaymentRequestManager
 
 @synthesize enabled = _enabled;
 @synthesize webState = _webState;
 @synthesize browserState = _browserState;
 @synthesize paymentRequestJsManager = _paymentRequestJsManager;
 
 - (instancetype)initWithBaseViewController:(UIViewController*)viewController
@@ skipping 133 matching lines @@
   }
   if (command == "paymentRequest.responseComplete") {
     return [self handleResponseComplete:JSONCommand];
   }
   if (command == "paymentRequest.updatePaymentDetails") {
     return [self handleUpdatePaymentDetails:JSONCommand];
   }
   return NO;
 }
 
+- (void)startAddressNormalizer {
+  autofill::PersonalDataManager* personalDataManager =
+      _paymentRequest->GetPersonalDataManager();
+
+  std::unique_ptr<i18n::addressinput::Source> addressNormalizerSource =
+      base::MakeUnique<autofill::ChromeMetadataSource>(
+          I18N_ADDRESS_VALIDATION_DATA_URL,
+          personalDataManager->GetURLRequestContextGetter());
+
+  std::unique_ptr<i18n::addressinput::Storage> addressNormalizerStorage =
+      autofill::ValidationRulesStorageFactory::CreateStorage();
+
+  std::unique_ptr<payments::AddressNormalizer> addressNormalizer =
+      base::MakeUnique<payments::AddressNormalizerImpl>(
+          std::move(addressNormalizerSource),
+          std::move(addressNormalizerStorage));
+
+  // Kickoff the process of loading the rules (which is asynchronous) for each
+  // profile's country, to get faster address normalization later.
+  for (const autofill::AutofillProfile* profile :
+       personalDataManager->GetProfilesToSuggest()) {
+    std::string countryCode =
+        base::UTF16ToUTF8(profile->GetRawInfo(autofill::ADDRESS_HOME_COUNTRY));
+    if (autofill::data_util::IsValidCountryCode(countryCode)) {
+      addressNormalizer->LoadRulesForRegion(countryCode);
+    }
+  }
+
+  const std::string default_country_code =
+      autofill::AutofillCountry::CountryCodeForLocale(
+          GetApplicationContext()->GetApplicationLocale());
+
+  _addressNormalizationManager =
+      base::MakeUnique<payments::AddressNormalizationManager>(
+          std::move(addressNormalizer), default_country_code);
+}
+
 // Ensures that |_paymentRequest| is set to the correct value for |message|.
 // Returns YES if |_paymentRequest| was already set to the right value, or if it
 // was updated to match |message|.
 - (BOOL)createPaymentRequestFromMessage:(const base::DictionaryValue&)message {
   const base::DictionaryValue* paymentRequestData;
   web::PaymentRequest webPaymentRequest;
   if (!message.GetDictionary("payment_request", &paymentRequestData)) {
     DLOG(ERROR) << "JS message parameter 'payment_request' is missing";
     return NO;
   }
@@ skipping 17 matching lines @@
 - (BOOL)handleRequestShow:(const base::DictionaryValue&)message {
   // TODO(crbug.com/602666): check that there's not already a pending request.
   // TODO(crbug.com/602666): compare our supported payment types (i.e. autofill
   //   credit card types) against the merchant supported types and return NO
   //   if the intersection is empty.
 
   if (![self createPaymentRequestFromMessage:message]) {
     return NO;
   }
 
+  [self startAddressNormalizer];
+
   UIImage* pageFavicon = nil;
   web::NavigationItem* navigationItem =
       [self webState]->GetNavigationManager()->GetVisibleItem();
   if (navigationItem && !navigationItem->GetFavicon().image.IsEmpty())
     pageFavicon = navigationItem->GetFavicon().image.ToUIImage();
   NSString* pageTitle = base::SysUTF16ToNSString([self webState]->GetTitle());
   NSString* pageHost =
       base::SysUTF8ToNSString([self webState]->GetLastCommittedURL().host());
   autofill::AutofillManager* autofillManager =
       autofill::AutofillDriverIOS::FromWebState(_webState)->autofill_manager();
@@ skipping 190 matching lines @@
     [mainWindow chromeExecuteCommand:command];
   };
 
   [self terminateRequestWithErrorMessage:kCancelMessage callback:callback];
 }
 
 - (void)paymentRequestCoordinator:(PaymentRequestCoordinator*)coordinator
         didCompletePaymentRequest:(PaymentRequest*)paymentRequest
                              card:(const autofill::CreditCard&)card
                  verificationCode:(const base::string16&)verificationCode {
-  web::PaymentResponse paymentResponse;
+  DCHECK_EQ(_paymentRequest.get(), paymentRequest);

[Moe, 2017/05/17 18:12:38]

nit: I prefer if |paymentRequest| wasn't part of the arguments because there's
only one instance circulating around. You could change the method signature to
something like the following without losing meaning:
-paymentRequestCoordinator:didCompletePaymentRequestWithCard:verificationCode:

[macourteau, 2017/05/17 19:15:16]

Done.

 
-  // If the merchant specified the card network as part of the "basic-card"
-  // payment method, return "basic-card" as the method_name. Otherwise, return
-  // the name of the network directly.
-  std::string issuer_network =
-      autofill::data_util::GetPaymentRequestData(card.network())
-          .basic_card_issuer_network;
-  paymentResponse.method_name =
-      paymentRequest->basic_card_specified_networks().find(issuer_network) !=
-              paymentRequest->basic_card_specified_networks().end()
-          ? base::ASCIIToUTF16("basic-card")
-          : base::ASCIIToUTF16(issuer_network);
-
-  // Get the billing address
-  autofill::AutofillProfile billingAddress;
+  _fullCard.creditCard = card;
+  _fullCard.verificationCode = verificationCode;
 
   // TODO(crbug.com/714768): Make sure the billing address is set and valid
   // before getting here. Once the bug is addressed, there will be no need to
   // copy the address, *billing_address_ptr can be used to get the basic card
   // response.
   if (!card.billing_address_id().empty()) {
     autofill::AutofillProfile* billingAddressPtr =
         autofill::PersonalDataManager::GetProfileFromProfilesByGUID(
             card.billing_address_id(), paymentRequest->billing_profiles());
-    if (billingAddressPtr)
-      billingAddress = *billingAddressPtr;
+    if (billingAddressPtr) {
+      _fullCard.billingAddress = *billingAddressPtr;
+      _addressNormalizationManager->StartNormalizingAddress(
+          &_fullCard.billingAddress);
+    }
   }
 
+  if (_paymentRequest->request_shipping()) {
+    _addressNormalizationManager->StartNormalizingAddress(
+        _paymentRequest->selected_shipping_profile());
+  }
+
+  _addressNormalizationManager->StartNormalizingAddress(
+      _paymentRequest->selected_contact_profile());
+
+  __weak PaymentRequestManager* weakSelf = self;
+  _addressNormalizationManager->FinalizeWithCompletionCallback(
+      base::BindBlockArc(^(const payments::AddressNormalizationManager&) {
+        [weakSelf paymentRequestAddressNormalizationDidComplete];
+      }));
+}
+
+- (void)paymentRequestAddressNormalizationDidComplete {
+  web::PaymentResponse paymentResponse;
+
+  // If the merchant specified the card network as part of the "basic-card"
+  // payment method, return "basic-card" as the method_name. Otherwise, return
+  // the name of the network directly.
+  std::string issuer_network =
+      autofill::data_util::GetPaymentRequestData(_fullCard.creditCard.network())
+          .basic_card_issuer_network;
+  paymentResponse.method_name =
+      _paymentRequest->basic_card_specified_networks().find(issuer_network) !=
+              _paymentRequest->basic_card_specified_networks().end()
+          ? base::ASCIIToUTF16("basic-card")
+          : base::ASCIIToUTF16(issuer_network);
+
   paymentResponse.details =
       payments::data_util::GetBasicCardResponseFromAutofillCreditCard(
-          card, verificationCode, billingAddress,
+          _fullCard.creditCard, _fullCard.verificationCode,
+          _fullCard.billingAddress,
           GetApplicationContext()->GetApplicationLocale());
 
-  if (paymentRequest->request_shipping()) {
+  if (_paymentRequest->request_shipping()) {
     autofill::AutofillProfile* shippingAddress =
-        paymentRequest->selected_shipping_profile();
+        _paymentRequest->selected_shipping_profile();
     // TODO(crbug.com/602666): User should get here only if they have selected
     // a shipping address.
     DCHECK(shippingAddress);
     paymentResponse.shipping_address =
         payments::data_util::GetPaymentAddressFromAutofillProfile(
             *shippingAddress, GetApplicationContext()->GetApplicationLocale());
 
     web::PaymentShippingOption* shippingOption =
-        paymentRequest->selected_shipping_option();
+        _paymentRequest->selected_shipping_option();
     DCHECK(shippingOption);
     paymentResponse.shipping_option = shippingOption->id;
   }
 
-  if (paymentRequest->request_payer_name()) {
+  if (_paymentRequest->request_payer_name()) {
     autofill::AutofillProfile* contactInfo =
-        paymentRequest->selected_contact_profile();
+        _paymentRequest->selected_contact_profile();
     // TODO(crbug.com/602666): User should get here only if they have selected
     // a contact info.
     DCHECK(contactInfo);
     paymentResponse.payer_name =
         contactInfo->GetInfo(autofill::AutofillType(autofill::NAME_FULL),
                              GetApplicationContext()->GetApplicationLocale());
   }
 
-  if (paymentRequest->request_payer_email()) {
+  if (_paymentRequest->request_payer_email()) {
     autofill::AutofillProfile* contactInfo =
-        paymentRequest->selected_contact_profile();
+        _paymentRequest->selected_contact_profile();
     // TODO(crbug.com/602666): User should get here only if they have selected
     // a contact info.
     DCHECK(contactInfo);
     paymentResponse.payer_email =
         contactInfo->GetRawInfo(autofill::EMAIL_ADDRESS);
   }
 
-  if (paymentRequest->request_payer_phone()) {
+  if (_paymentRequest->request_payer_phone()) {
     autofill::AutofillProfile* contactInfo =
-        paymentRequest->selected_contact_profile();
+        _paymentRequest->selected_contact_profile();
     // TODO(crbug.com/602666): User should get here only if they have selected
     // a contact info.
     DCHECK(contactInfo);
     paymentResponse.payer_phone =
         contactInfo->GetRawInfo(autofill::PHONE_HOME_WHOLE_NUMBER);
   }
 
   [_paymentRequestJsManager
       resolveRequestPromiseWithPaymentResponse:paymentResponse
                              completionHandler:nil];
@@ skipping 20 matching lines @@
 #pragma mark - CRWWebStateObserver methods
 
 - (void)webState:(web::WebState*)webState
     didCommitNavigationWithDetails:
         (const web::LoadCommittedDetails&)load_details {
   [self dismissUI];
   [self enableCurrentWebState];
 }
 
 @end