Add card details and legal message to Android save credit card infobar.

components/autofill/core/browser/autofill_manager.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/autofill/core/browser/autofill_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 659 matching lines @@
   if (identifier < 0)
     return false;
 
   const CreditCard* credit_card = nullptr;
   const AutofillProfile* profile = nullptr;
   if (GetCreditCard(identifier, &credit_card)) {
     if (credit_card->record_type() != CreditCard::LOCAL_CARD)
       return false;
 
     if (title)
-      title->assign(credit_card->TypeAndLastFourDigits());
+      title->assign(credit_card->TypeAndLastFourDigitsForDisplay());
     if (body) {
       body->assign(l10n_util::GetStringUTF16(
           IDS_AUTOFILL_DELETE_CREDIT_CARD_SUGGESTION_CONFIRMATION_BODY));
     }
 
     return true;
   } else if (GetProfile(identifier, &profile)) {
     if (profile->record_type() != AutofillProfile::LOCAL_PROFILE)
       return false;
 
@@ skipping 150 matching lines @@
     AutofillClient::PaymentsRpcResult result,
     const base::string16& context_token,
     scoped_ptr<base::DictionaryValue> legal_message) {
   // TODO(jdonnelly): Log duration.
   if (result == AutofillClient::SUCCESS) {
     // Do *not* call payments_client_->Prepare() here. We shouldn't send
     // credentials until the user has explicitly accepted a prompt to upload.
     upload_request_.context_token = context_token;
     user_did_accept_upload_prompt_ = false;
     client_->ConfirmSaveCreditCardToCloud(
+        upload_request_.card, std::move(legal_message),
         base::Bind(&AutofillManager::OnUserDidAcceptUpload,
-                   weak_ptr_factory_.GetWeakPtr()),
-        std::move(legal_message));
+                   weak_ptr_factory_.GetWeakPtr()));
     client_->LoadRiskData(base::Bind(&AutofillManager::OnDidGetUploadRiskData,
                                      weak_ptr_factory_.GetWeakPtr()));
     AutofillMetrics::LogCardUploadDecisionMetric(
         AutofillMetrics::UPLOAD_OFFERED);
   } else {
     // If the upload details request failed, fall back to a local save. The
     // reasoning here is as follows:
     // - This will sometimes fail intermittently, in which case it might be
     // better to not fall back, because sometimes offering upload and sometimes
     // offering local save is a poor user experience.
     // - However, in some cases, our local configuration limiting the feature to
     // countries that Payments is known to support will not match Payments' own
     // determination of what country the user is located in. In these cases,
     // the upload details request will consistently fail and if we don't fall
     // back to a local save then the user will never be offered any kind of
     // credit card save.
-    client_->ConfirmSaveCreditCardLocally(base::Bind(
-        base::IgnoreResult(&PersonalDataManager::SaveImportedCreditCard),
-        base::Unretained(personal_data_), upload_request_.card));
+    client_->ConfirmSaveCreditCardLocally(
+        upload_request_.card,
+        base::Bind(
+            base::IgnoreResult(&PersonalDataManager::SaveImportedCreditCard),
+            base::Unretained(personal_data_), upload_request_.card));
     AutofillMetrics::LogCardUploadDecisionMetric(
         AutofillMetrics::UPLOAD_NOT_OFFERED_GET_UPLOAD_DETAILS_FAILED);
   }
 }
 
 void AutofillManager::OnDidUploadCard(
     AutofillClient::PaymentsRpcResult result) {
   // We don't do anything user-visible if the upload attempt fails.
   // TODO(jdonnelly): Log duration.
 }
@@ skipping 76 matching lines @@
 
     DumpAutofillData(imported_credit_card);
   }
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
   // If credit card information was submitted, we need to confirm whether to
   // save it.
   if (imported_credit_card) {
     // Don't offer to save any cards that were recently unmasked.
     for (const CreditCard& unmasked_card : recently_unmasked_cards_) {
-      if (unmasked_card.TypeAndLastFourDigits() ==
-          imported_credit_card->TypeAndLastFourDigits())
+      if (unmasked_card.TypeAndLastFourDigitsForDisplay() ==
+          imported_credit_card->TypeAndLastFourDigitsForDisplay())
         return;
     }
 
     upload_request_ = payments::PaymentsClient::UploadRequestDetails();
     if (!IsCreditCardUploadEnabled()) {
-      client_->ConfirmSaveCreditCardLocally(base::Bind(
-          base::IgnoreResult(&PersonalDataManager::SaveImportedCreditCard),
-          base::Unretained(personal_data_), *imported_credit_card));
+      client_->ConfirmSaveCreditCardLocally(
+          *imported_credit_card,
+          base::Bind(
+              base::IgnoreResult(&PersonalDataManager::SaveImportedCreditCard),
+              base::Unretained(personal_data_), *imported_credit_card));
     } else {
       // Check for a CVC in order to determine whether we can prompt the user to
       // upload their card.
       for (const auto& field : submitted_form) {
         if (field->Type().GetStorableType() == CREDIT_CARD_VERIFICATION_CODE) {
           upload_request_.cvc = field->value;
           break;
         }
       }
 
@@ skipping 710 matching lines @@
     if (i > 0)
       fputs("Next oldest form:\n", file);
   }
   fputs("\n", file);
 
   fclose(file);
 }
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 }  // namespace autofill