Stores server card as a full server card when upload to server succeeds.

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 42 matching lines @@
 #include "components/metrics/proto/ukm/entry.pb.h"
 #include "components/prefs/pref_service.h"
 #include "components/rappor/test_rappor_service.h"
 #include "components/security_state/core/security_state.h"
 #include "components/strings/grit/components_strings.h"
 #include "components/ukm/test_ukm_service.h"
 #include "components/ukm/ukm_entry.h"
 #include "components/ukm/ukm_source.h"
 #include "components/variations/variations_associated_data.h"
 #include "net/base/url_util.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #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::_;
@@ skipping 41 matching lines @@
                         const std::string& app_locale) override {
     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 {
-    delegate_->OnDidUploadCard(AutofillClient::SUCCESS);
+    delegate_->OnDidUploadCard(AutofillClient::SUCCESS, server_id_);
   }
 
+  std::string server_id_;
+
  private:
   payments::PaymentsClientDelegate* const delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPaymentsClient);
 };
 
 class TestPersonalDataManager : public PersonalDataManager {

[Mathieu, 2017/04/24 18:11:55]

I wonder if we could subclass
components/autofill/core/browser/test_personal_data_manager.h and save a bunch
of lines here?

[csashi, 2017/04/24 18:30:06]

Looks like the savings would be minimal and we would need to override some
important functions like GetCreditCards.

  public:
   TestPersonalDataManager()
       : PersonalDataManager("en-US"),
         num_times_save_imported_profile_called_(0) {
     CreateTestAutofillProfiles(&web_profiles_);
     CreateTestCreditCards(&local_credit_cards_);
   }
 
   using PersonalDataManager::set_database;
   using PersonalDataManager::SetPrefService;
@@ skipping 29 matching lines @@
     web_profiles_.push_back(std::move(profile));
   }
 
   void AddCreditCard(const CreditCard& credit_card) override {
     std::unique_ptr<CreditCard> local_credit_card =
         base::MakeUnique<CreditCard>(credit_card);
     local_credit_card->set_modification_date(base::Time::Now());
     local_credit_cards_.push_back(std::move(local_credit_card));
   }
 
+  void AddServerCreditCard(const CreditCard& credit_card) override {
+    std::unique_ptr<CreditCard> server_credit_card =
+        base::MakeUnique<CreditCard>(credit_card);
+    server_credit_card->set_modification_date(base::Time::Now());
+    server_credit_cards_.push_back(std::move(server_credit_card));
+  }
+
   void RecordUseOf(const AutofillDataModel& data_model) override {
     CreditCard* credit_card = GetCreditCardWithGUID(data_model.guid().c_str());
     if (credit_card)
       credit_card->RecordAndLogUse();
 
     AutofillProfile* profile = GetProfileWithGUID(data_model.guid().c_str());
     if (profile)
       profile->RecordAndLogUse();
   }
 
@@ skipping 16 matching lines @@
                        }));
     }
   }
 
   void ClearAutofillProfiles() {
     web_profiles_.clear();
   }
 
   void ClearCreditCards() {
     local_credit_cards_.clear();
+    server_credit_cards_.clear();
   }
 
   // Create Elvis card with whitespace in the credit card number.
   void CreateTestCreditCardWithWhitespace() {
     ClearCreditCards();
     std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>();
     test::SetCreditCardInfo(credit_card.get(), "Elvis Presley",
                             "4234 5678 9012 3456",  // Visa
                             "04", "2999");
     credit_card->set_guid("00000000-0000-0000-0000-000000000008");
@@ skipping 299 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockAutofillDriver);
 };
 
 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()),
         autofill_enabled_(true),
         credit_card_upload_enabled_(false),
         credit_card_was_uploaded_(false),
         expected_observed_submission_(true) {
-    set_payments_client(
-        new TestPaymentsClient(driver->GetURLRequestContext(), this));
+    set_payments_client(new TestPaymentsClient(context_getter_, this));
   }
   ~TestAutofillManager() override {}
 
   bool IsAutofillEnabled() const override { return autofill_enabled_; }
 
   void set_autofill_enabled(bool autofill_enabled) {
     autofill_enabled_ = autofill_enabled;
   }
 
   bool IsCreditCardUploadEnabled() override {
@@ skipping 68 matching lines @@
   }
 
   AutofillProfile* GetProfileWithGUID(const char* guid) {
     return personal_data_->GetProfileWithGUID(guid);
   }
 
   CreditCard* GetCreditCardWithGUID(const char* guid) {
     return personal_data_->GetCreditCardWithGUID(guid);
   }
 
