[Web Payments] Mojom namespace blink -> payments

third_party/WebKit/Source/modules/payments/PaymentRequest.cpp

 // 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/PaymentRequest.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8StringResource.h"
@@ skipping 17 matching lines @@
 #include "mojo/public/cpp/bindings/wtf_array.h"
 #include "platform/mojo/MojoHelper.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/HashSet.h"
 #include <utility>
 
 namespace mojo {
 
-using blink::mojom::blink::PaymentCurrencyAmount;
-using blink::mojom::blink::PaymentCurrencyAmountPtr;
-using blink::mojom::blink::PaymentDetails;
-using blink::mojom::blink::PaymentDetailsModifier;
-using blink::mojom::blink::PaymentDetailsModifierPtr;
-using blink::mojom::blink::PaymentDetailsPtr;
-using blink::mojom::blink::PaymentErrorReason;
-using blink::mojom::blink::PaymentItem;
-using blink::mojom::blink::PaymentItemPtr;
-using blink::mojom::blink::PaymentMethodData;
-using blink::mojom::blink::PaymentMethodDataPtr;
-using blink::mojom::blink::PaymentOptions;
-using blink::mojom::blink::PaymentOptionsPtr;
-using blink::mojom::blink::PaymentShippingOption;
-using blink::mojom::blink::PaymentShippingOptionPtr;
-using blink::mojom::blink::PaymentShippingType;
+using payments::mojom::blink::PaymentCurrencyAmount;
+using payments::mojom::blink::PaymentCurrencyAmountPtr;
+using payments::mojom::blink::PaymentDetails;
+using payments::mojom::blink::PaymentDetailsModifier;
+using payments::mojom::blink::PaymentDetailsModifierPtr;
+using payments::mojom::blink::PaymentDetailsPtr;
+using payments::mojom::blink::PaymentErrorReason;
+using payments::mojom::blink::PaymentItem;
+using payments::mojom::blink::PaymentItemPtr;
+using payments::mojom::blink::PaymentMethodData;
+using payments::mojom::blink::PaymentMethodDataPtr;
+using payments::mojom::blink::PaymentOptions;
+using payments::mojom::blink::PaymentOptionsPtr;
+using payments::mojom::blink::PaymentShippingOption;
+using payments::mojom::blink::PaymentShippingOptionPtr;
+using payments::mojom::blink::PaymentShippingType;
 
 template <>
 struct TypeConverter<PaymentCurrencyAmountPtr, blink::PaymentCurrencyAmount> {
   static PaymentCurrencyAmountPtr Convert(
       const blink::PaymentCurrencyAmount& input) {
     PaymentCurrencyAmountPtr output = PaymentCurrencyAmount::New();
     output->currency = input.currency();
     output->value = input.value();
     if (input.hasCurrencySystem())
       output->currencySystem = input.currencySystem();
@@ skipping 347 matching lines @@
   static const char* const validValues[] = {
       "shipping", "delivery", "pickup",
   };
   for (size_t i = 0; i < WTF_ARRAY_LENGTH(validValues); i++) {
     if (shippingType == validValues[i])
       return shippingType;
   }
   return validValues[0];
 }
 
-mojom::blink::PaymentDetailsPtr maybeKeepShippingOptions(
-    mojom::blink::PaymentDetailsPtr details,
+payments::mojom::blink::PaymentDetailsPtr maybeKeepShippingOptions(
+    payments::mojom::blink::PaymentDetailsPtr details,
     bool keep) {
   if (!keep)
     details->shipping_options.resize(0);
 
   return details;
 }
 
 bool allowedToUsePaymentRequest(const Frame* frame) {
   // To determine whether a Document object |document| is allowed to use the
   // feature indicated by attribute name |allowpaymentrequest|, run these steps:
@@ skipping 15 matching lines @@
   if (ownerElement && isHTMLIFrameElement(ownerElement)) {
     HTMLIFrameElement* iframe = toHTMLIFrameElement(ownerElement);
     if (HTMLIFrameElementPayments::from(*iframe).allowPaymentRequest(*iframe))
       return allowedToUsePaymentRequest(frame->tree().parent());
   }
 
   // 4. Return false.
   return false;
 }
 
-WTF::Vector<mojom::blink::PaymentMethodDataPtr> ConvertPaymentMethodData(
+WTF::Vector<payments::mojom::blink::PaymentMethodDataPtr>
+ConvertPaymentMethodData(
     const Vector<PaymentRequest::MethodData>& blinkMethods) {
-  WTF::Vector<mojom::blink::PaymentMethodDataPtr> mojoMethods(
+  WTF::Vector<payments::mojom::blink::PaymentMethodDataPtr> mojoMethods(
       blinkMethods.size());
   for (size_t i = 0; i < blinkMethods.size(); ++i) {
-    mojoMethods[i] = mojom::blink::PaymentMethodData::New();
+    mojoMethods[i] = payments::mojom::blink::PaymentMethodData::New();
     mojoMethods[i]->supported_methods =
         WTF::Vector<WTF::String>(blinkMethods[i].supportedMethods);
     mojoMethods[i]->stringified_data = blinkMethods[i].stringifiedData;
   }
   return mojoMethods;
 }
 
 }  // namespace
 
 PaymentRequest* PaymentRequest::create(
@@ skipping 81 matching lines @@
 
   // User has cancelled the transaction while the website was processing it.
   if (!m_paymentProvider)
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(InvalidStateError, "Request cancelled"));
 
   m_completeTimer.stop();
 
   // The payment provider should respond in PaymentRequest::OnComplete().
-  m_paymentProvider->Complete(mojom::blink::PaymentComplete(result));
+  m_paymentProvider->Complete(payments::mojom::blink::PaymentComplete(result));
 
   m_completeResolver = ScriptPromiseResolver::create(scriptState);
   return m_completeResolver->promise();
 }
 
 void PaymentRequest::onUpdatePaymentDetails(
     const ScriptValue& detailsScriptValue) {
   if (!m_showResolver || !m_paymentProvider)
     return;
 
@@ skipping 18 matching lines @@
   }
 
   if (m_options.requestShipping()) {
     if (keepShippingOptions)
       m_shippingOption = getSelectedShippingOption(details);
     else
       m_shippingOption = String();
   }
 
   m_paymentProvider->UpdateWith(maybeKeepShippingOptions(
-      mojom::blink::PaymentDetails::From(details), keepShippingOptions));
+      payments::mojom::blink::PaymentDetails::From(details),
+      keepShippingOptions));
 }
 
 void PaymentRequest::onUpdatePaymentDetailsFailure(const String& error) {
   if (m_showResolver)
     m_showResolver->reject(DOMException::create(AbortError, error));
   if (m_completeResolver)
     m_completeResolver->reject(DOMException::create(AbortError, error));
   clearResolversAndCloseMojoConnection();
 }
 
