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

components/autofill/content/browser/wallet/wallet_client_unittest.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 "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 474 matching lines @@
         "\"use_minimal_addresses\":false"
     "}";
 
 const char kUpdateAddressValidRequest[] =
     "{"
         "\"merchant_domain\":\"https://example.com/\","
         "\"phone_number_required\":true,"
         "\"risk_params\":\"risky business\","
         "\"shipping_address\":"
         "{"
-            "\"id\":\"shipping_address_id\","
+            "\"id\":\"address_id\","
             "\"phone_number\":\"ship_phone_number\","
             "\"postal_address\":"
             "{"
                 "\"address_line\":"
                 "["
                     "\"ship_address_line_1\","
                     "\"ship_address_line_2\""
                 "],"
                 "\"administrative_area_name\":\"ship_admin_area_name\","
                 "\"country_name_code\":\"US\","
@@ skipping 17 matching lines @@
             "["
                 "\"address_line_1\","
                 "\"address_line_2\""
             "],"
             "\"administrative_area_name\":\"admin_area_name\","
             "\"country_name_code\":\"US\","
             "\"locality_name\":\"locality_name\","
             "\"postal_code_number\":\"postal_code_number\","
             "\"recipient_name\":\"recipient_name\""
         "},"
-        "\"upgraded_instrument_id\":\"instrument_id\","
+        "\"upgraded_instrument_id\":\"default_instrument_id\","
         "\"use_minimal_addresses\":false"
     "}";
 
 const char kUpdateInstrumentAddressWithNameChangeValidRequest[] =
     "{"
         "\"instrument_phone_number\":\"phone_number\","
         "\"merchant_domain\":\"https://example.com/\","
         "\"phone_number_required\":true,"
         "\"risk_params\":\"risky business\","
         "\"upgraded_billing_address\":"
         "{"
             "\"address_line\":"
             "["
                 "\"address_line_1\","
                 "\"address_line_2\""
             "],"
             "\"administrative_area_name\":\"admin_area_name\","
             "\"country_name_code\":\"US\","
             "\"locality_name\":\"locality_name\","
             "\"postal_code_number\":\"postal_code_number\","
             "\"recipient_name\":\"recipient_name\""
         "},"
-        "\"upgraded_instrument_id\":\"instrument_id\","
+        "\"upgraded_instrument_id\":\"default_instrument_id\","
         "\"use_minimal_addresses\":false"
     "}";
 
 const char kUpdateInstrumentExpirationDateValidRequest[] =
     "{"
         "\"instrument\":"
         "{"
             "\"credit_card\":"
             "{"
                 "\"exp_month\":12,"
-                "\"exp_year\":3000"
+                "\"exp_year\":3001"
             "},"
             "\"type\":\"CREDIT_CARD\""
         "},"
         "\"merchant_domain\":\"https://example.com/\","
         "\"phone_number_required\":true,"
         "\"risk_params\":\"risky business\","
         "\"upgraded_instrument_id\":\"instrument_id\","
         "\"use_minimal_addresses\":false"
     "}";
 
@@ skipping 609 matching lines @@
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet(std::string(),
                                 "saved_address_id",
                                 std::vector<RequiredAction>(),
                                 std::vector<FormFieldError>())).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
 
   scoped_ptr<Address> address = GetTestSaveableAddress();
   wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
-                               address.Pass());
+                               address.Pass(),
+                               NULL,
+                               NULL);
   VerifyAndFinishRequest(net::HTTP_OK,
                          kSaveAddressValidRequest,
                          kSaveAddressValidResponse);
 }
 
 TEST_F(WalletClientTest, SaveAddressWithRequiredActionsSucceeded) {
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletRequiredActionMetric(
       AutofillMetrics::REQUIRE_PHONE_NUMBER);
   delegate_.ExpectWalletRequiredActionMetric(
       AutofillMetrics::INVALID_FORM_FIELD);
 
   std::vector<RequiredAction> required_actions;
   required_actions.push_back(REQUIRE_PHONE_NUMBER);
   required_actions.push_back(INVALID_FORM_FIELD);
 
   std::vector<FormFieldError> form_errors;
   form_errors.push_back(FormFieldError(FormFieldError::INVALID_POSTAL_CODE,
                                        FormFieldError::SHIPPING_ADDRESS));
 
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet(std::string(),
                                 std::string(),
                                 required_actions,
                                 form_errors)).Times(1);
 
   scoped_ptr<Address> address = GetTestSaveableAddress();
   wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
