[Payments] Move PaymentMethodData to components/payments/core

components/payments/core/payment_method_data.cc

Index: components/payments/core/payment_method_data.cc
diff --git a/components/payments/core/payment_method_data.cc b/components/payments/core/payment_method_data.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f4f4e186847db69f2421b4d8f232c639445c7e5f
--- /dev/null
+++ b/components/payments/core/payment_method_data.cc
@@ -0,0 +1,95 @@
+// Copyright 2017 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/payments/core/payment_method_data.h"
+
+#include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
+
+namespace payments {
+
+namespace {
+
+// These are defined as part of the spec at:
+// https://w3c.github.io/browser-payment-api/#paymentmethoddata-dictionary
+static const char kBasicCardMethodName[] = "basic-card";
+static const char kMethodDataData[] = "data";
+static const char kSupportedMethods[] = "supportedMethods";
+static const char kSupportedNetworks[] = "supportedNetworks";
+static const char kSupportedTypes[] = "supportedTypes";
+
+}  // namespace
+
+PaymentMethodData::PaymentMethodData() {}
+PaymentMethodData::PaymentMethodData(const PaymentMethodData& other) = default;
+PaymentMethodData::~PaymentMethodData() = default;
+
+bool PaymentMethodData::operator==(const PaymentMethodData& other) const {
+  return this->supported_methods == other.supported_methods &&
+         this->data == other.data &&
+         this->supported_networks == other.supported_networks &&
+         this->supported_types == other.supported_types;
+}
+
+bool PaymentMethodData::operator!=(const PaymentMethodData& other) const {
+  return !(*this == other);
+}
+
+bool PaymentMethodData::FromDictionaryValue(
+    const base::DictionaryValue& value) {
+  this->supported_methods.clear();
+  this->supported_networks.clear();
+  this->supported_types.clear();
+
+  bool has_basic_card = false;
+  const base::ListValue* supported_methods_list = nullptr;
+  // At least one supported method is required.
+  if (!value.GetList(kSupportedMethods, &supported_methods_list) ||
+      supported_methods_list->GetSize() == 0) {
+    return false;
+  }
+  for (size_t i = 0; i < supported_methods_list->GetSize(); ++i) {
+    base::string16 supported_method;
+    if (!supported_methods_list->GetString(i, &supported_method)) {
+      return false;
+    }
+    if (supported_method == base::ASCIIToUTF16(kBasicCardMethodName))
+      has_basic_card = true;
+    this->supported_methods.push_back(supported_method);
+  }
+
+  // Data is optional, but if a dictionary is present, save a stringified
+  // version and attempt to parse supportedNetworks/supportedTypes.
+  const base::DictionaryValue* data_dict = nullptr;
+  if (value.GetDictionary(kMethodDataData, &data_dict)) {
+    std::string json_data;
+    base::JSONWriter::Write(*data_dict, &json_data);
+    this->data = base::UTF8ToUTF16(json_data);
+    const base::ListValue* supported_networks_list = nullptr;
+    if (data_dict->GetList(kSupportedNetworks, &supported_networks_list)) {
+      for (size_t i = 0; i < supported_networks_list->GetSize(); ++i) {
+        base::string16 supported_network;
+        if (!supported_networks_list->GetString(i, &supported_network)) {
+          break;  // TODO(mathp): or return false? or continue?

[Mathieu, 2017/04/04 03:21:08]

Not sure how this should validate. If item at this location is not a string, we
should probably return false, right?

[Mathieu, 2017/04/04 12:33:02]

I went with return false, as the caller should not use the result of this if
it's invalid.

[Moe, 2017/04/04 17:52:50]

I agree. Returning false makes more sense.

+        }
+        this->supported_networks.push_back(supported_network);
+      }
+    }
+    const base::ListValue* supported_types_list = nullptr;
+    if (data_dict->GetList(kSupportedTypes, &supported_types_list)) {
+      for (size_t i = 0; i < supported_types_list->GetSize(); ++i) {
+        base::string16 supported_type;
+        if (!supported_types_list->GetString(i, &supported_type)) {
+          break;  // TODO(mathp): or return false? or continue?
+        }
+        this->supported_types.push_back(supported_type);
+      }
+    }
+  }
+  return true;
+}
+
+}  // namespace payments