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 590 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,
-                                AutofillClient::UNMASK_FOR_AUTOFILL,
-                                weak_ptr_factory_.GetWeakPtr());
-      client_->LoadRiskData(base::Bind(&AutofillManager::OnDidGetUnmaskRiskData,
-                                       weak_ptr_factory_.GetWeakPtr()));
+      masked_card_ = credit_card;
+      GetOrCreateFullCardRequest()->GetFullCard(
+          masked_card_, AutofillClient::UNMASK_FOR_AUTOFILL,
+          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 */);
+                             true /* is_credit_card */,
+                             base::string16() /* cvc */);
 }
 
 void AutofillManager::FillOrPreviewProfileForm(
     AutofillDriver::RendererFormDataAction action,
     int query_id,
     const FormData& form,
     const FormFieldData& field,
     const AutofillProfile& profile) {
   if (action == AutofillDriver::FORM_DATA_ACTION_FILL)
     address_form_event_logger_->OnDidFillSuggestion(profile);
 
   FillOrPreviewDataModelForm(action, query_id, form, field, profile,
-                             false /* is_credit_card */);
+                             false /* is_credit_card */,
+                             base::string16() /* cvc */);
 }
 
 void AutofillManager::FillOrPreviewForm(
     AutofillDriver::RendererFormDataAction action,
     int query_id,
     const FormData& form,
     const FormFieldData& field,
     int unique_id) {
   if (!IsValidFormData(form) || !IsValidFormFieldData(field))
     return;
 
   // NOTE: RefreshDataModels may invalidate |data_model| because it causes the
   // PersonalDataManager to reload Mac address book entries. Thus it must come
   // before GetProfile or GetCreditCard.
   if (!RefreshDataModels() || !driver_->RendererIsAvailable())
     return;
 
   const CreditCard* credit_card = nullptr;
   const AutofillProfile* profile = nullptr;
   if (GetCreditCard(unique_id, &credit_card))
     FillOrPreviewCreditCardForm(action, query_id, form, field, *credit_card);
   else if (GetProfile(unique_id, &profile))
     FillOrPreviewProfileForm(action, query_id, form, field, *profile);
 }
 
 void AutofillManager::FillCreditCardForm(int query_id,
                                          const FormData& form,
                                          const FormFieldData& field,
-                                         const CreditCard& credit_card) {
+                                         const CreditCard& credit_card,
+                                         const base::string16& cvc) {
   if (!IsValidFormData(form) || !IsValidFormFieldData(field) ||
       !driver_->RendererIsAvailable()) {
     return;
   }
 
   FillOrPreviewDataModelForm(AutofillDriver::FORM_DATA_ACTION_FILL, query_id,
-                             form, field, credit_card, true);
+                             form, field, credit_card, true, cvc);
 }
 
 void AutofillManager::OnFocusNoLongerOnForm() {
   ProcessPendingFormForUpload();
 }
 
 void AutofillManager::OnDidPreviewAutofillFormData() {
   if (test_delegate_)
     test_delegate_->DidPreviewFormData();
 }
@@ skipping 127 matching lines @@
   personal_data_->RemoveByGUID(guid);
   return true;
 }
 
 void AutofillManager::RemoveAutocompleteEntry(const base::string16& name,
                                               const base::string16& value) {
   autocomplete_history_manager_->OnRemoveAutocompleteEntry(name, value);
 }
 
 bool AutofillManager::IsShowingUnmaskPrompt() {
-  return unmask_request_.card.Compare(CreditCard()) != 0;
+  return full_card_request_ && full_card_request_->IsGettingFullCard();
 }
 
 const std::vector<FormStructure*>& AutofillManager::GetFormStructures() {
   return form_structures_.get();
 }
 
+payments::FullCardRequest* AutofillManager::GetOrCreateFullCardRequest() {
+  if (!full_card_request_) {
+    full_card_request_.reset(new payments::FullCardRequest(
+        client_, payments_client_.get(), personal_data_));
+  }
+
+  return full_card_request_.get();
+}
+
 void AutofillManager::SetTestDelegate(AutofillManagerTestDelegate* delegate) {
   test_delegate_ = delegate;
 }
 
 void AutofillManager::OnSetDataList(const std::vector<base::string16>& values,
                                     const std::vector<base::string16>& labels) {
   if (!IsValidString16Vector(values) ||
       !IsValidString16Vector(labels) ||
       values.size() != labels.size())
     return;
@@ skipping 28 matching lines @@
                                     client_->GetRapporService());
 
   // 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) {
