Offer to save card locally if user manually enters same card number as

components/autofill/core/browser/personal_data_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/personal_data_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 230 matching lines @@
 
     ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
   }
 
   // Helper methods that simply forward the call to the private member (to avoid
   // having to friend every test that needs to access the private
   // PersonalDataManager::ImportAddressProfile or ImportCreditCard).
   bool ImportAddressProfiles(const FormStructure& form) {
     return personal_data_->ImportAddressProfiles(form);
   }
-  bool ImportCreditCard(const FormStructure& form,
-                        bool should_return_local_card,
-                        std::unique_ptr<CreditCard>* imported_credit_card) {
-    return personal_data_->ImportCreditCard(form, should_return_local_card,
-                                            imported_credit_card);
+  bool ImportCreditCard(
+      const FormStructure& form,
+      bool should_return_local_card,
+      std::unique_ptr<CreditCard>* imported_credit_card,
+      bool* imported_credit_card_matches_masked_server_credit_card) {
+    return personal_data_->ImportCreditCard(
+        form, should_return_local_card, imported_credit_card,
+        imported_credit_card_matches_masked_server_credit_card);
   }
 
   void SubmitFormAndExpectImportedCardWithData(const FormData& form,
                                                const char* exp_name,
                                                const char* exp_cc_num,
                                                const char* exp_cc_month,
                                                const char* exp_cc_year) {
     FormStructure form_structure(form);
     form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
     std::unique_ptr<CreditCard> imported_credit_card;
-    EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
+    bool imported_credit_card_matches_masked_server_credit_card;
+    EXPECT_TRUE(ImportCreditCard(
+        form_structure, false, &imported_credit_card,
+        &imported_credit_card_matches_masked_server_credit_card));
     ASSERT_TRUE(imported_credit_card);
+    EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
     personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
     // Verify that the web database has been updated and the notification sent.
     EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
         .WillOnce(QuitMainMessageLoop());
     base::RunLoop().Run();
 
     CreditCard expected(base::GenerateGUID(), "https://www.example.com");
     test::SetCreditCardInfo(&expected, exp_name, exp_cc_num, exp_cc_month,
                             exp_cc_year);
@@ skipping 1918 matching lines @@
 // Tests that a valid credit card is extracted.
 TEST_F(PersonalDataManagerTest, ImportCreditCard_Valid) {
   // Add a single valid credit card form.
   FormData form;
   AddFullCreditCardForm(&form, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01",
                           "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 }
 
 // Tests that an invalid credit card is not extracted.
 TEST_F(PersonalDataManagerTest, ImportCreditCard_Invalid) {
   FormData form;
   AddFullCreditCardForm(&form, "Jim Johansen", "1000000000000000", "02",
                         "2999");
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_FALSE(ImportCreditCard(form_structure, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_FALSE(ImportCreditCard(
+      form_structure, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_FALSE(imported_credit_card);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
   ResetPersonalDataManager(USER_MODE_NORMAL);
 
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(0U, results.size());
 }
 
@@ skipping 13 matching lines @@
   std::vector<base::string16> contents;
   contents.push_back(base::ASCIIToUTF16("Jan (1)"));
   contents.push_back(base::ASCIIToUTF16("Feb (2)"));
   contents.push_back(base::ASCIIToUTF16("Mar (3)"));
   form.fields[2].option_values = values;
   form.fields[2].option_contents = contents;
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // See that the invalid option text was converted to the right value.
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "02",
                           "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 }
 
 TEST_F(PersonalDataManagerTest, ImportCreditCard_TwoValidCards) {
   // Start with a single valid credit card form.
   FormData form1;
   AddFullCreditCardForm(&form1, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure1, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure1, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01",
                           "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card.
   FormData form2;
   AddFullCreditCardForm(&form2, "", "5500 0000 0000 0004", "02", "2999");
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card2;
-  EXPECT_TRUE(ImportCreditCard(form_structure2, false, &imported_credit_card2));
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure2, false, &imported_credit_card2,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card2);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card2);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2, "", "5500000000000004", "02", "2999");
   std::vector<CreditCard*> cards;
@@ skipping 93 matching lines @@
   // Type the same data as the masked card into a form.
   FormData form;
   AddFullCreditCardForm(&form, "John Dillinger", "4111111111111111", "01",
                         "2999");
 
   // The card should be offered to be saved locally because it only matches the
   // masked server card.
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 }
 
 // Tests that a credit card is not extracted because it matches a full server
 // card.
 TEST_F(PersonalDataManagerTest,
        ImportCreditCard_DuplicateServerCards_FullCard) {
   // Add a full server card.
   std::vector<CreditCard> server_cards;
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "c789"));
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
                           "347666888555" /* American Express */, "04", "2999");
   test::SetServerCreditCards(autofill_table_, server_cards);
 
   // Type the same data as the unmasked card into a form.
   FormData form;
   AddFullCreditCardForm(&form, "Clyde Barrow", "347666888555", "04", "2999");
 
   // The card should not be offered to be saved locally because it only matches
   // the full server card.
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_FALSE(ImportCreditCard(form_structure, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_FALSE(ImportCreditCard(
+      form_structure, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_FALSE(imported_credit_card);
 }
 
 TEST_F(PersonalDataManagerTest, ImportCreditCard_SameCreditCardWithConflict) {
   // Start with a single valid credit card form.
   FormData form1;
   AddFullCreditCardForm(&form1, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2998");
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure1, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure1, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01",
                           "2998");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card where the year is different but
   // the credit card number matches.
   FormData form2;
   AddFullCreditCardForm(&form2, "Biggie Smalls", "4111 1111 1111 1111", "01",
                         /* different year */ "2999");
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card2;
-  EXPECT_TRUE(ImportCreditCard(form_structure2, false, &imported_credit_card2));
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure2, false, &imported_credit_card2,
+      &imported_credit_card_matches_masked_server_credit_card));
   EXPECT_FALSE(imported_credit_card2);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Expect that the newer information is saved.  In this case the year is
   // updated to "2999".
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2, "Biggie Smalls", "4111111111111111", "01",
                           "2999");
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
 TEST_F(PersonalDataManagerTest, ImportCreditCard_ShouldReturnLocalCard) {
   // Start with a single valid credit card form.
   FormData form1;
   AddFullCreditCardForm(&form1, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2998");
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure1, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure1, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01",
                           "2998");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card where the year is different but
   // the credit card number matches.
   FormData form2;
   AddFullCreditCardForm(&form2, "Biggie Smalls", "4111 1111 1111 1111", "01",
                         /* different year */ "2999");
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card2;
-  EXPECT_TRUE(ImportCreditCard(form_structure2,
-                               /* should_return_local_card= */ true,
-                               &imported_credit_card2));
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure2,
+      /* should_return_local_card= */ true, &imported_credit_card2,
+      &imported_credit_card_matches_masked_server_credit_card));
   // The local card is returned after an update.
   EXPECT_TRUE(imported_credit_card2);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Expect that the newer information is saved.  In this case the year is
   // updated to "2999".
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2, "Biggie Smalls", "4111111111111111", "01",
                           "2999");
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
 TEST_F(PersonalDataManagerTest, ImportCreditCard_EmptyCardWithConflict) {
   // Start with a single valid credit card form.
   FormData form1;
   AddFullCreditCardForm(&form1, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2998");
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure1, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure1, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01",
                           "2998");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second credit card with no number.
   FormData form2;
   AddFullCreditCardForm(&form2, "Biggie Smalls", /* no number */ nullptr, "01",
                         "2999");
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card2;
-  EXPECT_FALSE(
-      ImportCreditCard(form_structure2, false, &imported_credit_card2));
+  EXPECT_FALSE(ImportCreditCard(
+      form_structure2, false, &imported_credit_card2,
+      &imported_credit_card_matches_masked_server_credit_card));
   EXPECT_FALSE(imported_credit_card2);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
   ResetPersonalDataManager(USER_MODE_NORMAL);
 
   // No change is expected.
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2, "Biggie Smalls", "4111111111111111", "01",
                           "2998");
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
 TEST_F(PersonalDataManagerTest, ImportCreditCard_MissingInfoInNew) {
   // Start with a single valid credit card form.
   FormData form1;
   AddFullCreditCardForm(&form1, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure1, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure1, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   CreditCard expected(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected,
       "Biggie Smalls", "4111111111111111", "01", "2999");
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, expected.Compare(*results[0]));
 
   // Add a second different valid credit card where the name is missing but
   // the credit card number matches.
   FormData form2;
   AddFullCreditCardForm(&form2, /* missing name */ nullptr,
                         "4111-1111-1111-1111", "01", "2999");
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card2;
-  EXPECT_TRUE(ImportCreditCard(form_structure2, false, &imported_credit_card2));
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure2, false, &imported_credit_card2,
+      &imported_credit_card_matches_masked_server_credit_card));
   EXPECT_FALSE(imported_credit_card2);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
   ResetPersonalDataManager(USER_MODE_NORMAL);
 
   // No change is expected.
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected2,
       "Biggie Smalls", "4111111111111111", "01", "2999");
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 
   // Add a third credit card where the expiration date is missing.
   FormData form3;
   AddFullCreditCardForm(&form3, "Johnny McEnroe", "5555555555554444",
                         /* no month */ nullptr,
                         /* no year */ nullptr);
 
   FormStructure form_structure3(form3);
   form_structure3.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card3;
-  EXPECT_FALSE(
-      ImportCreditCard(form_structure3, false, &imported_credit_card3));
+  EXPECT_FALSE(ImportCreditCard(
+      form_structure3, false, &imported_credit_card3,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_FALSE(imported_credit_card3);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
   ResetPersonalDataManager(USER_MODE_NORMAL);
 
   // No change is expected.
   CreditCard expected3(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&expected3,
       "Biggie Smalls", "4111111111111111", "01", "2999");
@@ skipping 21 matching lines @@
 
   // Add a second different valid credit card where the year is different but
   // the credit card number matches.
   FormData form;
   AddFullCreditCardForm(&form, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         /* different year */ "2999");
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   EXPECT_FALSE(imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Expect that the newer information is saved.  In this case the year is
   // added to the existing credit card.
   CreditCard expected2(base::GenerateGUID(), "https://www.example.com");
@@ skipping 24 matching lines @@
   EXPECT_EQ(0, saved_credit_card.Compare(*results1[0]));
 
   // Import the same card info, but with different separators in the number.
   FormData form;
   AddFullCreditCardForm(&form, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   EXPECT_FALSE(imported_credit_card);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
   ResetPersonalDataManager(USER_MODE_NORMAL);
 
   // Expect that no new card is saved.
   const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results2.size());
   EXPECT_EQ(0, saved_credit_card.Compare(*results2[0]));
@@ skipping 18 matching lines @@
   base::RunLoop().Run();
 
   // Simulate a form submission with conflicting expiration year.
   FormData form;
   AddFullCreditCardForm(&form, "Biggie Smalls", "4111 1111 1111 1111", "01",
                         /* different year */ "2999");
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(ImportCreditCard(form_structure, false, &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(ImportCreditCard(
+      form_structure, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_FALSE(imported_credit_card);
 
   // Since no refresh is expected, reload the data from the database to make
   // sure no changes were written out.
   ResetPersonalDataManager(USER_MODE_NORMAL);
 
   // Expect that the saved credit card is not modified.
   const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
   ASSERT_EQ(1U, results.size());
   EXPECT_EQ(0, credit_card.Compare(*results[0]));
@@ skipping 26 matching lines @@
   test::CreateTestFormField("Zip:", "zip", "94102", "text", &field);
   form.fields.push_back(field);
 
   // Credit card section.
   AddFullCreditCardForm(&form, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_TRUE(personal_data_->ImportFormData(form_structure, false,
-                                             &imported_credit_card));
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(personal_data_->ImportFormData(
+      form_structure, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Test that the address has been saved.
   AutofillProfile expected_address(base::GenerateGUID(),
                                    "https://www.example.com");
@@ skipping 55 matching lines @@
   test::CreateTestFormField("Country:", "country", "USA", "text", &field);
   form.fields.push_back(field);
 
   // Credit card section.
   AddFullCreditCardForm(&form, "Biggie Smalls", "4111-1111-1111-1111", "01",
                         "2999");
 
   FormStructure form_structure(form);
   form_structure.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
+  bool imported_credit_card_matches_masked_server_credit_card;
   // Still returns true because the credit card import was successful.
-  EXPECT_TRUE(personal_data_->ImportFormData(form_structure, false,
-                                             &imported_credit_card));
+  EXPECT_TRUE(personal_data_->ImportFormData(
+      form_structure, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
   ASSERT_TRUE(imported_credit_card);
+  EXPECT_FALSE(imported_credit_card_matches_masked_server_credit_card);
   personal_data_->SaveImportedCreditCard(*imported_credit_card);
 
   // Verify that the web database has been updated and the notification sent.
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::RunLoop().Run();
 
   // Test that both addresses have been saved.
   EXPECT_EQ(2U, personal_data_->GetProfiles().size());
 
@@ skipping 1223 matching lines @@
   ResetPersonalDataManager(USER_MODE_NORMAL);
   EXPECT_FALSE(personal_data_->GetCreditCards().empty());
 
   personal_data_->ClearAllServerData();
 
   // Reload the database, everything should be gone.
   ResetPersonalDataManager(USER_MODE_NORMAL);
   EXPECT_TRUE(personal_data_->GetCreditCards().empty());
 }
 
-TEST_F(PersonalDataManagerTest, DontDuplicateServerCard) {
+TEST_F(PersonalDataManagerTest,
+       DuplicateMaskedServerCard_DontDuplicateFullServerCard) {

[sebsg, 2017/05/03 17:23:30]

Can you split this one in two? Like DontDuplicateFullSercerCard and
SaveCopyOfMaskedCardLocally (or something similar).

[csashi, 2017/05/03 17:43:09]

Done.

   EnableWalletCardImport();
 
   std::vector<CreditCard> server_cards;
   server_cards.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "a123"));
   test::SetCreditCardInfo(&server_cards.back(), "John Dillinger",
                           "1881" /* Visa */, "01", "2999");
   server_cards.back().SetNetworkForMaskedCard(kVisaCard);
 
   server_cards.push_back(CreditCard(CreditCard::FULL_SERVER_CARD, "c789"));
   test::SetCreditCardInfo(&server_cards.back(), "Clyde Barrow",
@@ skipping 18 matching lines @@
                             "text", &field);
   form1.fields.push_back(field);
   test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field);
   form1.fields.push_back(field);
   test::CreateTestFormField("Exp Year:", "exp_year", "2999", "text", &field);
   form1.fields.push_back(field);
 
   FormStructure form_structure1(form1);
   form_structure1.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card;
-  EXPECT_FALSE(personal_data_->ImportFormData(form_structure1, false,
-                                             &imported_credit_card));
-  EXPECT_FALSE(imported_credit_card);
+  bool imported_credit_card_matches_masked_server_credit_card;
+  EXPECT_TRUE(personal_data_->ImportFormData(
+      form_structure1, false, &imported_credit_card,
+      &imported_credit_card_matches_masked_server_credit_card));
+  ASSERT_TRUE(imported_credit_card);
+  EXPECT_TRUE(imported_credit_card_matches_masked_server_credit_card);
+  personal_data_->SaveImportedCreditCard(*imported_credit_card);
+
+  // Verify that the web database has been updated and the notification sent.
+  EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
+      .WillOnce(QuitMainMessageLoop());
+  base::RunLoop().Run();
+
+  CreditCard local_card(base::GenerateGUID(), "https://www.example.com");
+  test::SetCreditCardInfo(&local_card, "John Dillinger", "4012888888881881",
+                          "01", "2999");
+  const std::vector<CreditCard*>& results =
+      personal_data_->GetLocalCreditCards();
+  ASSERT_EQ(1U, results.size());
+  EXPECT_EQ(0, local_card.Compare(*results[0]));
+  EXPECT_EQ(3U, personal_data_->GetCreditCards().size());
 
   // A user re-types (or fills with) an unmasked card. Don't offer to save
   // here, either. Since it's unmasked, we know for certain that it's the same
   // card.
   FormData form2;
   test::CreateTestFormField("Name on card:", "name_on_card", "Clyde Barrow",
                             "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField("Card Number:", "card_number", "347666888555",
                             "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField("Exp Month:", "exp_month", "04", "text", &field);
   form2.fields.push_back(field);
   test::CreateTestFormField("Exp Year:", "exp_year", "2999", "text", &field);
   form2.fields.push_back(field);
 
   FormStructure form_structure2(form2);
   form_structure2.DetermineHeuristicTypes(nullptr /* ukm_service */);
   std::unique_ptr<CreditCard> imported_credit_card2;
-  EXPECT_FALSE(personal_data_->ImportFormData(form_structure2, false,
-                                              &imported_credit_card2));
+  EXPECT_FALSE(personal_data_->ImportFormData(
+      form_structure2, false, &imported_credit_card2,
+      &imported_credit_card_matches_masked_server_credit_card));
   EXPECT_FALSE(imported_credit_card2);
 }
 
 // Tests the SaveImportedProfile method with different profiles to make sure the
 // merge logic works correctly.
 typedef struct {
   autofill::ServerFieldType field_type;
   std::string field_value;
 } ProfileField;
 
@@ skipping 2031 matching lines @@
   // to the converted address.
   EXPECT_EQ(profiles[0]->guid(),
             personal_data_->GetCreditCards()[0]->billing_address_id());
   // Make sure that the billing address id of the new server card still refers
   // to the converted address.
   EXPECT_EQ(profiles[0]->guid(),
             personal_data_->GetCreditCards()[1]->billing_address_id());
 }
 
 }  // namespace autofill