+  std::vector<CreditCard*> GetLocalCreditCards() const {
+    return personal_data_->GetLocalCreditCards();
+  }
+
+  const std::vector<CreditCard*>& GetCreditCards() const {
+    return personal_data_->GetCreditCards();
+  }
+
   void AddProfile(std::unique_ptr<AutofillProfile> profile) {
     personal_data_->AddProfile(std::move(profile));
   }
 
   void AddCreditCard(const CreditCard& credit_card) {
     personal_data_->AddCreditCard(credit_card);
   }
 
   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) override {
+  void OnDidUploadCard(AutofillClient::PaymentsRpcResult result,
+                       const std::string& server_id) override {
     credit_card_was_uploaded_ = true;
+    AutofillManager::OnDidUploadCard(result, server_id);
   };
 
-  // Weak reference.
-  TestPersonalDataManager* personal_data_;
-
+  TestPersonalDataManager* personal_data_;        // Weak reference.
+  net::URLRequestContextGetter* context_getter_;  // Weak reference.
   bool autofill_enabled_;
   bool credit_card_upload_enabled_;
   bool credit_card_was_uploaded_;
   bool expected_observed_submission_;
 
   std::unique_ptr<base::RunLoop> run_loop_;
 
   std::string submitted_form_signature_;
   std::vector<ServerFieldTypeSet> expected_submitted_field_types_;
 
@@ skipping 39 matching lines @@
       EXPECT_EQ(expected_suggestions[i].label, suggestions_[i].label);
       EXPECT_EQ(expected_suggestions[i].icon, suggestions_[i].icon);
       EXPECT_EQ(expected_suggestions[i].frontend_id,
                 suggestions_[i].frontend_id);
     }
     ASSERT_EQ(expected_num_suggestions, suggestions_.size());
   }
 
   // Wrappers around the above GetSuggestions call that take a hardcoded number
   // of expected results so callsites are cleaner.
