Card unmasking without form filling

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 226 matching lines @@
   // work if the delegate has a pointer to the AutofillManager, but
   // future directions may not need such a pointer.
   external_delegate_ = delegate;
   autocomplete_history_manager_->SetExternalDelegate(delegate);
 }
 
 void AutofillManager::ShowAutofillSettings() {
   client_->ShowAutofillSettings();
 }
 
+void AutofillManager::UnmaskCardForPayment(const CreditCard& maybe_masked_card,
+                                           const UnmaskCallback& callback) {
+  if (unmask_callback_) {
+    callback.Run(false, maybe_masked_card, maybe_masked_card, base::string16());
+    return;
+  }
+
+  unmask_callback_.reset(new UnmaskCallback(callback));
+  unmask_request_.card = maybe_masked_card;
+  bool is_masked =
+      maybe_masked_card.record_type() == CreditCard::MASKED_SERVER_CARD;
+
+  if (is_masked)
+    payments_client_->Prepare();
+
+  client_->ShowUnmaskPrompt(unmask_request_.card,

[Mathieu, 2016/04/19 13:24:25]

can you mention why we're calling ShowUnmaskPrompt if the card is unmasked? I
understand that if called from |autofill_manager_| it will be with a masked
card, but it's not immediately obvious why other callers need this.

+                            weak_ptr_factory_.GetWeakPtr());
+
+  if (is_masked) {
+    client_->LoadRiskData(base::Bind(&AutofillManager::OnDidGetUnmaskRiskData,
+                                     weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
 bool AutofillManager::ShouldShowScanCreditCard(const FormData& form,
                                                const FormFieldData& field) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableCreditCardScan)) {
     return false;
   }
 
   if (base::FieldTrialList::FindFullName("CreditCardScan") == "Control" &&
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableCreditCardScan)) {
@@ skipping 343 matching lines @@
 
 void AutofillManager::FillOrPreviewCreditCardForm(
     AutofillDriver::RendererFormDataAction action,
     int query_id,
     const FormData& form,
     const FormFieldData& field,
     const CreditCard& credit_card) {
   if (action == AutofillDriver::FORM_DATA_ACTION_FILL) {
     if (credit_card.record_type() == CreditCard::MASKED_SERVER_CARD &&
         WillFillCreditCardNumber(form, field)) {
-      unmask_request_.card = credit_card;
       unmasking_query_id_ = query_id;
       unmasking_form_ = form;
       unmasking_field_ = field;
-      payments_client_->Prepare();
-      client_->ShowUnmaskPrompt(unmask_request_.card,
-                                weak_ptr_factory_.GetWeakPtr());
-      client_->LoadRiskData(base::Bind(&AutofillManager::OnDidGetUnmaskRiskData,
-                                       weak_ptr_factory_.GetWeakPtr()));
+      UnmaskCardForPayment(credit_card,
+                           base::Bind(&AutofillManager::OnCardUnmasked,
+                                      weak_ptr_factory_.GetWeakPtr()));
       credit_card_form_event_logger_->OnDidSelectMaskedServerCardSuggestion();
       return;
     }
     credit_card_form_event_logger_->OnDidFillSuggestion(credit_card);
   }
 
   FillOrPreviewDataModelForm(action, query_id, form, field, credit_card,
                              true /* is_credit_card */);
 }
 
@@ skipping 240 matching lines @@
 
   // Forward form structures to the password generation manager to detect
   // account creation forms.
   driver_->PropagateAutofillPredictions(queried_forms);
 
   // If the corresponding flag is set, annotate forms with the predicted types.
   driver_->SendAutofillTypePredictionsToRenderer(queried_forms);
 }
 
 void AutofillManager::OnUnmaskResponse(const UnmaskResponse& response) {
+  DCHECK(unmask_callback_);
+
+  if (unmask_request_.card.record_type() != CreditCard::MASKED_SERVER_CARD) {
+    unmask_callback_->Run(true, unmask_request_.card, unmask_request_.card,
+                          response.cvc);
+    unmask_callback_.reset();
+    client_->OnUnmaskVerificationResult(AutofillClient::SUCCESS);
+    return;
+  }
+
   unmask_request_.user_response = response;
   if (!unmask_request_.risk_data.empty()) {
     real_pan_request_timestamp_ = base::Time::Now();
     payments_client_->UnmaskCard(unmask_request_);
   }
 }
 
 void AutofillManager::OnUnmaskPromptClosed() {
+  if (unmask_callback_) {
+    unmask_callback_->Run(false, unmask_request_.card, unmask_request_.card,
+                          base::string16());
+    unmask_callback_.reset();
+  }
   payments_client_->CancelRequest();
-  driver_->RendererShouldClearPreviewedForm();
   unmask_request_ = payments::PaymentsClient::UnmaskRequestDetails();
 }
 
 IdentityProvider* AutofillManager::GetIdentityProvider() {
   return client_->GetIdentityProvider();
 }
 
 void AutofillManager::OnDidGetRealPan(AutofillClient::PaymentsRpcResult result,
                                       const std::string& real_pan) {
+  DCHECK(unmask_callback_);
   AutofillMetrics::LogRealPanDuration(
       base::Time::Now() - real_pan_request_timestamp_, result);
+  CreditCard original = unmask_request_.card;
   if (!real_pan.empty()) {
     DCHECK_EQ(AutofillClient::SUCCESS, result);
-    credit_card_form_event_logger_->OnDidFillSuggestion(unmask_request_.card);
     unmask_request_.card.set_record_type(CreditCard::FULL_SERVER_CARD);
     unmask_request_.card.SetNumber(base::UTF8ToUTF16(real_pan));
     if (!unmask_request_.user_response.exp_month.empty()) {
       unmask_request_.card.SetRawInfo(CREDIT_CARD_EXP_MONTH,
                                       unmask_request_.user_response.exp_month);
     }
     if (!unmask_request_.user_response.exp_year.empty()) {
       unmask_request_.card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR,
                                       unmask_request_.user_response.exp_year);
     }
     if (unmask_request_.user_response.should_store_pan)
       personal_data_->UpdateServerCreditCard(unmask_request_.card);
+  }
 
-    FillCreditCardForm(unmasking_query_id_, unmasking_form_, unmasking_field_,
-                       unmask_request_.card);
-  }
+  unmask_callback_->Run(!real_pan.empty() && result == AutofillClient::SUCCESS,
+                        original, unmask_request_.card,
+                        unmask_request_.user_response.cvc);
+  unmask_callback_.reset();
 
   client_->OnUnmaskVerificationResult(result);
 }
 
 void AutofillManager::OnDidGetUploadDetails(
     AutofillClient::PaymentsRpcResult result,
     const base::string16& context_token,
     std::unique_ptr<base::DictionaryValue> legal_message) {
   // TODO(jdonnelly): Log duration.
   if (result == AutofillClient::SUCCESS) {
@@ skipping 30 matching lines @@
         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.
 }
 
+void AutofillManager::OnCardUnmasked(bool success,
+                                     const CreditCard& original_card,
+                                     const CreditCard& unmasked_card,
+                                     const base::string16& unused_cvc) {
+  if (success) {
+    credit_card_form_event_logger_->OnDidFillSuggestion(original_card);
+    FillCreditCardForm(unmasking_query_id_, unmasking_form_, unmasking_field_,

[Mathieu, 2016/04/19 13:24:24]

curious, if the CVC is unused here, where is it taken from when filling the
form?

+                       unmasked_card);
+  } else {
+    driver_->RendererShouldClearPreviewedForm();
+  }
+}
+
 void AutofillManager::OnDidGetUnmaskRiskData(const std::string& risk_data) {
   unmask_request_.risk_data = risk_data;
   if (!unmask_request_.user_response.cvc.empty()) {
     real_pan_request_timestamp_ = base::Time::Now();
     payments_client_->UnmaskCard(unmask_request_);
   }
 }
 
 void AutofillManager::OnUserDidAcceptUpload() {
   user_did_accept_upload_prompt_ = true;
@@ skipping 1038 matching lines @@
     if (i > 0)
       fputs("Next oldest form:\n", file);
   }
   fputs("\n", file);
 
   fclose(file);
 }
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 }  // namespace autofill