[Web Payments] Common Payments validation

components/payments/payments_validators.cc

 // Copyright 2016 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 "modules/payments/PaymentsValidators.h"
+#include "components/payments/payments_validators.h"
 
-#include "bindings/core/v8/ScriptRegexp.h"
-#include "platform/weborigin/KURL.h"
-#include "wtf/text/StringImpl.h"
+#include "third_party/re2/src/re2/re2.h"
+#include "url/gurl.h"
 
-namespace blink {
+namespace payments {
 
 // We limit the maximum length of string to 2048 bytes for security reasons.
-static const int maxiumStringLength = 2048;
+static const int maximumStringLength = 2048;
 
 bool PaymentsValidators::isValidCurrencyCodeFormat(
-    const String& code,
-    const String& system,
-    String* optionalErrorMessage) {
+    const std::string& code,
+    const std::string& system,
+    std::string* optionalErrorMessage) {
   if (system == "urn:iso:std:iso:4217") {
-    if (ScriptRegexp("^[A-Z]{3}$", TextCaseSensitive).match(code) == 0)
+    if (RE2::FullMatch(code, "[A-Z]{3}"))
       return true;
 
     if (optionalErrorMessage)
       *optionalErrorMessage = "'" + code +
                               "' is not a valid ISO 4217 currency code, should "
                               "be 3 upper case letters [A-Z]";
 
     return false;
   }
 
-  if (!KURL(KURL(), system).isValid()) {
+  if (code.size() > maximumStringLength) {
     if (optionalErrorMessage)
-      *optionalErrorMessage = "The currency system is not a valid URL";
-
+      *optionalErrorMessage =
+          "The currency code should be at most 2048 characters long";
     return false;
   }
+  if (!GURL(system).is_valid()) {
+    if (optionalErrorMessage)
+      *optionalErrorMessage =
+          "The system should be a valid URL";
+    return false;
+  }
+  return true;
+}
 
-  if (code.length() <= maxiumStringLength)
+bool PaymentsValidators::isValidAmountFormat(
+    const std::string& amount,
+    std::string* optionalErrorMessage) {
+  if (RE2::FullMatch(amount, "-?[0-9]+(\\.[0-9]+)?"))
     return true;
 
   if (optionalErrorMessage)
-    *optionalErrorMessage =
-        "The currency code should be at most 2048 characters long";
-
-  return false;
-}
-
-bool PaymentsValidators::isValidAmountFormat(const String& amount,
-                                             String* optionalErrorMessage) {
-  if (ScriptRegexp("^-?[0-9]+(\\.[0-9]+)?$", TextCaseSensitive).match(amount) ==
-      0)
-    return true;
-
-  if (optionalErrorMessage)
     *optionalErrorMessage = "'" + amount + "' is not a valid amount format";
 
   return false;
 }
 
 bool PaymentsValidators::isValidCountryCodeFormat(
-    const String& code,
-    String* optionalErrorMessage) {
-  if (ScriptRegexp("^[A-Z]{2}$", TextCaseSensitive).match(code) == 0)
+    const std::string& code,
+    std::string* optionalErrorMessage) {
+  if (RE2::FullMatch(code, "[A-Z]{2}"))
     return true;
 
   if (optionalErrorMessage)
     *optionalErrorMessage = "'" + code +
                             "' is not a valid CLDR country code, should be 2 "
                             "upper case letters [A-Z]";
 
   return false;
 }
 
 bool PaymentsValidators::isValidLanguageCodeFormat(
-    const String& code,
-    String* optionalErrorMessage) {
-  if (ScriptRegexp("^([a-z]{2,3})?$", TextCaseSensitive).match(code) == 0)
+    const std::string& code,
+    std::string* optionalErrorMessage) {
+  if (RE2::FullMatch(code, "([a-z]{2,3})?"))
     return true;
 
   if (optionalErrorMessage)
     *optionalErrorMessage = "'" + code +
                             "' is not a valid BCP-47 language code, should be "
                             "2-3 lower case letters [a-z]";
 
   return false;
 }
 
-bool PaymentsValidators::isValidScriptCodeFormat(const String& code,
-                                                 String* optionalErrorMessage) {
-  if (ScriptRegexp("^([A-Z][a-z]{3})?$", TextCaseSensitive).match(code) == 0)
+bool PaymentsValidators::isValidScriptCodeFormat(
+    const std::string& code,
+    std::string* optionalErrorMessage) {
+  if (RE2::FullMatch(code, "([A-Z][a-z]{3})?"))
     return true;
 
   if (optionalErrorMessage)
     *optionalErrorMessage = "'" + code +
                             "' is not a valid ISO 15924 script code, should be "
                             "an upper case letter [A-Z] followed by 3 lower "
                             "case letters [a-z]";
 
   return false;
 }
 
 bool PaymentsValidators::isValidShippingAddress(
-    const mojom::blink::PaymentAddressPtr& address,
-    String* optionalErrorMessage) {
+    const blink::mojom::PaymentAddressPtr& address,
+    std::string* optionalErrorMessage) {
   if (!isValidCountryCodeFormat(address->country, optionalErrorMessage))
     return false;
 
   if (!isValidLanguageCodeFormat(address->language_code, optionalErrorMessage))
     return false;
 
   if (!isValidScriptCodeFormat(address->script_code, optionalErrorMessage))
     return false;
 
-  if (address->language_code.isEmpty() && !address->script_code.isEmpty()) {
+  if (address->language_code.empty() && !address->script_code.empty()) {
     if (optionalErrorMessage)
       *optionalErrorMessage =
           "If language code is empty, then script code should also be empty";
 
     return false;
   }
 
   return true;
 }
 
-bool PaymentsValidators::isValidErrorMsgFormat(const String& error,
-                                               String* optionalErrorMessage) {
-  if (error.length() <= maxiumStringLength)
+bool PaymentsValidators::isValidErrorMsgFormat(
+    const std::string& error,
+    std::string* optionalErrorMessage) {
+  if (error.length() <= maximumStringLength)
     return true;
 
   if (optionalErrorMessage)
     *optionalErrorMessage =
         "Error message should be at most 2048 characters long";
 
   return false;
 }
 
-}  // namespace blink
+}  // namespace payments