-                               address.Pass());
+                               address.Pass(),
+                               NULL,
+                               NULL);
   VerifyAndFinishRequest(net::HTTP_OK,
                          kSaveAddressValidRequest,
                          kSaveAddressWithRequiredActionsValidResponse);
 }
 
 TEST_F(WalletClientTest, SaveAddressFailedInvalidRequiredAction) {
   EXPECT_CALL(delegate_,
               OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE);
   delegate_.ExpectLogWalletMalformedResponse(AutofillMetrics::SAVE_TO_WALLET);
 
   scoped_ptr<Address> address = GetTestSaveableAddress();
   wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
-                               address.Pass());
+                               address.Pass(),
+                               NULL,
+                               NULL);
   VerifyAndFinishRequest(net::HTTP_OK,
                          kSaveAddressValidRequest,
                          kSaveWithInvalidRequiredActionsResponse);
 }
 
 TEST_F(WalletClientTest, SaveAddressFailedMalformedResponse) {
   EXPECT_CALL(delegate_,
               OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE);
   delegate_.ExpectLogWalletMalformedResponse(AutofillMetrics::SAVE_TO_WALLET);
 
   scoped_ptr<Address> address = GetTestSaveableAddress();
   wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
-                               address.Pass());
+                               address.Pass(),
+                               NULL,
+                               NULL);
   VerifyAndFinishRequest(net::HTTP_OK,
                          kSaveAddressValidRequest,
                          kSaveInvalidResponse);
 }
 
 TEST_F(WalletClientTest, SaveInstrumentSucceeded) {
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet("instrument_id",
                                 std::string(),
                                 std::vector<RequiredAction>(),
                                 std::vector<FormFieldError>())).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
 
   scoped_ptr<Instrument> instrument = GetTestInstrument();
   wallet_client_->SaveToWallet(instrument.Pass(),
-                               scoped_ptr<Address>());
+                               scoped_ptr<Address>(),
+                               NULL,
+                               NULL);
 
   VerifyAndFinishFormEncodedRequest(net::HTTP_OK,
                                     kSaveInstrumentValidRequest,
                                     kSaveInstrumentValidResponse,
                                     4U);
 }
 
 TEST_F(WalletClientTest, SaveInstrumentWithRequiredActionsSucceeded) {
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
@@ skipping 11 matching lines @@
                                        FormFieldError::SHIPPING_ADDRESS));
 
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet(std::string(),
                                 std::string(),
                                 required_actions,
                                 form_errors)).Times(1);
 
   scoped_ptr<Instrument> instrument = GetTestInstrument();
   wallet_client_->SaveToWallet(instrument.Pass(),
-                               scoped_ptr<Address>());
+                               scoped_ptr<Address>(),
+                               NULL,
+                               NULL);
 
   VerifyAndFinishFormEncodedRequest(
       net::HTTP_OK,
       kSaveInstrumentValidRequest,
       kSaveInstrumentWithRequiredActionsValidResponse,
       4U);
 }
 
 TEST_F(WalletClientTest, SaveInstrumentFailedInvalidRequiredActions) {
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE);
   delegate_.ExpectLogWalletMalformedResponse(AutofillMetrics::SAVE_TO_WALLET);
 
   EXPECT_CALL(delegate_,
               OnWalletError(WalletClient::MALFORMED_RESPONSE));
 
   scoped_ptr<Instrument> instrument = GetTestInstrument();
   wallet_client_->SaveToWallet(instrument.Pass(),
-                               scoped_ptr<Address>());
+                               scoped_ptr<Address>(),
+                               NULL,
+                               NULL);
 
   VerifyAndFinishFormEncodedRequest(net::HTTP_OK,
                                     kSaveInstrumentValidRequest,
                                     kSaveWithInvalidRequiredActionsResponse,
                                     4U);
 }
 
 TEST_F(WalletClientTest, SaveInstrumentFailedMalformedResponse) {
   EXPECT_CALL(delegate_,
               OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE);
   delegate_.ExpectLogWalletMalformedResponse(AutofillMetrics::SAVE_TO_WALLET);
 
   scoped_ptr<Instrument> instrument = GetTestInstrument();
   wallet_client_->SaveToWallet(instrument.Pass(),
-                               scoped_ptr<Address>());
+                               scoped_ptr<Address>(),
+                               NULL,
+                               NULL);
 
   VerifyAndFinishFormEncodedRequest(net::HTTP_OK,
                                     kSaveInstrumentValidRequest,
                                     kSaveInvalidResponse,
                                     4U);
 }
 
 TEST_F(WalletClientTest, SaveInstrumentAndAddressSucceeded) {
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet("saved_instrument_id",
                                 "saved_address_id",
                                 std::vector<RequiredAction>(),
                                 std::vector<FormFieldError>())).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(
       AutofillMetrics::SAVE_TO_WALLET,
       1);
   delegate_.ExpectBaselineMetrics();
 
   scoped_ptr<Instrument> instrument = GetTestInstrument();
   scoped_ptr<Address> address = GetTestSaveableAddress();
