[Payments] Move PersonalDataManager and locale to PaymentRequestState

components/payments/content/payment_request_state.cc

 // 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.
 
 #include "components/payments/content/payment_request_state.h"
 
 #include "components/autofill/core/browser/autofill_data_util.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/credit_card.h"
+#include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/payments/content/payment_request_spec.h"
 #include "components/payments/core/autofill_payment_instrument.h"
 
 namespace payments {
 
 namespace {
 // Identifier for the basic card payment method in the PaymentMethodData.
 static const char* const kBasicCardMethodName = "basic-card";
 }  // namespace
 
-PaymentRequestState::PaymentRequestState(PaymentRequestSpec* spec,
-                                         Delegate* delegate)
+PaymentRequestState::PaymentRequestState(
+    PaymentRequestSpec* spec,
+    Delegate* delegate,
+    const std::string& app_locale,
+    autofill::PersonalDataManager* personal_data_manager)
     : is_ready_to_pay_(false),
+      app_locale_(app_locale),
       spec_(spec),
       delegate_(delegate),
+      personal_data_manager_(personal_data_manager),
       selected_shipping_profile_(nullptr),
       selected_contact_profile_(nullptr),
       selected_credit_card_(nullptr),
       selected_shipping_option_(nullptr) {
   PopulateProfileCache();
   UpdateSelectedShippingOption();
   SetDefaultProfileSelections();
 }
 
 void PaymentRequestState::AddObserver(Observer* observer) {
@@ skipping 17 matching lines @@
   delegate_->OnPaymentResponseAvailable(std::move(payment_response));
 }
 
 void PaymentRequestState::GeneratePaymentResponse() {
   // TODO(mathp): PaymentRequest should know about the currently selected
   // instrument, and not |selected_credit_card_| which is too specific.
   // TODO(mathp): The method_name should reflect what the merchant asked, and
   // not necessarily basic-card.
   selected_payment_instrument_.reset(new AutofillPaymentInstrument(
       kBasicCardMethodName, *selected_credit_card_, shipping_profiles_,
-      delegate_->GetApplicationLocale()));
+      app_locale_));
   // Fetch the instrument details, will call back into
   // PaymentRequest::OnInstrumentsDetailsReady.
   selected_payment_instrument_->InvokePaymentApp(this);
 }
 
 void PaymentRequestState::SetSelectedShippingProfile(
     autofill::AutofillProfile* profile) {
   selected_shipping_profile_ = profile;
   UpdateIsReadyToPayAndNotifyObservers();
 }
 
 void PaymentRequestState::SetSelectedContactProfile(
     autofill::AutofillProfile* profile) {
   selected_contact_profile_ = profile;
   UpdateIsReadyToPayAndNotifyObservers();
 }
 
 void PaymentRequestState::SetSelectedCreditCard(autofill::CreditCard* card) {
   selected_credit_card_ = card;
   UpdateIsReadyToPayAndNotifyObservers();
 }
 
+const std::string& PaymentRequestState::GetApplicationLocale() {
+  return app_locale_;
+}
+
+autofill::PersonalDataManager* PaymentRequestState::GetPersonalDataManager() {
+  return personal_data_manager_;
+}
+
 void PaymentRequestState::PopulateProfileCache() {
-  autofill::PersonalDataManager* personal_data_manager =
-      delegate_->GetPersonalDataManager();
-  DCHECK(personal_data_manager);
   std::vector<autofill::AutofillProfile*> profiles =
-      personal_data_manager->GetProfilesToSuggest();
+      personal_data_manager_->GetProfilesToSuggest();
 
   // PaymentRequest may outlive the Profiles returned by the Data Manager.
   // Thus, we store copies, and return a vector of pointers to these copies
   // whenever Profiles are requested. The same is true for credit cards.
   for (size_t i = 0; i < profiles.size(); i++) {
     profile_cache_.push_back(
         base::MakeUnique<autofill::AutofillProfile>(*profiles[i]));
 
     // TODO(tmartino): Implement deduplication rules specific to shipping and
     // contact profiles.
     shipping_profiles_.push_back(profile_cache_[i].get());
     contact_profiles_.push_back(profile_cache_[i].get());
   }
 
   const std::vector<autofill::CreditCard*>& cards =
-      personal_data_manager->GetCreditCardsToSuggest();
+      personal_data_manager_->GetCreditCardsToSuggest();
   for (autofill::CreditCard* card : cards) {
     card_cache_.push_back(base::MakeUnique<autofill::CreditCard>(*card));
     credit_cards_.push_back(card_cache_.back().get());
   }
 }
 
 void PaymentRequestState::SetDefaultProfileSelections() {
   if (!shipping_profiles().empty())
     selected_shipping_profile_ = shipping_profiles()[0];
 
@@ skipping 38 matching lines @@
                    basic_card_payment_type) !=
              spec_->supported_card_networks().end();
 }
 
 bool PaymentRequestState::ArePaymentOptionsSatisfied() {
   // TODO(mathp): Have a measure of shipping address completeness.
   if (spec_->request_shipping() && selected_shipping_profile_ == nullptr)
     return false;
 
   // TODO(mathp): Make an encompassing class to validate contact info.
-  const std::string& app_locale = delegate_->GetApplicationLocale();
   if (spec_->request_payer_name() &&
       (selected_contact_profile_ == nullptr ||
        selected_contact_profile_
-           ->GetInfo(autofill::AutofillType(autofill::NAME_FULL), app_locale)
+           ->GetInfo(autofill::AutofillType(autofill::NAME_FULL), app_locale_)
            .empty())) {
     return false;
   }
   if (spec_->request_payer_email() &&
       (selected_contact_profile_ == nullptr ||
        selected_contact_profile_
            ->GetInfo(autofill::AutofillType(autofill::EMAIL_ADDRESS),
-                     app_locale)
+                     app_locale_)
            .empty())) {
     return false;
   }
   if (spec_->request_payer_phone() &&
       (selected_contact_profile_ == nullptr ||
        selected_contact_profile_
            ->GetInfo(autofill::AutofillType(autofill::PHONE_HOME_WHOLE_NUMBER),
-                     app_locale)
+                     app_locale_)
            .empty())) {
     return false;
   }
 
   return true;
 }
 
 void PaymentRequestState::UpdateSelectedShippingOption() {
   selected_shipping_option_ = nullptr;
 
   // As per the spec, the selected shipping option should initially be the last
   // one in the array that has its selected field set to true.
   auto selected_shipping_option_it = std::find_if(
       spec_->details().shipping_options.rbegin(),
       spec_->details().shipping_options.rend(),
       [](const payments::mojom::PaymentShippingOptionPtr& element) {
         return element->selected;
       });
   if (selected_shipping_option_it != spec_->details().shipping_options.rend()) {
     selected_shipping_option_ = selected_shipping_option_it->get();
   }
 }
 
 }  // namespace payments