In components/autofill, move browser/wallet/ to content/browser/wallet/

This change is part of moving components/autofill into its eventual structure
as a layered component. As part of this move, this CL renames the
autofill_test_util target (which contains only util code for testing wallet) to
autofill_content_test_util.

TBR=joi, thakis
BUG=247015

Review URL: https://chromiumcodereview.appspot.com/16579003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@205259 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 141 insertions, 0 deletions

diff --git a/components/autofill/content/browser/wallet/instrument.cc b/components/autofill/content/browser/wallet/instrument.cc
new file mode 100644
index 0000000..6c94b60
--- /dev/null
+++ b/components/autofill/content/browser/wallet/instrument.cc
@@ -0,0 +1,141 @@
+// 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/instrument.h"
+
+#include "base/logging.h"
+#include "base/string_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
+#include "components/autofill/browser/autofill_country.h"
+#include "components/autofill/browser/autofill_profile.h"
+#include "components/autofill/browser/credit_card.h"
+#include "components/autofill/browser/validation.h"
+#include "components/autofill/content/browser/wallet/wallet_address.h"
+
+namespace autofill {
+namespace wallet {
+
+namespace {
+
+// Converts a known Autofill card type to a Instrument::FormOfPayment.
+// Used for creating new Instruments.
+Instrument::FormOfPayment FormOfPaymentFromCardType(const std::string& type) {
+  if (type == kAmericanExpressCard)
+    return Instrument::AMEX;
+  else if (type == kDiscoverCard)
+    return Instrument::DISCOVER;
+  else if (type == kMasterCard)
+    return Instrument::MASTER_CARD;
+  else if (type == kVisaCard)
+    return Instrument::VISA;
+
+  return Instrument::UNKNOWN;
+}
+
+std::string FormOfPaymentToString(Instrument::FormOfPayment form_of_payment) {
+  switch (form_of_payment) {
+    case Instrument::UNKNOWN:
+      return "UNKNOWN";
+    case Instrument::VISA:
+      return "VISA";
+    case Instrument::MASTER_CARD:
+      return "MASTER_CARD";
+    case Instrument::AMEX:
+      return "AMEX";
+    case Instrument::DISCOVER:
+      return "DISCOVER";
+    case Instrument::JCB:
+      return "JCB";
+  }
+  NOTREACHED();
+  return "NOT_POSSIBLE";
+}
+
+}  // namespace
+
+Instrument::Instrument(const CreditCard& card,
+                       const base::string16& card_verification_number,
+                       const AutofillProfile& profile)
+    : primary_account_number_(card.GetRawInfo(CREDIT_CARD_NUMBER)),
+      card_verification_number_(card_verification_number),
+      expiration_month_(card.expiration_month()),
+      expiration_year_(card.expiration_year()),
+      form_of_payment_(FormOfPaymentFromCardType(card.type())),
+      address_(new Address(profile)) {
+  Init();
+}
+
+Instrument::Instrument(const base::string16& primary_account_number,
+                       const base::string16& card_verification_number,
+                       int expiration_month,
+                       int expiration_year,
+                       FormOfPayment form_of_payment,
+                       scoped_ptr<Address> address)
+    : primary_account_number_(primary_account_number),
+      card_verification_number_(card_verification_number),
+      expiration_month_(expiration_month),
+      expiration_year_(expiration_year),
+      form_of_payment_(form_of_payment),
+      address_(address.Pass()) {
+  DCHECK(address_);
+  Init();
+}
+
+Instrument::Instrument(const Instrument& instrument)
+    : primary_account_number_(instrument.primary_account_number()),
+      card_verification_number_(instrument.card_verification_number()),
+      expiration_month_(instrument.expiration_month()),
+      expiration_year_(instrument.expiration_year()),
+      form_of_payment_(instrument.form_of_payment()),
+      address_(new Address(instrument.address())) {
+  Init();
+}
+
+Instrument::~Instrument() {}
+
+scoped_ptr<base::DictionaryValue> Instrument::ToDictionary() const {
+  // |primary_account_number_| and |card_verification_number_| can never be
+  // sent the server in way that would require putting them into a dictionary.
+  // Never add them to this function.
+
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  dict->SetString("type", "CREDIT_CARD");
+  dict->SetInteger("credit_card.exp_month", expiration_month_);
+  dict->SetInteger("credit_card.exp_year", expiration_year_);
+  dict->SetString("credit_card.fop_type",
+                  FormOfPaymentToString(form_of_payment_));
+  dict->SetString("credit_card.last_4_digits", last_four_digits_);
+  dict->Set("credit_card.address",
+            address_.get()->ToDictionaryWithoutID().release());
+
+  return dict.Pass();
+}
+
+bool Instrument::IsValid() const {
+  if (!IsStringASCII(primary_account_number_))
+    return false;
+  bool primary_account_number_valid =
+      autofill::IsValidCreditCardNumber(primary_account_number_);
+  bool card_verification_number_valid = card_verification_number_.size() == 3 ||
+                                        card_verification_number_.size() == 4;
+  bool exp_month_valid = expiration_month_ >= 1 && expiration_month_ <= 12;
+  bool exp_year_valid = expiration_year_ >= 2013 && expiration_year_ <= 2100;
+
+  return primary_account_number_valid &&
+         card_verification_number_valid &&
+         exp_month_valid &&
+         exp_year_valid;
+}
+
+void Instrument::Init() {
+  if (primary_account_number_.size() >= 4) {
+    last_four_digits_ =
+        primary_account_number_.substr(primary_account_number_.size() - 4);
+  }
+}
+
+}  // namespace wallet
+}  // namespace autofill