@@ skipping 52 matching lines @@
   if (m_options.requestShipping()) {
     if (keepShippingOptions)
       m_shippingOption = getSelectedShippingOption(details);
     m_shippingType = getValidShippingType(m_options.shippingType());
   }
 
   scriptState->domWindow()->frame()->interfaceProvider()->getInterface(
       mojo::GetProxy(&m_paymentProvider));
   m_paymentProvider.set_connection_error_handler(convertToBaseCallback(
       WTF::bind(&PaymentRequest::OnError, wrapWeakPersistent(this),
-                mojom::blink::PaymentErrorReason::UNKNOWN)));
+                payments::mojom::blink::PaymentErrorReason::UNKNOWN)));
   m_paymentProvider->Init(
       m_clientBinding.CreateInterfacePtrAndBind(),
       ConvertPaymentMethodData(validatedMethodData),
       maybeKeepShippingOptions(
-          mojom::blink::PaymentDetails::From(details),
+          payments::mojom::blink::PaymentDetails::From(details),
           keepShippingOptions && m_options.requestShipping()),
-      mojom::blink::PaymentOptions::From(m_options));
+      payments::mojom::blink::PaymentOptions::From(m_options));
 }
 
 void PaymentRequest::contextDestroyed() {
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::OnShippingAddressChange(
-    mojom::blink::PaymentAddressPtr address) {
+    payments::mojom::blink::PaymentAddressPtr address) {
   DCHECK(m_showResolver);
   DCHECK(!m_completeResolver);
 
   String errorMessage;
   if (!PaymentsValidators::isValidShippingAddress(address, &errorMessage)) {
     m_showResolver->reject(DOMException::create(SyntaxError, errorMessage));
     clearResolversAndCloseMojoConnection();
     return;
   }
 
@@ skipping 14 matching lines @@
   PaymentRequestUpdateEvent* event =
       PaymentRequestUpdateEvent::create(EventTypeNames::shippingoptionchange);
   event->setTarget(this);
   event->setPaymentDetailsUpdater(this);
   bool success = getExecutionContext()->getEventQueue()->enqueueEvent(event);
   DCHECK(success);
   ALLOW_UNUSED_LOCAL(success);
 }
 
 void PaymentRequest::OnPaymentResponse(
-    mojom::blink::PaymentResponsePtr response) {
+    payments::mojom::blink::PaymentResponsePtr response) {
   DCHECK(m_showResolver);
   DCHECK(!m_completeResolver);
   DCHECK(!m_completeTimer.isActive());
 
   if (m_options.requestShipping()) {
     if (!response->shipping_address || response->shipping_option.isEmpty()) {
       m_showResolver->reject(DOMException::create(SyntaxError));
       clearResolversAndCloseMojoConnection();
       return;
     }
@@ skipping 41 matching lines @@
   if (!Platform::current()) {
     // TODO(rockot): Clean this up once renderer shutdown sequence is fixed.
     return;
   }
 
   bool isError = false;
   ExceptionCode ec = UnknownError;
   String message;
 
   switch (error) {
-    case mojom::blink::PaymentErrorReason::USER_CANCEL:
+    case payments::mojom::blink::PaymentErrorReason::USER_CANCEL:
       message = "Request cancelled";
       break;
-    case mojom::blink::PaymentErrorReason::NOT_SUPPORTED:
+    case payments::mojom::blink::PaymentErrorReason::NOT_SUPPORTED:
       isError = true;
       ec = NotSupportedError;
       message = "The payment method is not supported";
       break;
-    case mojom::blink::PaymentErrorReason::UNKNOWN:
+    case payments::mojom::blink::PaymentErrorReason::UNKNOWN:
       isError = true;
       ec = UnknownError;
       message = "Request failed";
       break;
   }
 
   DCHECK(!message.isEmpty());
 
   if (isError) {
     if (m_completeResolver)
@@ skipping 33 matching lines @@
     m_abortResolver.clear();
     return;
   }
 
   m_showResolver->reject(DOMException::create(AbortError));
   m_abortResolver->resolve();
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::onCompleteTimeout(TimerBase*) {
-  m_paymentProvider->Complete(mojom::blink::PaymentComplete(Fail));
+  m_paymentProvider->Complete(payments::mojom::blink::PaymentComplete(Fail));
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::clearResolversAndCloseMojoConnection() {
   m_completeTimer.stop();
   m_completeResolver.clear();
   m_showResolver.clear();
   m_abortResolver.clear();
   if (m_clientBinding.is_bound())
     m_clientBinding.Close();
   m_paymentProvider.reset();
 }
 
 }  // namespace blink