rAc Wallet extirpation round 4: clean out RPC code

components/autofill/content/browser/wallet/wallet_test_util.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_test_util.h"
 
 #include <string>
 #include <vector>
 
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/autofill/content/browser/wallet/full_wallet.h"
-#include "components/autofill/content/browser/wallet/gaia_account.h"
-#include "components/autofill/content/browser/wallet/instrument.h"
-#include "components/autofill/content/browser/wallet/required_action.h"
 #include "components/autofill/content/browser/wallet/wallet_address.h"
 
 using base::ASCIIToUTF16;
 
 namespace autofill {
 namespace wallet {
 
 namespace {
 
 int FutureYear() {
   // "In the Year 3000." - Richie "LaBamba" Rosenberg
   return 3000;
 }
 
 }  // namespace
 
-scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentWithDetails(
-    const std::string& id,
-    scoped_ptr<Address> address,
-    WalletItems::MaskedInstrument::Type type,
-    WalletItems::MaskedInstrument::Status status) {
-  return make_scoped_ptr(
-      new WalletItems::MaskedInstrument(ASCIIToUTF16("descriptive_name"),
-                                        type,
-                                        ASCIIToUTF16("1111"),
-                                        12,
-                                        FutureYear(),
-                                        address.Pass(),
-                                        status,
-                                        id));
-}
-
-scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentWithId(
-    const std::string& id) {
-  return GetTestMaskedInstrumentWithDetails(
-      id,
-      GetTestAddress(),
-      WalletItems::MaskedInstrument::VISA,
-      WalletItems::MaskedInstrument::VALID);
-}
-
-scoped_ptr<WalletItems::MaskedInstrument>
-GetTestMaskedInstrumentWithIdAndAddress(
-    const std::string& id, scoped_ptr<Address> address) {
-  return GetTestMaskedInstrumentWithDetails(
-      id,
-      address.Pass(),
-      WalletItems::MaskedInstrument::VISA,
-      WalletItems::MaskedInstrument::VALID);
-}
-
-scoped_ptr<GaiaAccount> GetTestGaiaAccount() {
-  return GaiaAccount::CreateForTesting("user@chromium.org",
-                                       "obfuscated_id",
-                                       0,
-                                       true);
-}
-
 std::vector<base::string16> StreetAddress(const std::string& line1,
                                           const std::string& line2) {
   std::vector<base::string16> street_address;
   street_address.push_back(ASCIIToUTF16(line1));
   street_address.push_back(ASCIIToUTF16(line2));
   return street_address;
 }
 
 scoped_ptr<Address> GetTestAddress() {
   return make_scoped_ptr(
@@ skipping 10 matching lines @@
                   "language_code"));
 }
 
 scoped_ptr<Address> GetTestMinimalAddress() {
   scoped_ptr<Address> address = GetTestAddress();
   address->set_is_complete_address(false);
   return address.Pass();
 }
 
 scoped_ptr<FullWallet> GetTestFullWallet() {
-  return GetTestFullWalletWithRequiredActions(std::vector<RequiredAction>());
-}
-
-scoped_ptr<FullWallet> GetTestFullWalletWithRequiredActions(
-    const std::vector<RequiredAction>& actions) {
-  scoped_ptr<FullWallet> wallet(new FullWallet(FutureYear(),
-                                               12,
-                                               "528512",
-                                               "5ec4feecf9d6",
-                                               GetTestAddress(),
-                                               GetTestShippingAddress(),
-                                               actions));
+  scoped_ptr<FullWallet> wallet(new FullWallet(FutureYear(), 12, "528512",
+                                               "5ec4feecf9d6", GetTestAddress(),
+                                               GetTestShippingAddress()));
   std::vector<uint8> one_time_pad;
   base::HexStringToBytes("5F04A8704183", &one_time_pad);
   wallet->set_one_time_pad(one_time_pad);
   return wallet.Pass();
 }
 
 scoped_ptr<FullWallet> GetTestFullWalletInstrumentOnly() {
-  scoped_ptr<FullWallet> wallet(new FullWallet(FutureYear(),
-                                               12,
-                                               "528512",
-                                               "5ec4feecf9d6",
-                                               GetTestAddress(),
-                                               scoped_ptr<Address>(),
-                                               std::vector<RequiredAction>()));
+  scoped_ptr<FullWallet> wallet(new FullWallet(FutureYear(), 12, "528512",
+                                               "5ec4feecf9d6", GetTestAddress(),
+                                               scoped_ptr<Address>()));
   std::vector<uint8> one_time_pad;
   base::HexStringToBytes("5F04A8704183", &one_time_pad);
   wallet->set_one_time_pad(one_time_pad);
   return wallet.Pass();
 }
 
-scoped_ptr<Instrument> GetTestInstrument() {
-  return make_scoped_ptr(new Instrument(ASCIIToUTF16("4444444444444448"),
-                                        ASCIIToUTF16("123"),
-                                        12,
-                                        FutureYear(),
-                                        Instrument::VISA,
-                                        GetTestAddress()));
-}
-
-scoped_ptr<Instrument> GetTestAddressUpgradeInstrument() {
-  return make_scoped_ptr(new Instrument(base::string16(),
-                                        base::string16(),
-                                        12,
-                                        FutureYear(),
-                                        Instrument::UNKNOWN,
-                                        GetTestAddress()));
-}
-
-scoped_ptr<Instrument> GetTestExpirationDateChangeInstrument() {
-  return make_scoped_ptr(new Instrument(base::string16(),
-                                        ASCIIToUTF16("123"),
-                                        12,
-                                        FutureYear() + 1,
-                                        Instrument::UNKNOWN,
-                                        scoped_ptr<Address>()));
-}
-
-scoped_ptr<Instrument> GetTestAddressNameChangeInstrument() {
-  return make_scoped_ptr(new Instrument(base::string16(),
-                                        ASCIIToUTF16("123"),
-                                        12,
-                                        FutureYear(),
-                                        Instrument::UNKNOWN,
-                                        GetTestAddress()));
-}
-
-scoped_ptr<WalletItems::LegalDocument> GetTestLegalDocument() {
-  base::DictionaryValue dict;
-  dict.SetString("legal_document_id", "document_id");
-  dict.SetString("url", "https://example.com");
-  dict.SetString("display_name", "display_name");
-  return wallet::WalletItems::LegalDocument::CreateLegalDocument(dict);
-}
-
-scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrument() {
-  return GetTestMaskedInstrumentWithId("default_instrument_id");
-}
-
-scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentExpired() {
-  return GetTestMaskedInstrumentWithDetails(
-      "default_instrument_id",
-      GetTestAddress(),
-      WalletItems::MaskedInstrument::VISA,
-      WalletItems::MaskedInstrument::EXPIRED);
-}
-
-scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentInvalid() {
-  return GetTestMaskedInstrumentWithDetails(
-      "default_instrument_id",
-      GetTestAddress(),
-      WalletItems::MaskedInstrument::VISA,
-      WalletItems::MaskedInstrument::DECLINED);
-}
-
-scoped_ptr<WalletItems::MaskedInstrument> GetTestMaskedInstrumentAmex(
-    AmexPermission amex_permission) {
-  return GetTestMaskedInstrumentWithDetails(
-      "default_instrument_id",
-      GetTestAddress(),
-      WalletItems::MaskedInstrument::AMEX,
-      amex_permission == AMEX_ALLOWED ?
-          WalletItems::MaskedInstrument::VALID :
-          WalletItems::MaskedInstrument::AMEX_NOT_SUPPORTED);
-}
-
-scoped_ptr<WalletItems::MaskedInstrument> GetTestNonDefaultMaskedInstrument() {
-  return GetTestMaskedInstrumentWithId("instrument_id");
-}
-
 scoped_ptr<Address> GetTestSaveableAddress() {
   return make_scoped_ptr(
       new Address("US",
                   ASCIIToUTF16("save_recipient_name"),
                   StreetAddress("save_address_line_1", "save_address_line_2"),
                   ASCIIToUTF16("save_locality_name"),
                   ASCIIToUTF16("save_dependent_locality_name"),
                   ASCIIToUTF16("save_admin_area_name"),
                   ASCIIToUTF16("save_postal_code_number"),
                   ASCIIToUTF16("save_sorting_code"),
@@ skipping 16 matching lines @@
                   "default_address_id",
                   "ship_language_code"));
 }
 
 scoped_ptr<Address> GetTestNonDefaultShippingAddress() {
   scoped_ptr<Address> address = GetTestShippingAddress();
   address->set_object_id("address_id");
   return address.Pass();
 }
 
-scoped_ptr<WalletItems> GetTestWalletItemsWithDetails(
-    const std::vector<RequiredAction>& required_actions,
-    const std::string& default_instrument_id,
-    const std::string& default_address_id,
-    AmexPermission amex_permission) {
-  return make_scoped_ptr(new wallet::WalletItems(required_actions,
-                                                 "google_transaction_id",
-                                                 default_instrument_id,
-                                                 default_address_id,
-                                                 amex_permission));
-}
-
-scoped_ptr<WalletItems> GetTestWalletItemsWithRequiredAction(
-    RequiredAction action) {
-  std::vector<RequiredAction> required_actions(1, action);
-  scoped_ptr<WalletItems> items =
-      GetTestWalletItemsWithDetails(required_actions,
-                                    "default_instrument_id",
-                                    "default_address_id",
-                                    AMEX_ALLOWED);
-
-  if (action != GAIA_AUTH)
-    items->AddAccount(GetTestGaiaAccount());
-
-  return items.Pass();
-}
-
-scoped_ptr<WalletItems> GetTestWalletItems(AmexPermission amex_permission) {
-  return GetTestWalletItemsWithDefaultIds("default_instrument_id",
-                                          "default_address_id",
-                                          amex_permission);
-}
-
-scoped_ptr<WalletItems> GetTestWalletItemsWithUsers(
-    const std::vector<std::string>& users, size_t active_index) {
-  scoped_ptr<WalletItems> items =
-      GetTestWalletItemsWithDetails(std::vector<RequiredAction>(),
-                                    "default_instrument_id",
-                                    "default_address_id",
-                                    AMEX_ALLOWED);
-  for (size_t i = 0; i < users.size(); ++i) {
-    scoped_ptr<GaiaAccount> account(GaiaAccount::CreateForTesting(
-        users[i], "obfuscated_id", i, i == active_index));
-    items->AddAccount(account.Pass());
-  }
-  return items.Pass();
-}
-
-scoped_ptr<WalletItems> GetTestWalletItemsWithDefaultIds(
-    const std::string& default_instrument_id,
-    const std::string& default_address_id,
-    AmexPermission amex_permission) {
-  scoped_ptr<WalletItems> items =
-      GetTestWalletItemsWithDetails(std::vector<RequiredAction>(),
-                                    default_instrument_id,
-                                    default_address_id,
-                                    amex_permission);
-  items->AddAccount(GetTestGaiaAccount());
-  return items.Pass();
-}
-
 }  // namespace wallet
 }  // namespace autofill