Integrating Online Wallet into Chrome.

chrome/browser/autofill/wallet/full_wallet.cc

Index: chrome/browser/autofill/wallet/full_wallet.cc
diff --git a/chrome/browser/autofill/wallet/full_wallet.cc b/chrome/browser/autofill/wallet/full_wallet.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9ae60c12120eb062a680072dc55dd93349ef8043
--- /dev/null
+++ b/chrome/browser/autofill/wallet/full_wallet.cc
@@ -0,0 +1,177 @@
+// Copyright (c) 2012 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 "chrome/browser/autofill/wallet/full_wallet.h"
+
+#include "base/logging.h"
+#include "base/string_number_conversions.h"
+#include "base/values.h"
+
+
+namespace {
+
+size_t kPanSize = 16;
+size_t kBinSize = 6;
+size_t kCvnSize = 3;
+
+}  // end anonymous namespace
+
+namespace wallet {
+
+FullWallet::FullWallet(int expiration_month,
+             int expiration_year,
+             const std::string& iin,
+             const std::string& encrypted_rest,
+             Address* billing_address,
+             Address* shipping_address,
+             std::vector<std::string> required_actions)
+    : expiration_month_(expiration_month),
+      expiration_year_(expiration_year),
+      iin_(iin),
+      encrypted_rest_(encrypted_rest),
+      billing_address_(billing_address),
+      shipping_address_(shipping_address),
+      required_actions_(required_actions) {}
+
+FullWallet::~FullWallet() {
+}
+
+FullWallet* FullWallet::CreateFullWallet(DictionaryValue* dictionary) {
+  DCHECK(dictionary);
+  ListValue* required_actions_list;
+  std::vector<std::string> required_actions;
+  if (dictionary->GetList("required_action", &required_actions_list)) {
+    for (size_t i = 0; i < required_actions_list->GetSize(); i++) {
+      std::string action;
+      if (required_actions_list->GetString(i, &action))
+        required_actions.push_back(action);
+    }
+    if (required_actions.size() > 0) {
+      return new FullWallet(-1, -1, "", "", NULL, NULL, required_actions);
+    }
+  } else {
+    VLOG(1) << "Response from Google wallet missing required actions";
+  }
+
+  int expiration_month;
+  if (!dictionary->GetInteger("expiration_month", &expiration_month)) {
+    LOG(ERROR) << "Response from Google wallet missing expiration month";

[Albert Bodenhamer, 2012/11/28 23:50:56]

We generally prefer DLOG over LOG (and friends) in an effort to reduce binary
size.  If these will be useful to end users in some way (eg when contacting
support) leave them in.  If not, make them debug only.

[ahutter, 2012/11/29 20:52:38]

Done.

+    return NULL;
+  }
+  int expiration_year;
+  if (!dictionary->GetInteger("expiration_year", &expiration_year)) {
+    LOG(ERROR) << "Response from Google wallet missing expiration year";
+    return NULL;
+  }
+  std::string iin;
+  if (!dictionary->GetString("iin", &iin)) {
+    LOG(ERROR) << "Response from Google wallet missing iin";
+    return NULL;
+  }
+  std::string encrypted_rest;
+  if (!dictionary->GetString("rest", &encrypted_rest)) {
+    LOG(ERROR) << "Response from Google wallet missing rest";
+    return NULL;
+  }
+  DictionaryValue* billing_address_dict;
+  if (!dictionary->GetDictionary("billing_address", &billing_address_dict)) {
+    LOG(ERROR) << "Response from Google wallet missing billing address";
+    return NULL;
+  }
+  Address* billing_address =
+      Address::CreateIdedAddress(billing_address_dict);
+  if (!billing_address) {
+    LOG(ERROR) << "Response from Google wallet has malformed billing address";
+    return NULL;
+  }
+
+  DictionaryValue* shipping_address_dict;
+  Address* shipping_address;
+  if (dictionary->GetDictionary("shipping_address", &shipping_address_dict)) {
+    shipping_address =
+        Address::CreateIdedAddress(shipping_address_dict);
+  } else {
+    VLOG(1) << "Response from Google wallet missing shipping address";
+  }
+
+  return new FullWallet(expiration_month,
+                        expiration_year,
+                        iin,
+                        encrypted_rest,
+                        billing_address,
+                        shipping_address,
+                        required_actions);
+}
+
+bool FullWallet::operator==(const FullWallet& other) const {
+  if (expiration_month_ != other.expiration_month_)
+    return false;
+  if (expiration_year_ != other.expiration_year_)
+    return false;
+  if (iin_.compare(other.iin_) != 0)
+    return false;
+  if (encrypted_rest_.compare(other.encrypted_rest_) != 0)
+    return false;
+  if (billing_address_.get() && other.billing_address_.get()) {
+    if (*billing_address_.get() != *other.billing_address_.get())
+      return false;
+  } else if (billing_address_.get() || other.billing_address_.get()) {
+    return false;
+  }
+  if (shipping_address_.get() && other.shipping_address_.get()) {
+    if (*shipping_address_.get() != *other.shipping_address_.get())
+      return false;
+  } else if (shipping_address_.get() || other.shipping_address_.get()) {
+    return false;
+  }
+  if (required_actions_ != other.required_actions_)
+    return false;
+  return true;
+}
+
+bool FullWallet::operator!=(const FullWallet& other) const {
+  return !(*this == other);
+}
+
+const std::string FullWallet::GetPAN(void* otp, size_t length) {
+  if (cvn_.empty())
+    DecryptCardInfo((uint8*) otp, length);
+  return pan_;
+}
+
+const std::string FullWallet::GetCVN(void* otp, size_t length) {
+  if (pan_.empty())
+    DecryptCardInfo((uint8*) otp, length);
+  return cvn_;
+}
+
+void FullWallet::DecryptCardInfo(uint8* otp, size_t length) {
+  std::vector<uint8> operating_data;
+  if (!base::HexStringToBytes(encrypted_rest_, &operating_data)) {
+    LOG(ERROR) << "Failed to parse rest";
+    return;
+  }
+  DCHECK_EQ(length, operating_data.size());
+  uint8* result = new uint8[length];
+  for (size_t i = 0; i < length; i++)
+    result[i] = otp[i] ^ operating_data[i];
+  std::string hex_decrypted = base::HexEncode(result, length);
+  delete[] result;
+  int64 decrypted;
+  if (!base::HexStringToInt64(hex_decrypted, &decrypted)) {
+    LOG(ERROR) << "Failed to parse decrypted";
+    return;
+  }
+  std::string card_info = base::Int64ToString(decrypted);
+
+  size_t padded_length = (kPanSize - kBinSize + kCvnSize);
+  if (card_info.size() != padded_length)
+    card_info.insert(card_info.begin(), padded_length - card_info.size(), '0');
+
+  size_t split = kPanSize - kBinSize;
+  cvn_ = card_info.substr(split);
+  pan_ = iin_ + card_info.substr(0, split);
+}
+
+}  // end wallet namespace