Pass active_chrome_experiments in payments RPC.

components/autofill/core/browser/autofill_manager_unittest.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 <algorithm>
 #include <memory>
@@ skipping 59 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/geometry/rect.h"
 #include "url/gurl.h"
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using testing::_;
 using testing::AtLeast;
 using testing::Return;
 using testing::SaveArg;
+using testing::UnorderedElementsAre;
 
 namespace autofill {
 namespace {
 
 const int kDefaultPageID = 137;
 
 const char kUTF8MidlineEllipsis[] =
     "  "
     "\xE2\x80\xA2\xE2\x80\x86"
     "\xE2\x80\xA2\xE2\x80\x86"
@@ skipping 20 matching lines @@
 
 class TestPaymentsClient : public payments::PaymentsClient {
  public:
   TestPaymentsClient(net::URLRequestContextGetter* context_getter,
                      payments::PaymentsClientDelegate* delegate)
       : PaymentsClient(context_getter, delegate), delegate_(delegate) {}
 
   ~TestPaymentsClient() override {}
 
   void GetUploadDetails(const std::vector<AutofillProfile>& addresses,
+                        const std::vector<const char*>& active_experiments,
                         const std::string& app_locale) override {
+    active_experiments_ = active_experiments;
     delegate_->OnDidGetUploadDetails(
         app_locale == "en-US" ? AutofillClient::SUCCESS
                               : AutofillClient::PERMANENT_FAILURE,
         ASCIIToUTF16("this is a context token"),
         std::unique_ptr<base::DictionaryValue>(nullptr));
   }
 
   void UploadCard(const payments::PaymentsClient::UploadRequestDetails&
                       request_details) override {
+    active_experiments_ = request_details.active_experiments;
     delegate_->OnDidUploadCard(AutofillClient::SUCCESS, server_id_);
   }
 
   std::string server_id_;
+  std::vector<const char*> active_experiments_;
 
  private:
   payments::PaymentsClientDelegate* const delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPaymentsClient);
 };
 
 class TestPersonalDataManager : public PersonalDataManager {
  public:
   TestPersonalDataManager()
@@ skipping 408 matching lines @@
 };
 
 class TestAutofillManager : public AutofillManager {
  public:
   TestAutofillManager(AutofillDriver* driver,
                       AutofillClient* client,
                       TestPersonalDataManager* personal_data)
       : AutofillManager(driver, client, personal_data),
         personal_data_(personal_data),
         context_getter_(driver->GetURLRequestContext()),
+        test_payments_client_(new TestPaymentsClient(context_getter_, this)),
         autofill_enabled_(true),
         credit_card_upload_enabled_(false),
         credit_card_was_uploaded_(false),
         expected_observed_submission_(true),
         call_parent_upload_form_data_(false) {
-    set_payments_client(new TestPaymentsClient(context_getter_, this));
+    set_payments_client(test_payments_client_);
   }
   ~TestAutofillManager() override {}
 
   bool IsAutofillEnabled() const override { return autofill_enabled_; }
 
   void set_autofill_enabled(bool autofill_enabled) {
     autofill_enabled_ = autofill_enabled;
   }
 
   bool IsCreditCardUploadEnabled() override {
@@ skipping 90 matching lines @@
   }
 
   void AddProfile(std::unique_ptr<AutofillProfile> profile) {
     personal_data_->AddProfile(std::move(profile));
   }
 
   void AddCreditCard(const CreditCard& credit_card) {
     personal_data_->AddCreditCard(credit_card);
   }
 
+  const std::vector<const char*>& GetActiveExperiments() const {
+    return test_payments_client_->active_experiments_;
+  }
+
   int GetPackedCreditCardID(int credit_card_id) {
     std::string credit_card_guid =
         base::StringPrintf("00000000-0000-0000-0000-%012d", credit_card_id);
 
     return MakeFrontendID(credit_card_guid, std::string());
   }
 
   void AddSeenForm(std::unique_ptr<FormStructure> form) {
     form_structures()->push_back(std::move(form));
   }
 
   void ClearFormStructures() { form_structures()->clear(); }
 
   void ResetPaymentsClientForCardUpload(const char* server_id) {
     TestPaymentsClient* payments_client =
         new TestPaymentsClient(context_getter_, this);
     payments_client->server_id_ = server_id;
     set_payments_client(payments_client);
   }
 
  private:
   void OnDidUploadCard(AutofillClient::PaymentsRpcResult result,
                        const std::string& server_id) override {
     credit_card_was_uploaded_ = true;
     AutofillManager::OnDidUploadCard(result, server_id);
   };
 
   TestPersonalDataManager* personal_data_;        // Weak reference.
   net::URLRequestContextGetter* context_getter_;  // Weak reference.
+  TestPaymentsClient* test_payments_client_;      // Weak reference.
   bool autofill_enabled_;
   bool credit_card_upload_enabled_;
   bool credit_card_was_uploaded_;
   bool expected_observed_submission_;
   bool call_parent_upload_form_data_;
 
   std::unique_ptr<base::RunLoop> run_loop_;
 
   std::string submitted_form_signature_;
   std::vector<ServerFieldTypeSet> expected_submitted_field_types_;
@@ skipping 347 matching lines @@
     return static_cast<CardUnmaskDelegate*>(
         autofill_manager_->full_card_request_.get());
   }
 
   void SetHttpWarningEnabled() {
     scoped_feature_list_.InitAndEnableFeature(
         security_state::kHttpFormWarningFeature);
   }
 
   void EnableAutofillUpstreamRequestCvcIfMissingExperiment() {
-    scoped_feature_list_.InitWithFeatures(
-        {kAutofillUpstreamRequestCvcIfMissing}, {});
+    scoped_feature_list_.InitAndEnableFeature(
+        kAutofillUpstreamRequestCvcIfMissing);
   }
 
   void DisableAutofillUpstreamUseAutofillProfileComparatorForName() {
     scoped_feature_list_.InitAndDisableFeature(
         kAutofillUpstreamUseAutofillProfileComparatorForName);
   }
 
   void ExpectUniqueFillableFormParsedUkm() {
     ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
 
@@ skipping 3575 matching lines @@
   credit_card_form.fields[1].value = ASCIIToUTF16("4111111111111111");
   credit_card_form.fields[2].value = ASCIIToUTF16("11");
   credit_card_form.fields[3].value = ASCIIToUTF16("2017");
   credit_card_form.fields[4].value = ASCIIToUTF16("123");
 
   base::HistogramTester histogram_tester;
 
   EXPECT_CALL(autofill_client_, ConfirmSaveCreditCardLocally(_, _)).Times(0);
   FormSubmitted(credit_card_form);
   EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
+  EXPECT_THAT(autofill_manager_->GetActiveExperiments(),
+              UnorderedElementsAre(
+                  kAutofillUpstreamUseAutofillProfileComparatorForName.name));
 
   // Server did not send a server_id, expect copy of card is not stored.
   EXPECT_TRUE(autofill_manager_->GetCreditCards().empty());
   // Verify that the correct histogram entry (and only that) was logged.
   ExpectUniqueCardUploadDecision(histogram_tester,
                                  AutofillMetrics::UPLOAD_OFFERED);
   // Verify that the correct UKM was logged.
   ExpectCardUploadDecisionUkm(AutofillMetrics::UPLOAD_OFFERED);
   // Verify the histogram entry for recent profile modification.
   histogram_tester.ExpectUniqueSample(
       "Autofill.HasModifiedProfile.CreditCardFormSubmission", true, 1);
   // Verify that UMA for "DaysSincePreviousUse" was not logged because we
   // modified the profile.
   histogram_tester.ExpectTotalCount(
       "Autofill.DaysSincePreviousUseAtSubmission.Profile", 0);
 }
 
+TEST_F(AutofillManagerTest, UploadCreditCard_RequestCVCEnabled_DoesNotTrigger) {
+  EnableAutofillUpstreamRequestCvcIfMissingExperiment();
+
+  personal_data_.ClearCreditCards();
+  personal_data_.ClearAutofillProfiles();
+  autofill_manager_->set_credit_card_upload_enabled(true);
+
+  // Create, fill and submit an address form in order to establish a recent
+  // profile which can be selected for the upload request.
+  FormData address_form;
+  test::CreateTestAddressFormData(&address_form);
+  FormsSeen({address_form});
+
+  ManuallyFillAddressForm("Flo", "Master", "77401", "US", &address_form);
+  FormSubmitted(address_form);
+
+  // Set up our credit card form data.
+  FormData credit_card_form;
+  CreateTestCreditCardFormData(&credit_card_form, true, false);
+  FormsSeen({credit_card_form});
+
+  // Edit the data, and submit.
+  credit_card_form.fields[0].value = ASCIIToUTF16("Flo Master");
+  credit_card_form.fields[1].value = ASCIIToUTF16("4111111111111111");
+  credit_card_form.fields[2].value = ASCIIToUTF16("11");
+  credit_card_form.fields[3].value = ASCIIToUTF16("2017");
+  credit_card_form.fields[4].value = ASCIIToUTF16("123");
+
+  EXPECT_CALL(autofill_client_, ConfirmSaveCreditCardLocally(_, _)).Times(0);
+  FormSubmitted(credit_card_form);
+  EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
+  // Submitted form included CVC, so user did not need to enter CVC.
+  EXPECT_THAT(autofill_manager_->GetActiveExperiments(),
+              UnorderedElementsAre(
+                  kAutofillUpstreamUseAutofillProfileComparatorForName.name));
+}
+
 TEST_F(AutofillManagerTest, UploadCreditCardAndSaveCopy) {
   personal_data_.ClearCreditCards();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   const char* const server_id = "InstrumentData:1234";
   autofill_manager_->ResetPaymentsClientForCardUpload(server_id);
 
   // Create, fill and submit an address form in order to establish a recent
   // profile which can be selected for the upload request.
@@ skipping 506 matching lines @@
   credit_card_form.fields[1].value = ASCIIToUTF16("4111111111111111");
   credit_card_form.fields[2].value = ASCIIToUTF16("11");
   credit_card_form.fields[3].value = ASCIIToUTF16("2017");
 
   base::HistogramTester histogram_tester;
 
   // Upload should still happen as long as the user provides CVC in the bubble.
   EXPECT_CALL(autofill_client_, ConfirmSaveCreditCardLocally(_, _)).Times(0);
   FormSubmitted(credit_card_form);
   EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
+  EXPECT_THAT(autofill_manager_->GetActiveExperiments(),
+              UnorderedElementsAre(
+                  kAutofillUpstreamUseAutofillProfileComparatorForName.name,
+                  kAutofillUpstreamRequestCvcIfMissing.name));
 
   // Verify that the correct histogram entries were logged.
   ExpectCardUploadDecision(histogram_tester, AutofillMetrics::UPLOAD_OFFERED);
   ExpectCardUploadDecision(histogram_tester,
                            AutofillMetrics::CVC_FIELD_NOT_FOUND);
   // Verify that the correct UKM was logged.
   ExpectMetric(
       internal::kUKMCardUploadDecisionMetricName,
       internal::kUKMCardUploadDecisionEntryName,
       AutofillMetrics::UPLOAD_OFFERED | AutofillMetrics::CVC_FIELD_NOT_FOUND,
@@ skipping 197 matching lines @@
   credit_card_form.fields[2].value = ASCIIToUTF16("11");
   credit_card_form.fields[3].value = ASCIIToUTF16("2017");
   credit_card_form.fields[4].value = ASCIIToUTF16("123");
 
   base::HistogramTester histogram_tester;
 
   // Upload should be offered.
   EXPECT_CALL(autofill_client_, ConfirmSaveCreditCardLocally(_, _)).Times(0);
   FormSubmitted(credit_card_form);
   EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
+  EXPECT_THAT(autofill_manager_->GetActiveExperiments(),
+              UnorderedElementsAre(
+                  kAutofillUpstreamUseAutofillProfileComparatorForName.name,
+                  kAutofillUpstreamUseNotRecentlyUsedAutofillProfile.name));
 
   // Verify that the correct histogram entry (and only that) was logged.
   ExpectUniqueCardUploadDecision(histogram_tester,
                                  AutofillMetrics::UPLOAD_OFFERED);
 }
 
 TEST_F(AutofillManagerTest,
        UploadCreditCard_CvcUnavailableAndNoProfileAvailable) {
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
@@ skipping 309 matching lines @@
   credit_card_form.fields[2].value = ASCIIToUTF16("11");
   credit_card_form.fields[3].value = ASCIIToUTF16("2017");
   credit_card_form.fields[4].value = ASCIIToUTF16("123");
 
   base::HistogramTester histogram_tester;
 
   // Names match loosely, upload should happen.
   EXPECT_CALL(autofill_client_, ConfirmSaveCreditCardLocally(_, _)).Times(0);
   FormSubmitted(credit_card_form);
   EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
+  EXPECT_TRUE(autofill_manager_->GetActiveExperiments().empty());
 
   // Verify that the correct histogram entry (and only that) was logged.
   ExpectUniqueCardUploadDecision(histogram_tester,
                                  AutofillMetrics::UPLOAD_OFFERED);
 }
 
 TEST_F(AutofillManagerTest, UploadCreditCard_NoMiddleInitialInCCForm) {
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
@@ skipping 337 matching lines @@
   credit_card_form.fields[2].value = ASCIIToUTF16("11");
   credit_card_form.fields[3].value = ASCIIToUTF16("2017");
   credit_card_form.fields[4].value = ASCIIToUTF16("123");
 
   base::HistogramTester histogram_tester;
 
   // Name matches recently used profile, should offer upload.
   EXPECT_CALL(autofill_client_, ConfirmSaveCreditCardLocally(_, _)).Times(0);
   FormSubmitted(credit_card_form);
   EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
+  // Recently used profile was available, so did not need to use old profile.
+  EXPECT_THAT(autofill_manager_->GetActiveExperiments(),
+              UnorderedElementsAre(
+                  kAutofillUpstreamUseAutofillProfileComparatorForName.name));
 
   // Verify that the correct histogram entry (and only that) was logged.
   ExpectUniqueCardUploadDecision(histogram_tester,
                                  AutofillMetrics::UPLOAD_OFFERED);
 }
 
 TEST_F(AutofillManagerTest,
        UploadCreditCard_NamesHaveToMatch_DisableComparator) {
   DisableAutofillUpstreamUseAutofillProfileComparatorForName();
   personal_data_.ClearAutofillProfiles();
@@ skipping 786 matching lines @@
 
   // Wait for upload to complete (will check expected types as well).
   autofill_manager_->WaitForAsyncUploadProcess();
 
   EXPECT_EQ(signature, autofill_manager_->GetSubmittedFormSignature());
   EXPECT_NE(uploaded_available_types.end(),
             uploaded_available_types.find(autofill::PASSWORD));
 }
 
 }  // namespace autofill