Prompt for expiration date for local cards.

components/autofill/core/browser/payments/full_card_request.cc

 // Copyright 2016 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/payments/full_card_request.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/autofill_client.h"
 #include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 
 namespace autofill {
 namespace payments {
 
 FullCardRequest::FullCardRequest(AutofillClient* autofill_client,
                                  payments::PaymentsClient* payments_client,
                                  PersonalDataManager* personal_data_manager)
     : autofill_client_(autofill_client),
       payments_client_(payments_client),
       personal_data_manager_(personal_data_manager),
       delegate_(nullptr),
+      should_unmask_card_(false),
       weak_ptr_factory_(this) {
   DCHECK(autofill_client_);
+  DCHECK(payments_client_);
   DCHECK(personal_data_manager_);
 }
 
 FullCardRequest::~FullCardRequest() {}
 
 void FullCardRequest::GetFullCard(const CreditCard& card,
                                   AutofillClient::UnmaskCardReason reason,
                                   base::WeakPtr<Delegate> delegate) {
   DCHECK(delegate);
 
   // Only request can be active a time. If the member variable |delegate_| is
   // already set, then immediately reject the new request through the method
   // parameter |delegate|.
   if (delegate_) {
     delegate->OnFullCardError();
     return;
   }
 
   delegate_ = delegate;
   request_.reset(new payments::PaymentsClient::UnmaskRequestDetails);
   request_->card = card;
-  bool is_masked = card.record_type() == CreditCard::MASKED_SERVER_CARD;
-  if (is_masked)
+  should_unmask_card_ = card.record_type() == CreditCard::MASKED_SERVER_CARD ||
+                        (card.record_type() == CreditCard::FULL_SERVER_CARD &&
+                         card.ShouldUpdateExpiration());
+  if (should_unmask_card_)
     payments_client_->Prepare();
 
   autofill_client_->ShowUnmaskPrompt(request_->card, reason,
                                      weak_ptr_factory_.GetWeakPtr());
 
-  if (is_masked) {
+  if (should_unmask_card_) {
     autofill_client_->LoadRiskData(
         base::Bind(&FullCardRequest::OnDidGetUnmaskRiskData,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 bool FullCardRequest::IsGettingFullCard() const {
   return !!request_;
 }
 
 void FullCardRequest::OnUnmaskResponse(const UnmaskResponse& response) {
-  // TODO(rouslan): Update the expiration date of the card on disk.
-  // http://crbug.com/606008
   if (!response.exp_month.empty())
     request_->card.SetRawInfo(CREDIT_CARD_EXP_MONTH, response.exp_month);
 
   if (!response.exp_year.empty())
     request_->card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, response.exp_year);
 
-  if (request_->card.record_type() != CreditCard::MASKED_SERVER_CARD) {
+  if (request_->card.record_type() == CreditCard::LOCAL_CARD &&

[sebsg, 2016/04/27 14:59:02]

Quick question for my understanding. In what circumstances do we unmask local
credit cards? I didn't know we did that sometimes. Thanks.

[please use gerrit instead, 2016/04/27 18:05:44]

PaymentRequest uses FullCardRequest to prompt the user for the CVC and
optionally the updated expiration date of the local card. There's no form
filling in PaymentRequest, so the user has to manually type in the CVC
somewhere. I am using AutofillClient::ShowUnmaskPrompt() for this purpose.
"ShowUnmaskPrompt()" should really be renamed into "GetCvcAndExpirationDate()",
because that's what it does, but not in this patch.

Android UI for PaymentRequest landed on trunk only a couple of days ago and is
behind a flag.

Note that the local card's CVC is not sent to the server for the actual
unmasking: line 82.

+      (!response.exp_month.empty() || !response.exp_year.empty())) {
+    personal_data_manager_->UpdateCreditCard(request_->card);
+  }
+
+  if (!should_unmask_card_) {
     if (delegate_)
       delegate_->OnFullCardDetails(request_->card, response.cvc);
-    delegate_ = nullptr;
+    Reset();
     autofill_client_->OnUnmaskVerificationResult(AutofillClient::SUCCESS);
-    request_.reset();
     return;
   }
 
   request_->user_response = response;
   if (!request_->risk_data.empty()) {
     real_pan_request_timestamp_ = base::Time::Now();
     payments_client_->UnmaskCard(*request_);
   }
 }
 
 void FullCardRequest::OnUnmaskPromptClosed() {
   if (delegate_)
     delegate_->OnFullCardError();
 
-  delegate_ = nullptr;
+  Reset();
   payments_client_->CancelRequest();
-  request_.reset();
 }
 
 void FullCardRequest::OnDidGetUnmaskRiskData(const std::string& risk_data) {
   request_->risk_data = risk_data;
   if (!request_->user_response.cvc.empty()) {
     real_pan_request_timestamp_ = base::Time::Now();
     payments_client_->UnmaskCard(*request_);
   }
 }
 
 void FullCardRequest::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);
     request_->card.set_record_type(CreditCard::FULL_SERVER_CARD);
     request_->card.SetNumber(base::UTF8ToUTF16(real_pan));
+    request_->card.SetServerStatus(CreditCard::OK);
 
     if (request_->user_response.should_store_pan)
       personal_data_manager_->UpdateServerCreditCard(request_->card);
 
     if (delegate_)
       delegate_->OnFullCardDetails(request_->card, request_->user_response.cvc);
   } else {
     if (delegate_)
       delegate_->OnFullCardError();
   }
 
+  Reset();
+  autofill_client_->OnUnmaskVerificationResult(result);
+}
+
+void FullCardRequest::Reset() {
   delegate_ = nullptr;
-  autofill_client_->OnUnmaskVerificationResult(result);
   request_.reset();
+  should_unmask_card_ = false;
 }
 
 }  // namespace payments
 }  // namespace autofill