-  wallet_client_->SaveToWallet(instrument.Pass(),
-                               address.Pass());
+  wallet_client_->SaveToWallet(instrument.Pass(), address.Pass(), NULL, NULL);
 
   VerifyAndFinishFormEncodedRequest(net::HTTP_OK,
                                     kSaveInstrumentAndAddressValidRequest,
                                     kSaveInstrumentAndAddressValidResponse,
                                     4U);
 }
 
 TEST_F(WalletClientTest, SaveInstrumentAndAddressWithRequiredActionsSucceeded) {
   delegate_.ExpectLogWalletApiCallDuration(
       AutofillMetrics::SAVE_TO_WALLET,
@@ skipping 13 matching lines @@
                                        FormFieldError::SHIPPING_ADDRESS));
 
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet(std::string(),
                                 std::string(),
                                 required_actions,
                                 form_errors)).Times(1);
 
   scoped_ptr<Instrument> instrument = GetTestInstrument();
   scoped_ptr<Address> address = GetTestSaveableAddress();
-  wallet_client_->SaveToWallet(instrument.Pass(),
-                               address.Pass());
+  wallet_client_->SaveToWallet(instrument.Pass(), address.Pass(), NULL, NULL);
 
   VerifyAndFinishFormEncodedRequest(
       net::HTTP_OK,
       kSaveInstrumentAndAddressValidRequest,
       kSaveInstrumentAndAddressWithRequiredActionsValidResponse,
       4U);
 }
 
 TEST_F(WalletClientTest, SaveInstrumentAndAddressFailedInvalidRequiredAction) {
   EXPECT_CALL(delegate_,
               OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(
       AutofillMetrics::SAVE_TO_WALLET,
       1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE);
   delegate_.ExpectLogWalletMalformedResponse(AutofillMetrics::SAVE_TO_WALLET);
 
   scoped_ptr<Instrument> instrument = GetTestInstrument();
   scoped_ptr<Address> address = GetTestSaveableAddress();
-  wallet_client_->SaveToWallet(instrument.Pass(),
-                               address.Pass());
+  wallet_client_->SaveToWallet(instrument.Pass(), address.Pass(), NULL, NULL);
 
   VerifyAndFinishFormEncodedRequest(net::HTTP_OK,
                                     kSaveInstrumentAndAddressValidRequest,
                                     kSaveWithInvalidRequiredActionsResponse,
                                     4U);
 }
 
 TEST_F(WalletClientTest, UpdateAddressSucceeded) {
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet(std::string(),
                                 "shipping_address_id",
                                 std::vector<RequiredAction>(),
                                 std::vector<FormFieldError>())).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
 
-  scoped_ptr<Address> address = GetTestShippingAddress();
-  address->set_object_id("shipping_address_id");
+  scoped_ptr<Address> server_address = GetTestNonDefaultShippingAddress();
+  wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
+                               GetTestShippingAddress(),
+                               NULL,
+                               server_address.get());
 
-  wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
-                               address.Pass());
   VerifyAndFinishRequest(net::HTTP_OK,
                          kUpdateAddressValidRequest,
                          kUpdateAddressValidResponse);
 }
 
 TEST_F(WalletClientTest, UpdateAddressWithRequiredActionsSucceeded) {
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletRequiredActionMetric(
       AutofillMetrics::REQUIRE_PHONE_NUMBER);
   delegate_.ExpectWalletRequiredActionMetric(
       AutofillMetrics::INVALID_FORM_FIELD);
 
   std::vector<RequiredAction> required_actions;
   required_actions.push_back(REQUIRE_PHONE_NUMBER);
   required_actions.push_back(INVALID_FORM_FIELD);
 
   std::vector<FormFieldError> form_errors;
   form_errors.push_back(FormFieldError(FormFieldError::INVALID_POSTAL_CODE,
                                        FormFieldError::SHIPPING_ADDRESS));
 
   EXPECT_CALL(delegate_, OnDidSaveToWallet(std::string(),
                                            std::string(),
                                            required_actions,
                                            form_errors)).Times(1);
 
-  scoped_ptr<Address> address = GetTestShippingAddress();
-  address->set_object_id("shipping_address_id");
+  scoped_ptr<Address> server_address = GetTestNonDefaultShippingAddress();
+  wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
+                               GetTestShippingAddress(),
+                               NULL,
+                               server_address.get());
 
