Pass active_chrome_experiments in 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>
 
@@ skipping 143 matching lines @@
   address->Set("postal_address", std::move(postal_address));
 
   if (include_non_location_data) {
     SetStringIfNotEmpty(profile, PHONE_HOME_WHOLE_NUMBER, app_locale,
                         PaymentsClient::kPhoneNumber, address.get());
   }
 
   return address;
 }
 
+// Populates the list of active experiments that affect either the data sent in
+// payments RPCs or whether the RPCs are sent or not.
+void SetActiveExperiments(const std::vector<const char*>& active_experiments,
+                          base::DictionaryValue* request_dict) {
+  if (active_experiments.empty())
+    return;
+
+  std::unique_ptr<base::ListValue> active_chrome_experiments(
+      base::MakeUnique<base::ListValue>());
+  for (const char* it : active_experiments)
+    active_chrome_experiments->AppendString(it);
+
+  request_dict->Set("active_chrome_experiments",
+                    std::move(active_chrome_experiments));
+}
+
 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() ||
         CreditCard::FULL_SERVER_CARD == request_details.card.record_type());
   }
   ~UnmaskCardRequest() override {}
 
@@ skipping 41 matching lines @@
   }
 
  private:
   PaymentsClient::UnmaskRequestDetails request_details_;
   std::string real_pan_;
 };
 
 class GetUploadDetailsRequest : public PaymentsRequest {
  public:
   GetUploadDetailsRequest(const std::vector<AutofillProfile>& addresses,
+                          const std::vector<const char*>& active_experiments,
                           const std::string& app_locale)
-      : addresses_(addresses), app_locale_(app_locale) {}
+      : addresses_(addresses),
+        active_experiments_(active_experiments),
+        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));
 
+    SetActiveExperiments(active_experiments_, &request_dict);
+
     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_;
+  const std::vector<AutofillProfile> addresses_;
+  const std::vector<const char*> active_experiments_;
   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 30 matching lines @@
     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);
     if (base::StringToInt(exp_month, &value))
       request_dict.SetInteger("expiration_month", value);
     if (base::StringToInt(exp_year, &value))
       request_dict.SetInteger("expiration_year", value);
 
+    SetActiveExperiments(request_details_.active_experiments, &request_dict);
+
     const base::string16 pan = request_details_.card.GetInfo(
         AutofillType(CREDIT_CARD_NUMBER), app_locale);
     std::string json_request;
     base::JSONWriter::Write(request_dict, &json_request);
     std::string request_content = base::StringPrintf(
         kUploadCardRequestFormat,
         net::EscapeUrlEncodedData(json_request, true).c_str(),
         net::EscapeUrlEncodedData(base::UTF16ToASCII(pan), true).c_str(),
         net::EscapeUrlEncodedData(base::UTF16ToASCII(request_details_.cvc),
                                   true)
             .c_str());
     VLOG(3) << "savecard request body: " << request_content;
     return request_content;
   }
 
   void ParseResponse(std::unique_ptr<base::DictionaryValue> response) override {
     response->GetString("credit_card_id", &server_id_);
   }
 
   bool IsResponseComplete() override { return true; }
 
   void RespondToDelegate(PaymentsClientDelegate* delegate,
                          AutofillClient::PaymentsRpcResult result) override {
     delegate->OnDidUploadCard(result, server_id_);
   }
 
  private:
-  PaymentsClient::UploadRequestDetails request_details_;
+  const PaymentsClient::UploadRequestDetails request_details_;
   std::string server_id_;
 };
 
 }  // namespace
 
 const char PaymentsClient::kRecipientName[] = "recipient_name";
 const char PaymentsClient::kPhoneNumber[] = "phone_number";
 
 PaymentsClient::UnmaskRequestDetails::UnmaskRequestDetails() {}
 PaymentsClient::UnmaskRequestDetails::~UnmaskRequestDetails() {}
@@ skipping 20 matching lines @@
     StartTokenFetch(false);
 }
 
 void PaymentsClient::UnmaskCard(
     const PaymentsClient::UnmaskRequestDetails& request_details) {
   IssueRequest(base::MakeUnique<UnmaskCardRequest>(request_details), true);
 }
 
 void PaymentsClient::GetUploadDetails(
     const std::vector<AutofillProfile>& addresses,
+    const std::vector<const char*>& active_experiments,
     const std::string& app_locale) {
-  IssueRequest(base::MakeUnique<GetUploadDetailsRequest>(addresses, app_locale),
+  IssueRequest(base::MakeUnique<GetUploadDetailsRequest>(
+                   addresses, active_experiments, app_locale),
                false);
 }
 
 void PaymentsClient::UploadCard(
     const PaymentsClient::UploadRequestDetails& request_details) {
   IssueRequest(base::MakeUnique<UploadCardRequest>(request_details), true);
 }
 
 void PaymentsClient::IssueRequest(std::unique_ptr<PaymentsRequest> request,
                                   bool authenticate) {
@@ skipping 181 matching lines @@
 
 void PaymentsClient::SetOAuth2TokenAndStartRequest() {
   url_fetcher_->AddExtraRequestHeader(net::HttpRequestHeaders::kAuthorization +
                                       std::string(": Bearer ") + access_token_);
 
   url_fetcher_->Start();
 }
 
 }  // namespace payments
 }  // namespace autofill