Fix DCHECK() when updating instruments with no phone number.

components/autofill/content/browser/wallet/wallet_client.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/content/browser/wallet/wallet_client.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 265 matching lines @@
   std::vector<std::string> document_ids;
   for (size_t i = 0; i < documents.size(); ++i) {
     document_ids.push_back(documents[i]->id());
   }
   DoAcceptLegalDocuments(document_ids, google_transaction_id);
 }
 
 void WalletClient::AuthenticateInstrument(
     const std::string& instrument_id,
     const std::string& card_verification_number) {
-  if (HasRequestInProgress()) {
-    pending_requests_.push(base::Bind(&WalletClient::AuthenticateInstrument,
-                                      base::Unretained(this),
-                                      instrument_id,
-                                      card_verification_number));
-    return;
-  }
-
-  DCHECK_EQ(NO_PENDING_REQUEST, request_type_);
-  request_type_ = AUTHENTICATE_INSTRUMENT;
-
   base::DictionaryValue request_dict;
   request_dict.SetString(kApiKeyKey, google_apis::GetAPIKey());
   request_dict.SetString(kRiskParamsKey, delegate_->GetRiskData());
   request_dict.SetString(kInstrumentIdKey, instrument_id);
 
   std::string json_payload;
   base::JSONWriter::Write(&request_dict, &json_payload);
 
   std::string escaped_card_verification_number = net::EscapeUrlEncodedData(
       card_verification_number, true);
 
   std::string post_body = base::StringPrintf(
       kEscrowCardVerificationNumberFormat,
       net::EscapeUrlEncodedData(json_payload, true).c_str(),
       escaped_card_verification_number.c_str());
 
   MakeWalletRequest(GetAuthenticateInstrumentUrl(user_index_),
                     post_body,
-                    kFormEncodedMimeType);
+                    kFormEncodedMimeType,
+                    AUTHENTICATE_INSTRUMENT);
 }
 
 void WalletClient::GetFullWallet(const FullWalletRequest& full_wallet_request) {
-  if (HasRequestInProgress()) {
-    pending_requests_.push(base::Bind(&WalletClient::GetFullWallet,
-                                      base::Unretained(this),
-                                      full_wallet_request));
-    return;
-  }
-
-  DCHECK_EQ(NO_PENDING_REQUEST, request_type_);
-  request_type_ = GET_FULL_WALLET;
-
   base::DictionaryValue request_dict;
   request_dict.SetString(kApiKeyKey, google_apis::GetAPIKey());
   request_dict.SetString(kRiskParamsKey, delegate_->GetRiskData());
   request_dict.SetBoolean(kUseMinimalAddresses, false);
   request_dict.SetBoolean(kPhoneNumberRequired, true);
   request_dict.SetBoolean(kNewWalletUser, full_wallet_request.new_wallet_user);
 
   request_dict.SetString(kSelectedInstrumentIdKey,
                          full_wallet_request.instrument_id);
   request_dict.SetString(kSelectedAddressIdKey, full_wallet_request.address_id);
@@ skipping 23 matching lines @@
   DCHECK_GE(num_bits, kMinBits);
 
   std::string post_body = base::StringPrintf(
       kGetFullWalletRequestFormat,
       net::EscapeUrlEncodedData(json_payload, true).c_str(),
       base::HexEncode(&num_bits, 1).c_str(),
       base::HexEncode(&(one_time_pad_[0]), one_time_pad_.size()).c_str());
 
   MakeWalletRequest(GetGetFullWalletUrl(user_index_),
                     post_body,
-                    kFormEncodedMimeType);
+                    kFormEncodedMimeType,
+                    GET_FULL_WALLET);
 }
 
