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 103 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 {
  public:
   TestPersonalDataManager()
       : PersonalDataManager("en-US"),
@@ skipping 36 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 292 matching lines @@
   bool did_interact_with_credit_card_form() const {
     return did_interact_with_credit_card_form_;
   }
 
  private:
   bool is_incognito_;
   bool did_interact_with_credit_card_form_;
   DISALLOW_COPY_AND_ASSIGN(MockAutofillDriver);
 };
 
+class TestAutofillExternalDelegate : public AutofillExternalDelegate {
+ public:
+  explicit TestAutofillExternalDelegate(AutofillManager* autofill_manager,
+                                        AutofillDriver* autofill_driver)
+      : AutofillExternalDelegate(autofill_manager, autofill_driver),
+        on_query_seen_(false),
+        on_suggestions_returned_seen_(false) {}
+  ~TestAutofillExternalDelegate() override {}
+
+  void OnQuery(int query_id,
+               const FormData& form,
+               const FormFieldData& field,
+               const gfx::RectF& bounds) override {
+    on_query_seen_ = true;
+    on_suggestions_returned_seen_ = false;
+  }
+
+  void OnSuggestionsReturned(
+      int query_id,
+      const std::vector<Suggestion>& suggestions) override {
+    on_suggestions_returned_seen_ = true;
+    query_id_ = query_id;
+    suggestions_ = suggestions;
+  }
+
+  void CheckSuggestions(int expected_page_id,
+                        size_t expected_num_suggestions,
+                        const Suggestion expected_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_LE(expected_num_suggestions, suggestions_.size());
+    for (size_t i = 0; i < expected_num_suggestions; ++i) {
+      SCOPED_TRACE(base::StringPrintf("i: %" PRIuS, i));
+      EXPECT_EQ(expected_suggestions[i].value, suggestions_[i].value);
+      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) {
+    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);
+    CheckSuggestions(expected_page_id, 2, &suggestion_vector[0]);
+  }
+  void CheckSuggestions(int expected_page_id,
+                        const Suggestion& suggestion0,
+                        const Suggestion& suggestion1,
+                        const Suggestion& suggestion2) {
+    std::vector<Suggestion> suggestion_vector;
+    suggestion_vector.push_back(suggestion0);
+    suggestion_vector.push_back(suggestion1);
+    suggestion_vector.push_back(suggestion2);
+    CheckSuggestions(expected_page_id, 3, &suggestion_vector[0]);
+  }
+  // Check that the autofill suggestions were sent, and that they match a page
+  // but contain no results.
+  void CheckNoSuggestions(int expected_page_id) {
+    CheckSuggestions(expected_page_id, 0, nullptr);
+  }
+  // Check that the autofill suggestions were sent, and that they match a page
+  // 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_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
+  // call to OnQuery.
+  bool on_suggestions_returned_seen_;
+
+  // The query id of the most recent Autofill query.
+  int query_id_;
+
+  // The results returned by the most recent Autofill query.
+  std::vector<Suggestion> suggestions_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestAutofillExternalDelegate);
+};
+
+// Finds the specified UKM metric by |name| in the specified UKM |metrics|.
+const ukm::Entry_Metric* FindMetric(
+    const char* name,
+    const google::protobuf::RepeatedPtrField<ukm::Entry_Metric>& metrics) {
+  for (const auto& metric : metrics) {
+    if (metric.metric_hash() == base::HashMetricName(name))
+      return &metric;
+  }
+  return nullptr;
+}
+
+// Get Ukm sources from the Ukm service.
+std::vector<const ukm::UkmSource*> GetUkmSources(ukm::TestUkmService* service) {
+  std::vector<const ukm::UkmSource*> sources;
+  for (const auto& kv : service->GetSources())
+    sources.push_back(kv.second.get());
+
+  return sources;
+}
+
+}  // namespace
+
 class TestAutofillManager : public AutofillManager {
  public:
   TestAutofillManager(AutofillDriver* driver,
                       AutofillClient* client,
                       TestPersonalDataManager* personal_data)
       : AutofillManager(driver, client, personal_data),
         personal_data_(personal_data),
         autofill_enabled_(true),
         credit_card_upload_enabled_(false),
         credit_card_was_uploaded_(false),
@@ skipping 81 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(driver_->GetURLRequestContext(), 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.
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
 };
 
-class TestAutofillExternalDelegate : public AutofillExternalDelegate {
- public:
-  explicit TestAutofillExternalDelegate(AutofillManager* autofill_manager,
-                                        AutofillDriver* autofill_driver)
-      : AutofillExternalDelegate(autofill_manager, autofill_driver),
-        on_query_seen_(false),
-        on_suggestions_returned_seen_(false) {}
-  ~TestAutofillExternalDelegate() override {}
-
-  void OnQuery(int query_id,
-               const FormData& form,
-               const FormFieldData& field,
-               const gfx::RectF& bounds) override {
-    on_query_seen_ = true;
-    on_suggestions_returned_seen_ = false;
-  }
-
-  void OnSuggestionsReturned(
-      int query_id,
-      const std::vector<Suggestion>& suggestions) override {
-    on_suggestions_returned_seen_ = true;
-    query_id_ = query_id;
-    suggestions_ = suggestions;
-  }
-
-  void CheckSuggestions(int expected_page_id,
-                        size_t expected_num_suggestions,
-                        const Suggestion expected_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_LE(expected_num_suggestions, suggestions_.size());
-    for (size_t i = 0; i < expected_num_suggestions; ++i) {
-      SCOPED_TRACE(base::StringPrintf("i: %" PRIuS, i));
-      EXPECT_EQ(expected_suggestions[i].value, suggestions_[i].value);
-      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) {
-    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);
-    CheckSuggestions(expected_page_id, 2, &suggestion_vector[0]);
-  }
-  void CheckSuggestions(int expected_page_id,
-                        const Suggestion& suggestion0,
-                        const Suggestion& suggestion1,
-                        const Suggestion& suggestion2) {
-    std::vector<Suggestion> suggestion_vector;
-    suggestion_vector.push_back(suggestion0);
-    suggestion_vector.push_back(suggestion1);
-    suggestion_vector.push_back(suggestion2);
-    CheckSuggestions(expected_page_id, 3, &suggestion_vector[0]);
-  }
-  // Check that the autofill suggestions were sent, and that they match a page
-  // but contain no results.
-  void CheckNoSuggestions(int expected_page_id) {
-    CheckSuggestions(expected_page_id, 0, nullptr);
-  }
-  // Check that the autofill suggestions were sent, and that they match a page
-  // 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_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
-  // call to OnQuery.
-  bool on_suggestions_returned_seen_;
-
-  // The query id of the most recent Autofill query.
-  int query_id_;
-
-  // The results returned by the most recent Autofill query.
-  std::vector<Suggestion> suggestions_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestAutofillExternalDelegate);
-};
-
-// Finds the specified UKM metric by |name| in the specified UKM |metrics|.
-const ukm::Entry_Metric* FindMetric(
-    const char* name,
-    const google::protobuf::RepeatedPtrField<ukm::Entry_Metric>& metrics) {
-  for (const auto& metric : metrics) {
-    if (metric.metric_hash() == base::HashMetricName(name))
-      return &metric;
-  }
-  return nullptr;
-}
-
-// Get Ukm sources from the Ukm service.
-std::vector<const ukm::UkmSource*> GetUkmSources(ukm::TestUkmService* service) {
-  std::vector<const ukm::UkmSource*> sources;
-  for (const auto& kv : service->GetSources())
-    sources.push_back(kv.second.get());
-
-  return sources;
-}
-
-}  // namespace
-
 class AutofillManagerTest : public testing::Test {
  public:
   AutofillManagerTest() : field_trial_list_(nullptr) {}
 
   void SetUp() override {
     autofill_client_.SetPrefs(test::PrefServiceForTesting());
     personal_data_.set_database(autofill_client_.GetDatabase());
     personal_data_.SetPrefService(autofill_client_.GetPrefs());
     autofill_driver_.reset(new MockAutofillDriver());
     request_context_ = new net::TestURLRequestContextGetter(
@@ skipping 17 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