Pass active_chrome_experiments in payments RPC.

components/autofill/core/browser/autofill_manager.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/core/browser/autofill_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1267 matching lines @@
         }
       } else if (is_valid_cvc &&
                  field->Type().GetStorableType() == UNKNOWN_TYPE) {
         found_cvc_value_in_non_cvc_field_ = true;
       }
     }
 
     // Upload requires that recently used or modified addresses meet the
     // client-side validation rules.
     std::string rappor_metric_name;
-    int upload_decision_metrics = GetProfilesForCreditCardUpload(
-        *imported_credit_card, &upload_request_.profiles, &rappor_metric_name);
+    int upload_decision_metrics = SetProfilesForCreditCardUpload(
+        *imported_credit_card, &upload_request_, &rappor_metric_name);
 
     pending_upload_request_url_ = GURL(submitted_form.source_url());
 
     should_cvc_be_requested_ = false;
     if (upload_request_.cvc.empty()) {
       should_cvc_be_requested_ =
           (!upload_decision_metrics &&
            IsAutofillUpstreamRequestCvcIfMissingExperimentEnabled());
-      if (!should_cvc_be_requested_) {
+      if (should_cvc_be_requested_) {
+        upload_request_.active_experiments.push_back(
+            kAutofillUpstreamRequestCvcIfMissing.name);
+      } else {
         upload_decision_metrics |= GetCVCCardUploadDecisionMetric();
         rappor_metric_name = "Autofill.CardUploadNotOfferedNoCvc";
       }
     }
     if (upload_decision_metrics) {
       LogCardUploadDecisions(upload_decision_metrics);
       pending_upload_request_url_ = GURL();
       if (!rappor_metric_name.empty()) {
         CollectRapporSample(submitted_form.source_url(), rappor_metric_name);
       }
       return;
     }
 
     // All required data is available, start the upload process.
-    payments_client_->GetUploadDetails(upload_request_.profiles, app_locale_);
+    payments_client_->GetUploadDetails(upload_request_.profiles,
+                                       upload_request_.active_experiments,
+                                       app_locale_);
   }
 }
 
 AutofillMetrics::CardUploadDecisionMetric
 AutofillManager::GetCVCCardUploadDecisionMetric() const {
   if (found_cvc_field_)
     return found_value_in_cvc_field_ ? AutofillMetrics::INVALID_CVC_VALUE
                                      : AutofillMetrics::CVC_VALUE_NOT_FOUND;
   else
     return found_cvc_value_in_non_cvc_field_
                ? AutofillMetrics::FOUND_POSSIBLE_CVC_VALUE_IN_NON_CVC_FIELD
                : AutofillMetrics::CVC_FIELD_NOT_FOUND;
 }
 