-  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() {
-  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) {
-  AutofillMetrics::LogRealPanDuration(
-      base::Time::Now() - real_pan_request_timestamp_, result);
-  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);
-  }
-
-  client_->OnUnmaskVerificationResult(result);
+  DCHECK(full_card_request_);
+  full_card_request_->OnDidGetRealPan(result, real_pan);
 }
 
 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) {
     // Do *not* call payments_client_->Prepare() here. We shouldn't send
     // credentials until the user has explicitly accepted a prompt to upload.
@@ skipping 28 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::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::OnFullCardDetails(const CreditCard& card,
+                                        const base::string16& cvc) {
+  credit_card_form_event_logger_->OnDidFillSuggestion(masked_card_);
+  FillCreditCardForm(unmasking_query_id_, unmasking_form_, unmasking_field_,
+                     card, cvc);
+  masked_card_ = CreditCard();
+}
+
+void AutofillManager::OnFullCardError() {
+  driver_->RendererShouldClearPreviewedForm();
 }
 
 void AutofillManager::OnUserDidAcceptUpload() {
   user_did_accept_upload_prompt_ = true;
   if (!upload_request_.risk_data.empty()) {
     upload_request_.app_locale = app_locale_;
     payments_client_->UploadCard(upload_request_);
   }
 }
 
@@ skipping 266 matching lines @@
   address_form_event_logger_.reset(
       new AutofillMetrics::FormEventLogger(false /* is_for_credit_card */));
   credit_card_form_event_logger_.reset(
       new AutofillMetrics::FormEventLogger(true /* is_for_credit_card */));
   has_logged_autofill_enabled_ = false;
   has_logged_address_suggestions_count_ = false;
   did_show_suggestions_ = false;
   user_did_type_ = false;
   user_did_autofill_ = false;
   user_did_edit_autofilled_field_ = false;
-  unmask_request_ = payments::PaymentsClient::UnmaskRequestDetails();
+  masked_card_ = CreditCard();
   unmasking_query_id_ = -1;
   unmasking_form_ = FormData();
   unmasking_field_ = FormFieldData();
   forms_loaded_timestamps_.clear();
   initial_interaction_timestamp_ = TimeTicks();
   external_delegate_->Reset();
 }
 
 AutofillManager::AutofillManager(AutofillDriver* driver,
                                  AutofillClient* client,
@@ skipping 103 matching lines @@
     *credit_card = personal_data_->GetCreditCardByGUID(credit_card_id);
   return !!*credit_card;
 }
 
 void AutofillManager::FillOrPreviewDataModelForm(
     AutofillDriver::RendererFormDataAction action,
     int query_id,
     const FormData& form,
     const FormFieldData& field,
     const AutofillDataModel& data_model,
-    bool is_credit_card) {
+    bool is_credit_card,
+    const base::string16& cvc) {
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (!GetCachedFormAndField(form, field, &form_structure, &autofill_field))
     return;
 
   DCHECK(form_structure);
   DCHECK(autofill_field);
 
   FormData result = form;
 
@@ skipping 54 matching lines @@
     FieldTypeGroup field_group_type = cached_field->Type().group();
 
     if (field_group_type == NO_GROUP)
       continue;
 
     base::string16 value =
         data_model.GetInfo(cached_field->Type(), app_locale_);
     if (is_credit_card &&
         cached_field->Type().GetStorableType() ==
             CREDIT_CARD_VERIFICATION_CODE) {
-      // If this is |unmask_request_.card|, |unmask_request_.user_response.cvc|
-      // should be non-empty and vice versa.
-      value = unmask_request_.user_response.cvc;
-      DCHECK_EQ(&unmask_request_.card == &data_model, !value.empty());
+      value = cvc;
     } else if (is_credit_card && IsCreditCardExpirationType(
                                      cached_field->Type().GetStorableType()) &&
                static_cast<const CreditCard*>(&data_model)
                    ->IsExpired(base::Time::Now())) {
       // Don't fill expired cards expiration date.
       value = base::string16();
     }
 
     // Must match ForEachMatchingFormField() in form_autofill_util.cc.
     // Only notify autofilling of empty fields and the field that initiated
@@ skipping 545 matching lines @@
     if (i > 0)
       fputs("Next oldest form:\n", file);
   }
   fputs("\n", file);
 
   fclose(file);
 }
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 }  // namespace autofill