Log PaymentResponse.complete() timeout.

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 <stddef.h>
 #include <utility>
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 27 matching lines @@
 #include "modules/payments/PaymentShippingOption.h"
 #include "modules/payments/PaymentsValidators.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/mojo/MojoHelper.h"
 #include "platform/wtf/HashSet.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
 
-using payments::mojom::blink::CanMakePaymentQueryResult;
-using payments::mojom::blink::PaymentAddressPtr;
-using payments::mojom::blink::PaymentCurrencyAmount;
-using payments::mojom::blink::PaymentCurrencyAmountPtr;
-using payments::mojom::blink::PaymentDetailsModifierPtr;
-using payments::mojom::blink::PaymentDetailsPtr;
-using payments::mojom::blink::PaymentErrorReason;
-using payments::mojom::blink::PaymentItemPtr;
-using payments::mojom::blink::PaymentMethodDataPtr;
-using payments::mojom::blink::PaymentOptionsPtr;
-using payments::mojom::blink::PaymentResponsePtr;
-using payments::mojom::blink::PaymentShippingOptionPtr;
-using payments::mojom::blink::PaymentShippingType;
+namespace {
+
+using ::payments::mojom::blink::CanMakePaymentQueryResult;
+using ::payments::mojom::blink::PaymentAddressPtr;
+using ::payments::mojom::blink::PaymentCurrencyAmount;
+using ::payments::mojom::blink::PaymentCurrencyAmountPtr;
+using ::payments::mojom::blink::PaymentDetailsModifierPtr;
+using ::payments::mojom::blink::PaymentDetailsPtr;
+using ::payments::mojom::blink::PaymentErrorReason;
+using ::payments::mojom::blink::PaymentItemPtr;
+using ::payments::mojom::blink::PaymentMethodDataPtr;
+using ::payments::mojom::blink::PaymentOptionsPtr;
+using ::payments::mojom::blink::PaymentResponsePtr;
+using ::payments::mojom::blink::PaymentShippingOptionPtr;
+using ::payments::mojom::blink::PaymentShippingType;
+
+}  // namespace
 
 namespace mojo {
 
 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();
@@ skipping 177 matching lines @@
     bool ok = false;
     int min_google_play_services_version =
         android_pay.minGooglePlayServicesVersion().ToIntStrict(&ok);
     if (ok) {
       output->min_google_play_services_version =
           min_google_play_services_version;
     }
   }
 
   if (android_pay.hasAllowedCardNetworks()) {
-    using payments::mojom::blink::AndroidPayCardNetwork;
+    using ::payments::mojom::blink::AndroidPayCardNetwork;
 
     const struct {
       const AndroidPayCardNetwork code;
       const char* const name;
     } kAndroidPayNetwork[] = {{AndroidPayCardNetwork::AMEX, "AMEX"},
                               {AndroidPayCardNetwork::DISCOVER, "DISCOVER"},
                               {AndroidPayCardNetwork::MASTERCARD, "MASTERCARD"},
                               {AndroidPayCardNetwork::VISA, "VISA"}};
 
     for (const String& allowed_card_network :
          android_pay.allowedCardNetworks()) {
       for (size_t i = 0; i < arraysize(kAndroidPayNetwork); ++i) {
         if (allowed_card_network == kAndroidPayNetwork[i].name) {
           output->allowed_card_networks.push_back(kAndroidPayNetwork[i].code);
           break;
         }
       }
     }
   }
 
   if (android_pay.hasPaymentMethodTokenizationParameters()) {
     const blink::AndroidPayTokenization& tokenization =
         android_pay.paymentMethodTokenizationParameters();
     output->tokenization_type =
         payments::mojom::blink::AndroidPayTokenization::UNSPECIFIED;
     if (tokenization.hasTokenizationType()) {
-      using payments::mojom::blink::AndroidPayTokenization;
+      using ::payments::mojom::blink::AndroidPayTokenization;
 
       const struct {
         const AndroidPayTokenization code;
         const char* const name;
       } kAndroidPayTokenization[] = {
           {AndroidPayTokenization::GATEWAY_TOKEN, "GATEWAY_TOKEN"},
           {AndroidPayTokenization::NETWORK_TOKEN, "NETWORK_TOKEN"}};
 
       for (size_t i = 0; i < arraysize(kAndroidPayTokenization); ++i) {
         if (tokenization.tokenizationType() ==
@@ skipping 27 matching lines @@
                             PaymentMethodDataPtr& output,
                             ExecutionContext& execution_context,
                             ExceptionState& exception_state) {
   BasicCardRequest basic_card;
   V8BasicCardRequest::toImpl(input.GetIsolate(), input.V8Value(), basic_card,
                              exception_state);
   if (exception_state.HadException())
     return;
 
   if (basic_card.hasSupportedNetworks()) {
-    using payments::mojom::blink::BasicCardNetwork;
+    using ::payments::mojom::blink::BasicCardNetwork;
 
     const struct {
       const BasicCardNetwork code;
       const char* const name;
     } kBasicCardNetworks[] = {{BasicCardNetwork::AMEX, "amex"},
                               {BasicCardNetwork::DINERS, "diners"},
                               {BasicCardNetwork::DISCOVER, "discover"},
                               {BasicCardNetwork::JCB, "jcb"},
                               {BasicCardNetwork::MASTERCARD, "mastercard"},
                               {BasicCardNetwork::MIR, "mir"},
                               {BasicCardNetwork::UNIONPAY, "unionpay"},
                               {BasicCardNetwork::VISA, "visa"}};
 
     for (const String& network : basic_card.supportedNetworks()) {
       for (size_t i = 0; i < arraysize(kBasicCardNetworks); ++i) {
         if (network == kBasicCardNetworks[i].name) {
           output->supported_networks.push_back(kBasicCardNetworks[i].code);
           break;
         }
       }
     }
   }
 
   if (basic_card.hasSupportedTypes()) {
-    using payments::mojom::blink::BasicCardType;
+    using ::payments::mojom::blink::BasicCardType;
 
     const struct {
       const BasicCardType code;
       const char* const name;
     } kBasicCardTypes[] = {{BasicCardType::CREDIT, "credit"},
                            {BasicCardType::DEBIT, "debit"},
                            {BasicCardType::PREPAID, "prepaid"}};
 
     for (const String& type : basic_card.supportedTypes()) {
       for (size_t i = 0; i < arraysize(kBasicCardTypes); ++i) {
@@ skipping 694 matching lines @@
     case CanMakePaymentQueryResult::QUERY_QUOTA_EXCEEDED:
       can_make_payment_resolver_->Reject(DOMException::Create(
           kNotAllowedError, "Not allowed to check whether can make payment"));
       break;
   }
 
   can_make_payment_resolver_.Clear();
 }
 
 void PaymentRequest::OnCompleteTimeout(TimerBase*) {
+  GetExecutionContext()->AddConsoleMessage(ConsoleMessage::Create(
+      kJSMessageSource, kErrorMessageLevel,
+      "Timed out waiting for a PaymentResponse.complete() call."));
   payment_provider_->Complete(payments::mojom::blink::PaymentComplete(kFail));
   ClearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::ClearResolversAndCloseMojoConnection() {
   complete_timer_.Stop();
   complete_resolver_.Clear();
   show_resolver_.Clear();
   abort_resolver_.Clear();
   can_make_payment_resolver_.Clear();
   if (client_binding_.is_bound())
     client_binding_.Close();
   payment_provider_.reset();
 }
 
 }  // namespace blink