Include addresses with the getdetailsforsavecard Payments RPC.

components/autofill/core/browser/payments/payments_client.cc

 // Copyright 2015 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/autofill/core/browser/payments/payments_client.h"
 
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 84 matching lines @@
 
 void AppendStringIfNotEmpty(const AutofillProfile& profile,
                             const ServerFieldType& type,
                             const std::string& app_locale,
                             base::ListValue* list) {
   const base::string16 value = profile.GetInfo(AutofillType(type), app_locale);
   if (!value.empty())
     list->AppendString(value);
 }
 
+// Returns a dictionary with the structure expected by Payments RPCs, containing
+// each of the fields in |profile|, formatted according to |app_locale|. If
+// |include_non_location_data| is false, the name and phone number in |profile|
+// are not included.
 std::unique_ptr<base::DictionaryValue> BuildAddressDictionary(
     const AutofillProfile& profile,
-    const std::string& app_locale) {
+    const std::string& app_locale,
+    bool include_non_location_data) {
   std::unique_ptr<base::DictionaryValue> postal_address(
       new base::DictionaryValue());
 
-  SetStringIfNotEmpty(profile, NAME_FULL, app_locale, "recipient_name",
-                      postal_address.get());
+  if (include_non_location_data) {
+    SetStringIfNotEmpty(profile, NAME_FULL, app_locale,
+                        PaymentsClient::kRecipientName, postal_address.get());
+  }
 
   std::unique_ptr<base::ListValue> address_lines(new base::ListValue());
   AppendStringIfNotEmpty(profile, ADDRESS_HOME_LINE1, app_locale,
                          address_lines.get());
   AppendStringIfNotEmpty(profile, ADDRESS_HOME_LINE2, app_locale,
                          address_lines.get());
   AppendStringIfNotEmpty(profile, ADDRESS_HOME_LINE3, app_locale,
                          address_lines.get());
   if (!address_lines->empty())
     postal_address->Set("address_line", std::move(address_lines));
 
   SetStringIfNotEmpty(profile, ADDRESS_HOME_CITY, app_locale, "locality_name",
                       postal_address.get());
   SetStringIfNotEmpty(profile, ADDRESS_HOME_STATE, app_locale,
                       "administrative_area_name", postal_address.get());
   SetStringIfNotEmpty(profile, ADDRESS_HOME_ZIP, app_locale,
                       "postal_code_number", postal_address.get());
 
   // Use GetRawInfo to get a country code instead of the country name:
   const base::string16 country_code = profile.GetRawInfo(ADDRESS_HOME_COUNTRY);
   if (!country_code.empty())
     postal_address->SetString("country_name_code", country_code);
 
   std::unique_ptr<base::DictionaryValue> address(new base::DictionaryValue());
   address->Set("postal_address", std::move(postal_address));
-  SetStringIfNotEmpty(profile, PHONE_HOME_WHOLE_NUMBER, app_locale,
-                      "phone_number", address.get());
+
+  if (include_non_location_data) {
+    SetStringIfNotEmpty(profile, PHONE_HOME_WHOLE_NUMBER, app_locale,
+                        PaymentsClient::kPhoneNumber, address.get());
+  }
 
   return address;
 }
 
 class UnmaskCardRequest : public PaymentsRequest {
  public:
   UnmaskCardRequest(const PaymentsClient::UnmaskRequestDetails& request_details)
       : request_details_(request_details) {
     DCHECK(
         CreditCard::MASKED_SERVER_CARD == request_details.card.record_type() ||
@@ skipping 44 matching lines @@
     delegate->OnDidGetRealPan(result, real_pan_);
   }
 
  private:
   PaymentsClient::UnmaskRequestDetails request_details_;
   std::string real_pan_;
 };
 
 class GetUploadDetailsRequest : public PaymentsRequest {
  public:
-  GetUploadDetailsRequest(const std::string& app_locale)
-      : app_locale_(app_locale) {}
+  GetUploadDetailsRequest(const std::vector<AutofillProfile>& addresses,
+                          const std::string& app_locale)
+      : addresses_(addresses), app_locale_(app_locale) {}
   ~GetUploadDetailsRequest() override {}
 
   std::string GetRequestUrlPath() override {
     return kGetUploadDetailsRequestPath;
   }
 
   std::string GetRequestContentType() override { return "application/json"; }
 
   std::string GetRequestContent() override {
     base::DictionaryValue request_dict;
     std::unique_ptr<base::DictionaryValue> context(new base::DictionaryValue());
     context->SetString("language_code", app_locale_);
     request_dict.Set("context", std::move(context));
 
+    std::unique_ptr<base::ListValue> addresses(new base::ListValue());
+    for (const AutofillProfile& profile : addresses_) {
+      // These addresses are used by Payments to (1) accurately determine the
+      // user's country in order to show the correct legal documents and (2) to
+      // verify that the addresses are valid for their purposes so that we don't
+      // offer save in a case where it would definitely fail (e.g. P.O. boxes).
+      // The final parameter directs BuildAddressDictionary to omit names and
+      // phone numbers, which aren't useful for these purposes.
+      addresses->Append(BuildAddressDictionary(profile, app_locale_, false));
+    }
+    request_dict.Set("address", std::move(addresses));
+
     std::string request_content;
     base::JSONWriter::Write(request_dict, &request_content);
     VLOG(3) << "getdetailsforsavecard request body: " << request_content;
     return request_content;
   }
 
   void ParseResponse(std::unique_ptr<base::DictionaryValue> response) override {
     response->GetString("context_token", &context_token_);
     base::DictionaryValue* unowned_legal_message;
     if (response->GetDictionary("legal_message", &unowned_legal_message))
       legal_message_ = unowned_legal_message->CreateDeepCopy();
   }
 
   bool IsResponseComplete() override {
     return !context_token_.empty() && legal_message_;
   }
 
   void RespondToDelegate(PaymentsClientDelegate* delegate,
                          AutofillClient::PaymentsRpcResult result) override {
     delegate->OnDidGetUploadDetails(result, context_token_,
                                     std::move(legal_message_));
   }
 
  private:
+  std::vector<AutofillProfile> addresses_;
   std::string app_locale_;
   base::string16 context_token_;
   std::unique_ptr<base::DictionaryValue> legal_message_;
 };
 
 class UploadCardRequest : public PaymentsRequest {
  public:
   UploadCardRequest(const PaymentsClient::UploadRequestDetails& request_details)
       : request_details_(request_details) {}
   ~UploadCardRequest() override {}
@@ skipping 14 matching lines @@
     const std::string& app_locale = request_details_.app_locale;
     std::unique_ptr<base::DictionaryValue> context(new base::DictionaryValue());
     context->SetString("language_code", app_locale);
     request_dict.Set("context", std::move(context));
 
     SetStringIfNotEmpty(request_details_.card, CREDIT_CARD_NAME_FULL,
                         app_locale, "cardholder_name", &request_dict);
 
     std::unique_ptr<base::ListValue> addresses(new base::ListValue());
     for (const AutofillProfile& profile : request_details_.profiles) {
-      addresses->Append(BuildAddressDictionary(profile, app_locale));
+      addresses->Append(BuildAddressDictionary(profile, app_locale, true));
     }
     request_dict.Set("address", std::move(addresses));
 
     request_dict.SetString("context_token", request_details_.context_token);
 
     int value = 0;
     const base::string16 exp_month = request_details_.card.GetInfo(
         AutofillType(CREDIT_CARD_EXP_MONTH), app_locale);
     const base::string16 exp_year = request_details_.card.GetInfo(
         AutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR), app_locale);
@@ skipping 26 matching lines @@
                          AutofillClient::PaymentsRpcResult result) override {
     delegate->OnDidUploadCard(result);
   }
 
  private:
   PaymentsClient::UploadRequestDetails request_details_;
 };
 
 }  // namespace
 
