Reland: Normalize shipping address for merchant on Desktop.

components/payments/core/address_normalizer_impl.cc

 // Copyright 2017 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 "components/payments/core/address_normalizer.h"
+#include "components/payments/core/address_normalizer_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/cancelable_callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 100 matching lines @@
   autofill::AddressValidator* address_validator_;
 
   bool has_responded_;
   base::CancelableCallback<void()> on_timeout_;
 
   DISALLOW_COPY_AND_ASSIGN(AddressNormalizationRequest);
 };
 
 }  // namespace
 
-AddressNormalizer::AddressNormalizer(std::unique_ptr<Source> source,
-                                     std::unique_ptr<Storage> storage)
+AddressNormalizerImpl::AddressNormalizerImpl(std::unique_ptr<Source> source,
+                                             std::unique_ptr<Storage> storage)
     : address_validator_(std::move(source), std::move(storage), this) {}
 
-AddressNormalizer::~AddressNormalizer() {}
+AddressNormalizerImpl::~AddressNormalizerImpl() {}
 
-void AddressNormalizer::LoadRulesForRegion(const std::string& region_code) {
+void AddressNormalizerImpl::LoadRulesForRegion(const std::string& region_code) {
   address_validator_.LoadRules(region_code);
 }
 
-bool AddressNormalizer::AreRulesLoadedForRegion(
+bool AddressNormalizerImpl::AreRulesLoadedForRegion(
     const std::string& region_code) {
   return address_validator_.AreRulesLoadedForRegion(region_code);
 }
 
-void AddressNormalizer::StartAddressNormalization(
+void AddressNormalizerImpl::StartAddressNormalization(
     const AutofillProfile& profile,
     const std::string& region_code,
     int timeout_seconds,
     AddressNormalizer::Delegate* requester) {
   DCHECK(timeout_seconds >= 0);
 
   std::unique_ptr<AddressNormalizationRequest> request(
       base::MakeUnique<AddressNormalizationRequest>(profile, region_code,
                                                     timeout_seconds, requester,
                                                     &address_validator_));
@@ skipping 14 matching lines @@
     }
 
     it->second.push_back(std::move(request));
 
     // Start loading the rules for that region. If the rules were already in the
     // process of being loaded, this call will do nothing.
     LoadRulesForRegion(region_code);
   }
 }
 
-void AddressNormalizer::OnAddressValidationRulesLoaded(
+void AddressNormalizerImpl::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]->OnRulesLoaded(success);
     }
     pending_normalization_.erase(it);
   }
 }
 
 }  // namespace payments