-  wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
-                               address.Pass());
   VerifyAndFinishRequest(net::HTTP_OK,
                          kUpdateAddressValidRequest,
                          kUpdateWithRequiredActionsValidResponse);
 }
 
 TEST_F(WalletClientTest, UpdateAddressFailedInvalidRequiredAction) {
   EXPECT_CALL(delegate_,
               OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE);
   delegate_.ExpectLogWalletMalformedResponse(AutofillMetrics::SAVE_TO_WALLET);
 
-  scoped_ptr<Address> address = GetTestShippingAddress();
-  address->set_object_id("shipping_address_id");
+  scoped_ptr<Address> server_address = GetTestNonDefaultShippingAddress();
+  wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
+                               GetTestShippingAddress(),
+                               NULL,
+                               server_address.get());
 
-  wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
-                               address.Pass());
   VerifyAndFinishRequest(net::HTTP_OK,
                          kUpdateAddressValidRequest,
                          kSaveWithInvalidRequiredActionsResponse);
 }
 
 TEST_F(WalletClientTest, UpdateAddressMalformedResponse) {
   EXPECT_CALL(delegate_,
               OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET, 1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE);
   delegate_.ExpectLogWalletMalformedResponse(AutofillMetrics::SAVE_TO_WALLET);
 
-  scoped_ptr<Address> address = GetTestShippingAddress();
-  address->set_object_id("shipping_address_id");
+  scoped_ptr<Address> server_address = GetTestNonDefaultShippingAddress();
+  wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
+                               GetTestShippingAddress(),
+                               NULL,
+                               server_address.get());
 
-  wallet_client_->SaveToWallet(scoped_ptr<Instrument>(),
-                               address.Pass());
   VerifyAndFinishRequest(net::HTTP_OK,
                          kUpdateAddressValidRequest,
                          kUpdateMalformedResponse);
 }
 
 TEST_F(WalletClientTest, UpdateInstrumentAddressSucceeded) {
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet("instrument_id",
                                 std::string(),
                                 std::vector<RequiredAction>(),
                                 std::vector<FormFieldError>())).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET,
                                            1);
   delegate_.ExpectBaselineMetrics();
 
+  scoped_ptr<WalletItems::MaskedInstrument> server_instrument =
+      GetTestMaskedInstrument();
   wallet_client_->SaveToWallet(GetTestAddressUpgradeInstrument(),
-                               scoped_ptr<Address>());
+                               scoped_ptr<Address>(),
+                               server_instrument.get(),
+                               NULL);
 
   VerifyAndFinishRequest(net::HTTP_OK,
                          kUpdateInstrumentAddressValidRequest,
                          kUpdateInstrumentValidResponse);
 }
 
 TEST_F(WalletClientTest, UpdateInstrumentExpirationDateSuceeded) {
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet("instrument_id",
                                 std::string(),
                                 std::vector<RequiredAction>(),
                                 std::vector<FormFieldError>())).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET,
                                            1);
   delegate_.ExpectBaselineMetrics();
 
-  wallet_client_->SaveToWallet(GetTestExpirationDateChangeInstrument(),
-                               scoped_ptr<Address>());
+  scoped_ptr<Instrument> instrument = GetTestExpirationDateChangeInstrument();
+  scoped_ptr<WalletItems::MaskedInstrument> server_instrument =
+      GetTestMaskedInstrumentWithId("instrument_id");
+
+  int new_month = instrument->expiration_month();
+  int new_year = instrument->expiration_year();
+  ASSERT_TRUE(new_month != server_instrument->expiration_month() ||
+              new_year != server_instrument->expiration_year());
+
+  wallet_client_->SaveToWallet(instrument.Pass(),
+                               scoped_ptr<Address>(),
+                               server_instrument.get(),
+                               NULL);
 
   VerifyAndFinishFormEncodedRequest(net::HTTP_OK,
                                     kUpdateInstrumentExpirationDateValidRequest,
                                     kUpdateInstrumentValidResponse,
                                     3U);
 }
 
 TEST_F(WalletClientTest, UpdateInstrumentAddressWithNameChangeSucceeded) {
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet("instrument_id",
                                 std::string(),
                                 std::vector<RequiredAction>(),
                                 std::vector<FormFieldError>())).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET,
                                            1);
   delegate_.ExpectBaselineMetrics();
 