+const char PaymentsClient::kRecipientName[] = "recipient_name";
+const char PaymentsClient::kPhoneNumber[] = "phone_number";
+
 PaymentsClient::UnmaskRequestDetails::UnmaskRequestDetails() {}
 PaymentsClient::UnmaskRequestDetails::~UnmaskRequestDetails() {}
 
 PaymentsClient::UploadRequestDetails::UploadRequestDetails() {}
 PaymentsClient::UploadRequestDetails::UploadRequestDetails(
     const UploadRequestDetails& other) = default;
 PaymentsClient::UploadRequestDetails::~UploadRequestDetails() {}
 
 PaymentsClient::PaymentsClient(net::URLRequestContextGetter* context_getter,
                                PaymentsClientDelegate* delegate)
@@ skipping 10 matching lines @@
 void PaymentsClient::Prepare() {
   if (access_token_.empty())
     StartTokenFetch(false);
 }
 
 void PaymentsClient::UnmaskCard(
     const PaymentsClient::UnmaskRequestDetails& request_details) {
   IssueRequest(base::WrapUnique(new UnmaskCardRequest(request_details)), true);
 }
 
-void PaymentsClient::GetUploadDetails(const std::string& app_locale) {
-  IssueRequest(base::WrapUnique(new GetUploadDetailsRequest(app_locale)),
+void PaymentsClient::GetUploadDetails(
+    const std::vector<AutofillProfile>& addresses,
+    const std::string& app_locale) {
+  IssueRequest(base::WrapUnique(new GetUploadDetailsRequest(addresses, app_locale)),
                false);
 }
 
 void PaymentsClient::UploadCard(
     const PaymentsClient::UploadRequestDetails& request_details) {
   IssueRequest(base::WrapUnique(new UploadCardRequest(request_details)), true);
 }
 
 void PaymentsClient::IssueRequest(std::unique_ptr<PaymentsRequest> request,
                                   bool authenticate) {
@@ skipping 146 matching lines @@
 
 void PaymentsClient::SetOAuth2TokenAndStartRequest() {
   url_fetcher_->AddExtraRequestHeader(net::HttpRequestHeaders::kAuthorization +
                                       std::string(": Bearer ") + access_token_);
 
   url_fetcher_->Start();
 }
 
 }  // namespace payments
 }  // namespace autofill