Make Wallet respect whether or not shipping address is required.

components/autofill/content/browser/wallet/wallet_client.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 "components/autofill/content/browser/wallet/wallet_client.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 213 matching lines @@
 const char kFeatureKey[] = "feature";
 const char kGoogleTransactionIdKey[] = "google_transaction_id";
 const char kInstrumentIdKey[] = "instrument_id";
 const char kInstrumentKey[] = "instrument";
 const char kInstrumentEscrowHandleKey[] = "instrument_escrow_handle";
 const char kInstrumentExpMonthKey[] = "instrument.credit_card.exp_month";
 const char kInstrumentExpYearKey[] = "instrument.credit_card.exp_year";
 const char kInstrumentType[] = "instrument.type";
 const char kInstrumentPhoneNumberKey[] = "instrument_phone_number";
 const char kMerchantDomainKey[] = "merchant_domain";
+const char kPhoneNumberRequired[] = "phone_number_required";
 const char kReasonKey[] = "reason";
 const char kRiskCapabilitiesKey[] = "supported_risk_challenge";
 const char kRiskParamsKey[] = "risk_params";
 const char kSelectedAddressIdKey[] = "selected_address_id";
 const char kSelectedInstrumentIdKey[] = "selected_instrument_id";
 const char kSessionMaterialKey[] = "session_material";
 const char kShippingAddressIdKey[] = "shipping_address_id";
 const char kShippingAddressKey[] = "shipping_address";
+const char kShippingAddressRequired[] = "shipping_address_required";
 const char kAutocheckoutStepsKey[] = "steps";
 const char kSuccessKey[] = "success";
 const char kUpgradedBillingAddressKey[] = "upgraded_billing_address";
 const char kUpgradedInstrumentIdKey[] = "upgraded_instrument_id";
+const char kUseMinimalAddresses[] = "use_minimal_addresses";
 
 }  // namespace
 
 WalletClient::FullWalletRequest::FullWalletRequest(
     const std::string& instrument_id,
     const std::string& address_id,
     const GURL& source_url,
     const std::string& google_transaction_id,
     const std::vector<RiskCapability> risk_capabilities)
     : instrument_id(instrument_id),
@@ skipping 72 matching lines @@
                                       full_wallet_request));
     return;
   }
 
   DCHECK_EQ(NO_PENDING_REQUEST, request_type_);
   request_type_ = GET_FULL_WALLET;
 
   base::DictionaryValue request_dict;
   request_dict.SetString(kApiKeyKey, google_apis::GetAPIKey());
   request_dict.SetString(kRiskParamsKey, delegate_->GetRiskData());
+  request_dict.SetBoolean(kUseMinimalAddresses,
+                          delegate_->IsMinimalAddressAccepted());
+  request_dict.SetBoolean(kPhoneNumberRequired,
+                          delegate_->IsPhoneNumberRequired());
+
   request_dict.SetString(kSelectedInstrumentIdKey,
                          full_wallet_request.instrument_id);
   request_dict.SetString(kSelectedAddressIdKey, full_wallet_request.address_id);
   request_dict.SetString(
       kMerchantDomainKey,
       full_wallet_request.source_url.GetWithEmptyPath().spec());
   request_dict.SetString(kGoogleTransactionIdKey,
                          full_wallet_request.google_transaction_id);
   request_dict.SetString(kFeatureKey,
                          DialogTypeToFeatureString(delegate_->GetDialogType()));
@@ skipping 39 matching lines @@
   }
 
   DCHECK_EQ(NO_PENDING_REQUEST, request_type_);
   request_type_ = SAVE_TO_WALLET;
 
   base::DictionaryValue request_dict;
   request_dict.SetString(kApiKeyKey, google_apis::GetAPIKey());
   request_dict.SetString(kRiskParamsKey, delegate_->GetRiskData());
   request_dict.SetString(kMerchantDomainKey,
                          source_url.GetWithEmptyPath().spec());
+  request_dict.SetBoolean(kUseMinimalAddresses,
+                          delegate_->IsMinimalAddressAccepted());
+  request_dict.SetBoolean(kPhoneNumberRequired,
+                          delegate_->IsPhoneNumberRequired());
 
   std::string primary_account_number;
   std::string card_verification_number;
   if (instrument) {
     primary_account_number = net::EscapeUrlEncodedData(
         UTF16ToUTF8(instrument->primary_account_number()), true);
     card_verification_number = net::EscapeUrlEncodedData(
         UTF16ToUTF8(instrument->card_verification_number()), true);
 
     if (instrument->object_id().empty()) {
@@ skipping 67 matching lines @@
     return;
   }
 
   DCHECK_EQ(NO_PENDING_REQUEST, request_type_);
   request_type_ = GET_WALLET_ITEMS;
 
   base::DictionaryValue request_dict;
   request_dict.SetString(kApiKeyKey, google_apis::GetAPIKey());
   request_dict.SetString(kMerchantDomainKey,
                          source_url.GetWithEmptyPath().spec());
+  request_dict.SetBoolean(kShippingAddressRequired,
+                          delegate_->IsShippingAddressRequired());
+  request_dict.SetBoolean(kUseMinimalAddresses,
+                          delegate_->IsMinimalAddressAccepted());
+  request_dict.SetBoolean(kPhoneNumberRequired,
+                          delegate_->IsPhoneNumberRequired());
 
   std::string post_body;
   base::JSONWriter::Write(&request_dict, &post_body);
 
   MakeWalletRequest(GetGetWalletItemsUrl(), post_body, kJsonMimeType);
 }
 
 void WalletClient::SendAutocheckoutStatus(
     AutocheckoutStatus status,
     const GURL& source_url,
@@ skipping 339 matching lines @@
       NOTREACHED();
       return AutofillMetrics::UNKNOWN_API_CALL;
   }
 
   NOTREACHED();
   return AutofillMetrics::UNKNOWN_API_CALL;
 }
 
 }  // namespace wallet
 }  // namespace autofill