-int AutofillManager::GetProfilesForCreditCardUpload(
+int AutofillManager::SetProfilesForCreditCardUpload(
     const CreditCard& card,
-    std::vector<AutofillProfile>* profiles,
+    payments::PaymentsClient::UploadRequestDetails* upload_request,
     std::string* rappor_metric_name) const {
   std::vector<AutofillProfile> candidate_profiles;
   const base::Time now = AutofillClock::Now();
   const base::TimeDelta fifteen_minutes = base::TimeDelta::FromMinutes(15);
   int upload_decision_metrics = 0;
   bool has_profile = false;
   bool has_modified_profile = false;
 
   // First, collect all of the addresses used or modified recently.
   for (AutofillProfile* profile : personal_data_->GetProfiles()) {
     has_profile = true;
     if ((now - profile->modification_date()) < fifteen_minutes) {
       has_modified_profile = true;
       candidate_profiles.push_back(*profile);
     } else if ((now - profile->use_date()) < fifteen_minutes) {
       candidate_profiles.push_back(*profile);
     }
   }
 
   AutofillMetrics::LogHasModifiedProfileOnCreditCardFormSubmission(
       has_modified_profile);
 
   // If there are no recently used or modified profiles and experiment to use
   // profiles that were not recently is enabled, collect the profiles that were
   // not recently used but used within the maximum time specified in the
   // experiment.
   if (candidate_profiles.empty()) {
     const base::TimeDelta max_time_since_use =
         GetMaxTimeSinceAutofillProfileUseForCardUpload();
-    if (!max_time_since_use.is_zero())
+    if (!max_time_since_use.is_zero()) {
       for (AutofillProfile* profile : personal_data_->GetProfiles())
         if ((now - profile->modification_date()) < max_time_since_use ||
             (now - profile->use_date()) < max_time_since_use)
           candidate_profiles.push_back(*profile);
+      if (!candidate_profiles.empty())
+        upload_request->active_experiments.push_back(
+            kAutofillUpstreamUseNotRecentlyUsedAutofillProfile.name);
+    }
   }
 
   if (candidate_profiles.empty()) {
     upload_decision_metrics |=
         has_profile
             ? AutofillMetrics::UPLOAD_NOT_OFFERED_NO_RECENTLY_USED_ADDRESS
             : AutofillMetrics::UPLOAD_NOT_OFFERED_NO_ADDRESS_PROFILE;
     *rappor_metric_name = "Autofill.CardUploadNotOfferedNoAddress";
   }
 
   // If any of the names on the card or the addresses don't match the
   // candidate set is invalid. This matches the rules for name matching applied
   // server-side by Google Payments and ensures that we don't send upload
   // requests that are guaranteed to fail.
   const base::string16 card_name =
       card.GetInfo(AutofillType(CREDIT_CARD_NAME_FULL), app_locale_);
   base::string16 verified_name;
   if (candidate_profiles.empty()) {
     verified_name = card_name;
   } else {
     bool found_conflicting_names = false;
     if (base::FeatureList::IsEnabled(
             kAutofillUpstreamUseAutofillProfileComparatorForName)) {
+      upload_request->active_experiments.push_back(
+          kAutofillUpstreamUseAutofillProfileComparatorForName.name);
       AutofillProfileComparator comparator(app_locale_);
       verified_name = comparator.NormalizeForComparison(card_name);
       for (const AutofillProfile& profile : candidate_profiles) {
         const base::string16 address_name = comparator.NormalizeForComparison(
             profile.GetInfo(AutofillType(NAME_FULL), app_locale_));
         if (address_name.empty())
           continue;
         if (verified_name.empty() ||
             comparator.IsNameVariantOf(address_name, verified_name)) {
           verified_name = address_name;
@@ skipping 63 matching lines @@
       }
     }
   }
 
   // If none of the candidate addresses have a zip, the candidate set is
   // invalid.
   if (verified_zip.empty() && !candidate_profiles.empty())
     upload_decision_metrics |= AutofillMetrics::UPLOAD_NOT_OFFERED_NO_ZIP_CODE;
 
   if (!upload_decision_metrics) {
-    profiles->assign(candidate_profiles.begin(), candidate_profiles.end());
+    upload_request->profiles.assign(candidate_profiles.begin(),
+                                    candidate_profiles.end());
     if (!has_modified_profile)
       for (const AutofillProfile& profile : candidate_profiles)
         UMA_HISTOGRAM_COUNTS_1000(
             "Autofill.DaysSincePreviousUseAtSubmission.Profile",
             (profile.use_date() - profile.previous_use_date()).InDays());
   }
   return upload_decision_metrics;
 }
 
 void AutofillManager::CollectRapporSample(
@@ skipping 852 matching lines @@
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 void AutofillManager::LogCardUploadDecisions(int upload_decision_metrics) {
   AutofillMetrics::LogCardUploadDecisionMetrics(upload_decision_metrics);
   AutofillMetrics::LogCardUploadDecisionsUkm(client_->GetUkmService(),
                                              pending_upload_request_url_,
                                              upload_decision_metrics);
 }
 
 }  // namespace autofill