-  void CheckSuggestions(int expected_page_id,
-                        const Suggestion& suggestion0) {
+  void CheckSuggestions(int expected_page_id, const Suggestion& suggestion0) {
     std::vector<Suggestion> suggestion_vector;
     suggestion_vector.push_back(suggestion0);
     CheckSuggestions(expected_page_id, 1, &suggestion_vector[0]);
   }
   void CheckSuggestions(int expected_page_id,
                         const Suggestion& suggestion0,
                         const Suggestion& suggestion1) {
     std::vector<Suggestion> suggestion_vector;
     suggestion_vector.push_back(suggestion0);
     suggestion_vector.push_back(suggestion1);
@@ skipping 18 matching lines @@
   // and contain a specific number of suggestions.
   void CheckSuggestionCount(int expected_page_id,
                             size_t expected_num_suggestions) {
     // Ensure that these results are from the most recent query.
     EXPECT_TRUE(on_suggestions_returned_seen_);
 
     EXPECT_EQ(expected_page_id, query_id_);
     ASSERT_EQ(expected_num_suggestions, suggestions_.size());
   }
 
-  bool on_query_seen() const {
-    return on_query_seen_;
-  }
+  bool on_query_seen() const { return on_query_seen_; }
 
   bool on_suggestions_returned_seen() const {
     return on_suggestions_returned_seen_;
   }
 
  private:
   // Records if OnQuery has been called yet.
   bool on_query_seen_;
 
   // Records if OnSuggestionsReturned has been called after the most recent
@@ skipping 61 matching lines @@
   void TearDown() override {
     // Order of destruction is important as AutofillManager relies on
     // PersonalDataManager to be around when it gets destroyed.
     autofill_manager_.reset();
     autofill_driver_.reset();
 
     // Remove the AutofillWebDataService so TestPersonalDataManager does not
     // need to care about removing self as an observer in destruction.
     personal_data_.set_database(scoped_refptr<AutofillWebDataService>(NULL));
     personal_data_.SetPrefService(NULL);
+    personal_data_.ClearCreditCards();
 
     request_context_ = nullptr;
   }
 
   void GetAutofillSuggestions(int query_id,
                               const FormData& form,
                               const FormFieldData& field) {
     autofill_manager_->OnQueryFormFieldAutofill(query_id, form, field,
                                                 gfx::RectF());
   }
 
   void GetAutofillSuggestions(const FormData& form,
                               const FormFieldData& field) {
     GetAutofillSuggestions(kDefaultPageID, form, field);
   }
 
   void AutocompleteSuggestionsReturned(
       const std::vector<base::string16>& result) {
     autofill_manager_->autocomplete_history_manager_->SendSuggestions(&result);
   }
 
   void FormsSeen(const std::vector<FormData>& forms) {
     autofill_manager_->OnFormsSeen(forms, base::TimeTicks());
   }
 
   void FormSubmitted(const FormData& form) {
     autofill_manager_->ResetRunLoop();
-    if (autofill_manager_->OnWillSubmitForm(form, base::TimeTicks::Now()))
+    if (autofill_manager_->OnWillSubmitForm(form, base::TimeTicks::Now()) &&
+        (!personal_data_.GetProfiles().empty() ||
+         !personal_data_.GetCreditCards().empty()))
       autofill_manager_->WaitForAsyncUploadProcess();
     autofill_manager_->OnFormSubmitted(form);
   }
 
   void FillAutofillFormData(int query_id,
                             const FormData& form,
                             const FormFieldData& field,
                             int unique_id) {
     autofill_manager_->FillOrPreviewForm(
         AutofillDriver::FORM_DATA_ACTION_FILL, query_id, form, field,
@@ skipping 228 matching lines @@
     EXPECT_EQ(expected_num_matching_entries, num_matching_entries);
   }
 
  protected:
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   MockAutofillClient autofill_client_;
   std::unique_ptr<MockAutofillDriver> autofill_driver_;
   std::unique_ptr<TestAutofillManager> autofill_manager_;
   std::unique_ptr<TestAutofillExternalDelegate> external_delegate_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
-  TestPaymentsClient* payments_client_;
   TestAutofillDownloadManager* download_manager_;
   TestPersonalDataManager personal_data_;
   base::FieldTrialList field_trial_list_;
   base::test::ScopedFeatureList scoped_feature_list_;
 };
 
 class TestFormStructure : public FormStructure {
  public:
   explicit TestFormStructure(const FormData& form)
       : FormStructure(form) {}
@@ skipping 638 matching lines @@
                                  "04/99", kVisaCard,
                                  autofill_manager_->GetPackedCreditCardID(4)),
       Suggestion("MasterCard" + kUTF8MidlineEllipsis + "8765", "10/98",
                  kMasterCard, autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // Test that we will eventually return the credit card signin promo when there
 // are no credit card suggestions and the promo is active. See the tests in
 // AutofillExternalDelegateTest that test whether the promo is added.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_OnlySigninPromo) {
-  // Make sure there are no credit cards.
   personal_data_.ClearCreditCards();
 
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   FormFieldData field = form.fields[1];
 
   ON_CALL(autofill_client_, ShouldShowSigninPromo())
@@ skipping 536 matching lines @@
                                      &response_page_id, &response_data);
   ExpectFilledCreditCardYearMonthWithYearMonth(
       response_page_id, response_data, kDefaultPageID, false, "2999", "");
 }
 
 // Test that we correctly fill a credit card form with month input type.
 // 4. year non-empty, month empty
 TEST_F(AutofillManagerTest, FillCreditCardForm_YearMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
-  personal_data_.ClearCreditCards();
   personal_data_.CreateTestCreditCardsYearAndMonth("2999", "04");
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, true);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const char guid[] = "00000000-0000-0000-0000-000000000007";
   int response_page_id = 0;
   FormData response_data;
@@ skipping 2227 matching lines @@
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
 #define MAYBE_UploadCreditCard DISABLED_UploadCreditCard
 #else
 #define MAYBE_UploadCreditCard UploadCreditCard
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard) {
   EnableUkmLogging();
+  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(std::vector<FormData>(1, address_form));
   ExpectUniqueFillableFormParsedUkm();
 
@@ skipping 11 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;
 
   FormSubmitted(credit_card_form);
   EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
 
+  // 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.
   histogram_tester.ExpectUniqueSample("Autofill.CardUploadDecisionExpanded",
                                       AutofillMetrics::UPLOAD_OFFERED, 1);
   // Verify that the correct UKM was logged.
   ExpectCardUploadDecisionUkm(AutofillMetrics::UPLOAD_OFFERED);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
+#define MAYBE_UploadCreditCardAndSaveCopy DISABLED_UploadCreditCardAndSaveCopy
+#else
+#define MAYBE_UploadCreditCardAndSaveCopy UploadCreditCardAndSaveCopy
+#endif
+TEST_F(AutofillManagerTest, MAYBE_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.
+  FormData address_form;
+  test::CreateTestAddressFormData(&address_form);
+  FormsSeen(std::vector<FormData>(1, 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(std::vector<FormData>(1, credit_card_form));
+
+  // Edit the data, and submit.
+  const char* const card_number = "4111111111111111";
+  credit_card_form.fields[0].value = ASCIIToUTF16("Flo Master");
+  credit_card_form.fields[1].value = ASCIIToUTF16(card_number);
+  credit_card_form.fields[2].value = ASCIIToUTF16("11");
+  credit_card_form.fields[3].value = ASCIIToUTF16("2017");
+  credit_card_form.fields[4].value = ASCIIToUTF16("123");
+
+  FormSubmitted(credit_card_form);
+
+  EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
+  EXPECT_TRUE(autofill_manager_->GetLocalCreditCards().empty());
+  ASSERT_EQ(1U, autofill_manager_->GetCreditCards().size());
+  const CreditCard* const saved_card = autofill_manager_->GetCreditCards()[0];
+  EXPECT_EQ(CreditCard::OK, saved_card->GetServerStatus());
+  EXPECT_EQ(base::ASCIIToUTF16("1111"), saved_card->LastFourDigits());
+  EXPECT_EQ(kVisaCard, saved_card->type());
+  EXPECT_EQ(11, saved_card->expiration_month());
+  EXPECT_EQ(2017, saved_card->expiration_year());
+  EXPECT_EQ(server_id, saved_card->server_id());
+  EXPECT_EQ(CreditCard::FULL_SERVER_CARD, saved_card->record_type());
+  EXPECT_EQ(base::ASCIIToUTF16(card_number), saved_card->number());
+}
+
+// TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
+#if defined(OS_ANDROID)
 #define MAYBE_UploadCreditCard_FeatureNotEnabled DISABLED_UploadCreditCard_FeatureNotEnabled
 #else
 #define MAYBE_UploadCreditCard_FeatureNotEnabled UploadCreditCard_FeatureNotEnabled
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_FeatureNotEnabled) {
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(false);
 
   // Create, fill and submit an address form in order to establish a recent
   // profile which can be selected for the upload request.
@@ skipping 1445 matching lines @@
   autofill_manager_->StartUploadProcess(std::move(form_structure),
                                         base::TimeTicks::Now(), true);
 
   // Wait for upload to complete (will check expected types as well).
   autofill_manager_->WaitForAsyncUploadProcess();
 
   EXPECT_EQ(signature, autofill_manager_->GetSubmittedFormSignature());
 }
 
 }  // namespace autofill