+  scoped_ptr<WalletItems::MaskedInstrument> server_instrument =
+      GetTestMaskedInstrument();
   wallet_client_->SaveToWallet(GetTestAddressNameChangeInstrument(),
-                               scoped_ptr<Address>());
+                               scoped_ptr<Address>(),
+                               server_instrument.get(),
+                               NULL);
 
   VerifyAndFinishFormEncodedRequest(
       net::HTTP_OK,
       kUpdateInstrumentAddressWithNameChangeValidRequest,
       kUpdateInstrumentValidResponse,
       3U);
 }
 
 TEST_F(WalletClientTest, UpdateInstrumentWithRequiredActionsSucceeded) {
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET,
@@ skipping 11 matching lines @@
   std::vector<FormFieldError> form_errors;
   form_errors.push_back(FormFieldError(FormFieldError::INVALID_POSTAL_CODE,
                                        FormFieldError::SHIPPING_ADDRESS));
 
   EXPECT_CALL(delegate_,
               OnDidSaveToWallet(std::string(),
                                 std::string(),
                                 required_actions,
                                 form_errors)).Times(1);
 
+  scoped_ptr<WalletItems::MaskedInstrument> server_instrument =
+      GetTestMaskedInstrument();
   wallet_client_->SaveToWallet(GetTestAddressUpgradeInstrument(),
-                               scoped_ptr<Address>());
+                               scoped_ptr<Address>(),
+                               server_instrument.get(),
+                               NULL);
 
   VerifyAndFinishRequest(net::HTTP_OK,
                          kUpdateInstrumentAddressValidRequest,
                          kUpdateWithRequiredActionsValidResponse);
 }
 
 TEST_F(WalletClientTest, UpdateInstrumentFailedInvalidRequiredAction) {
   EXPECT_CALL(delegate_,
               OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET,
                                            1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE);
   delegate_.ExpectLogWalletMalformedResponse(AutofillMetrics::SAVE_TO_WALLET);
 
+  scoped_ptr<WalletItems::MaskedInstrument> server_instrument =
+      GetTestMaskedInstrument();
   wallet_client_->SaveToWallet(GetTestAddressUpgradeInstrument(),
-                               scoped_ptr<Address>());
+                               scoped_ptr<Address>(),
+                               server_instrument.get(),
+                               NULL);
 
   VerifyAndFinishRequest(net::HTTP_OK,
                          kUpdateInstrumentAddressValidRequest,
                          kSaveWithInvalidRequiredActionsResponse);
 }
 
 TEST_F(WalletClientTest, UpdateInstrumentMalformedResponse) {
   EXPECT_CALL(delegate_,
               OnWalletError(WalletClient::MALFORMED_RESPONSE)).Times(1);
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::SAVE_TO_WALLET,
                                            1);
   delegate_.ExpectBaselineMetrics();
   delegate_.ExpectWalletErrorMetric(AutofillMetrics::WALLET_MALFORMED_RESPONSE);
   delegate_.ExpectLogWalletMalformedResponse(AutofillMetrics::SAVE_TO_WALLET);
 
+  scoped_ptr<WalletItems::MaskedInstrument> server_instrument =
+      GetTestMaskedInstrument();
   wallet_client_->SaveToWallet(GetTestAddressUpgradeInstrument(),
-                               scoped_ptr<Address>());
+                               scoped_ptr<Address>(),
+                               server_instrument.get(),
+                               NULL);
 
   VerifyAndFinishRequest(net::HTTP_OK,
                          kUpdateInstrumentAddressValidRequest,
                          kUpdateMalformedResponse);
 }
 
 TEST_F(WalletClientTest, HasRequestInProgress) {
   EXPECT_FALSE(wallet_client_->HasRequestInProgress());
   delegate_.ExpectLogWalletApiCallDuration(AutofillMetrics::GET_WALLET_ITEMS,
                                            1);
@@ skipping 53 matching lines @@
   wallet_client_->GetWalletItems();
   EXPECT_EQ(2U, wallet_client_->pending_requests_.size());
 
   wallet_client_->CancelRequests();
   EXPECT_EQ(0U, wallet_client_->pending_requests_.size());
   EXPECT_FALSE(wallet_client_->HasRequestInProgress());
 }
 
 }  // namespace wallet
 }  // namespace autofill