-void WalletClient::SaveToWallet(scoped_ptr<Instrument> instrument,
-                                scoped_ptr<Address> address) {
+void WalletClient::SaveToWallet(
+    scoped_ptr<Instrument> instrument,
+    scoped_ptr<Address> address,
+    const WalletItems::MaskedInstrument* reference_instrument,
+    const Address* reference_address) {
   DCHECK(instrument || address);
-  if (HasRequestInProgress()) {
-    pending_requests_.push(base::Bind(&WalletClient::SaveToWallet,
-                                      base::Unretained(this),
-                                      base::Passed(&instrument),
-                                      base::Passed(&address)));
-    return;
-  }
-
-  DCHECK_EQ(NO_PENDING_REQUEST, request_type_);
-  request_type_ = SAVE_TO_WALLET;
 
   base::DictionaryValue request_dict;
   request_dict.SetString(kApiKeyKey, google_apis::GetAPIKey());
   request_dict.SetString(kRiskParamsKey, delegate_->GetRiskData());
   request_dict.SetString(kMerchantDomainKey,
                          source_url_.GetWithEmptyPath().spec());
   request_dict.SetBoolean(kUseMinimalAddresses, false);
   request_dict.SetBoolean(kPhoneNumberRequired, true);
 
   std::string primary_account_number;
   std::string card_verification_number;
   if (instrument) {
     primary_account_number = net::EscapeUrlEncodedData(
         UTF16ToUTF8(instrument->primary_account_number()), true);
     card_verification_number = net::EscapeUrlEncodedData(
         UTF16ToUTF8(instrument->card_verification_number()), true);
 
-    if (instrument->object_id().empty()) {
+    if (!reference_instrument) {
       request_dict.Set(kInstrumentKey, instrument->ToDictionary().release());
       request_dict.SetString(kInstrumentPhoneNumberKey,
                              instrument->address()->phone_number());
     } else {
-      DCHECK(instrument->address() ||
-             (instrument->expiration_month() > 0 &&
-              instrument->expiration_year() > 0));
+      DCHECK(!reference_instrument->object_id().empty());
+
+      int new_month = instrument->expiration_month();
+      int new_year = instrument->expiration_year();
+      bool expiration_date_changed =
+          new_month != reference_instrument->expiration_month() ||
+          new_year != reference_instrument->expiration_year();
+
+      DCHECK(instrument->address() || expiration_date_changed);
 
       request_dict.SetString(kUpgradedInstrumentIdKey,
-                             instrument->object_id());
+                             reference_instrument->object_id());
 
       if (instrument->address()) {
         request_dict.SetString(kInstrumentPhoneNumberKey,
                                instrument->address()->phone_number());
         request_dict.Set(
             kUpgradedBillingAddressKey,
             instrument->address()->ToDictionaryWithoutID().release());
       }
 
-      if (instrument->expiration_month() > 0 &&
-          instrument->expiration_year() > 0) {
+      if (expiration_date_changed) {
+        // Updating expiration date requires a CVC.
         DCHECK(!instrument->card_verification_number().empty());
         request_dict.SetInteger(kInstrumentExpMonthKey,
                                 instrument->expiration_month());
         request_dict.SetInteger(kInstrumentExpYearKey,
                                 instrument->expiration_year());
       }
 
       if (request_dict.HasKey(kInstrumentKey))
         request_dict.SetString(kInstrumentType, "CREDIT_CARD");
     }
   }
   if (address) {
+    if (reference_address) {
+      address->set_object_id(reference_address->object_id());
+      DCHECK(!address->object_id().empty());
+    }
     request_dict.Set(kShippingAddressKey,
                      address->ToDictionaryWithID().release());
   }
 
   std::string json_payload;
   base::JSONWriter::Write(&request_dict, &json_payload);
 
   if (!card_verification_number.empty()) {
     std::string post_body;
     if (!primary_account_number.empty()) {
       post_body = base::StringPrintf(
           kEscrowNewInstrumentFormat,
           net::EscapeUrlEncodedData(json_payload, true).c_str(),
           card_verification_number.c_str(),
           primary_account_number.c_str());
     } else {
       post_body = base::StringPrintf(
           kEscrowCardVerificationNumberFormat,
           net::EscapeUrlEncodedData(json_payload, true).c_str(),
           card_verification_number.c_str());
     }
     MakeWalletRequest(GetSaveToWalletUrl(user_index_),
                       post_body,
-                      kFormEncodedMimeType);
+                      kFormEncodedMimeType,
+                      SAVE_TO_WALLET);
   } else {
     MakeWalletRequest(GetSaveToWalletNoEscrowUrl(user_index_),
                       json_payload,
-                      kJsonMimeType);
+                      kJsonMimeType,
+                      SAVE_TO_WALLET);
   }
 }
 
 void WalletClient::GetWalletItems() {
-  if (HasRequestInProgress()) {
-    pending_requests_.push(base::Bind(&WalletClient::GetWalletItems,
-                                      base::Unretained(this)));
-    return;
-  }
-
-  DCHECK_EQ(NO_PENDING_REQUEST, request_type_);
-  request_type_ = GET_WALLET_ITEMS;
-
   base::DictionaryValue request_dict;
   request_dict.SetString(kApiKeyKey, google_apis::GetAPIKey());
   request_dict.SetString(kMerchantDomainKey,
                          source_url_.GetWithEmptyPath().spec());
   request_dict.SetBoolean(kShippingAddressRequired,
                           delegate_->IsShippingAddressRequired());
   request_dict.SetBoolean(kUseMinimalAddresses, false);
   request_dict.SetBoolean(kPhoneNumberRequired, true);
 
   std::string post_body;
   base::JSONWriter::Write(&request_dict, &post_body);
 
   MakeWalletRequest(GetGetWalletItemsUrl(user_index_),
                     post_body,
-                    kJsonMimeType);
+                    kJsonMimeType,
+                    GET_WALLET_ITEMS);
 }
 
 bool WalletClient::HasRequestInProgress() const {
   return request_;
 }
 
 void WalletClient::CancelRequests() {
   request_.reset();
   request_type_ = NO_PENDING_REQUEST;
   while (!pending_requests_.empty()) {
     pending_requests_.pop();
   }
 }
 
 void WalletClient::DoAcceptLegalDocuments(
     const std::vector<std::string>& document_ids,
     const std::string& google_transaction_id) {
-  if (HasRequestInProgress()) {
-    pending_requests_.push(base::Bind(&WalletClient::DoAcceptLegalDocuments,
-                                      base::Unretained(this),
-                                      document_ids,
-                                      google_transaction_id));
-    return;
-  }
-
-  DCHECK_EQ(NO_PENDING_REQUEST, request_type_);
-  request_type_ = ACCEPT_LEGAL_DOCUMENTS;
-
   base::DictionaryValue request_dict;
   request_dict.SetString(kApiKeyKey, google_apis::GetAPIKey());
   request_dict.SetString(kGoogleTransactionIdKey, google_transaction_id);
   request_dict.SetString(kMerchantDomainKey,
                          source_url_.GetWithEmptyPath().spec());
   scoped_ptr<base::ListValue> docs_list(new base::ListValue());
   for (std::vector<std::string>::const_iterator it = document_ids.begin();
        it != document_ids.end(); ++it) {
     if (!it->empty())
       docs_list->AppendString(*it);
   }
   request_dict.Set(kAcceptedLegalDocumentKey, docs_list.release());
 
   std::string post_body;
   base::JSONWriter::Write(&request_dict, &post_body);
 
   MakeWalletRequest(GetAcceptLegalDocumentsUrl(user_index_),
                     post_body,
-                    kJsonMimeType);
+                    kJsonMimeType,
+                    ACCEPT_LEGAL_DOCUMENTS);
 }
 
 void WalletClient::MakeWalletRequest(const GURL& url,
                                      const std::string& post_body,
-                                     const std::string& mime_type) {
-  DCHECK(!HasRequestInProgress());
+                                     const std::string& mime_type,
+                                     RequestType request_type) {
+  if (HasRequestInProgress()) {
+    pending_requests_.push(base::Bind(&WalletClient::MakeWalletRequest,
+                                      base::Unretained(this),
+                                      url,
+                                      post_body,
+                                      mime_type,
+                                      request_type));
+    return;
+  }
+
+  DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
+  request_type_ = request_type;
 
   request_.reset(net::URLFetcher::Create(
       0, url, net::URLFetcher::POST, this));
   request_->SetRequestContext(context_getter_.get());
   VLOG(1) << "Making request to " << url << " with post_body=" << post_body;
   request_->SetUploadData(mime_type, post_body);
   request_->AddExtraRequestHeader("Authorization: GoogleLogin auth=" +
                                   delegate_->GetWalletCookieValue());
   DVLOG(1) << "Setting authorization header value to "
            << delegate_->GetWalletCookieValue();
@@ skipping 263 matching lines @@
       NOTREACHED();
       return AutofillMetrics::UNKNOWN_API_CALL;
   }
 
   NOTREACHED();
   return AutofillMetrics::UNKNOWN_API_CALL;
 }
 
 }  // namespace wallet
 }  // namespace autofill