Add a timeout to the update event in case page doesn't resolve promise from updateWith

third_party/WebKit/Source/modules/payments/PaymentRequestUpdateEvent.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/PaymentRequestUpdateEvent.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "modules/payments/PaymentUpdater.h"
+#include "public/platform/WebTraceLocation.h"
 
 namespace blink {
 namespace {
 
+static const int abortTimeout = 60; // Reject the payment request if the page does not resolve the promise from updateWith within 60 seconds.
+
 class UpdatePaymentDetailsFunction : public ScriptFunction {
 public:
     static v8::Local<v8::Function> createFunction(ScriptState* scriptState, PaymentUpdater* updater)
     {
         UpdatePaymentDetailsFunction* self = new UpdatePaymentDetailsFunction(scriptState, updater);
         return self->bindToV8Function();
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
@@ skipping 60 matching lines @@
     return new PaymentRequestUpdateEvent();
 }
 
 PaymentRequestUpdateEvent* PaymentRequestUpdateEvent::create(const AtomicString& type, const PaymentRequestUpdateEventInit& init)
 {
     return new PaymentRequestUpdateEvent(type, init);
 }
 
 void PaymentRequestUpdateEvent::setPaymentDetailsUpdater(PaymentUpdater* updater)
 {
+    DCHECK(!m_abortTimer.isActive());
+    m_abortTimer.startOneShot(abortTimeout, BLINK_FROM_HERE);
     m_updater = updater;
 }
 
 void PaymentRequestUpdateEvent::updateWith(ScriptState* scriptState, ScriptPromise promise, ExceptionState& exceptionState)
 {
     if (!m_updater)
         return;
 
     if (!isBeingDispatched()) {
         exceptionState.throwDOMException(InvalidStateError, "Cannot update details when the event is not being dispatched");
         return;
     }
 
     if (m_waitForUpdate) {
         exceptionState.throwDOMException(InvalidStateError, "Cannot update details twice");
         return;
     }
 
     stopImmediatePropagation();
     m_waitForUpdate = true;
+    m_abortTimer.stop();
 
     promise.then(UpdatePaymentDetailsFunction::createFunction(scriptState, m_updater),
         UpdatePaymentDetailsErrorFunction::createFunction(scriptState, m_updater));
 }
 
+void PaymentRequestUpdateEvent::onTimerFired(Timer<PaymentRequestUpdateEvent>*)
+{
+    if (!m_updater)
+        return;
+
+    m_updater->onUpdatePaymentDetailsFailure(ScriptValue());
+}
+
 DEFINE_TRACE(PaymentRequestUpdateEvent)
 {
     visitor->trace(m_updater);
     Event::trace(visitor);
 }
 
 PaymentRequestUpdateEvent::PaymentRequestUpdateEvent()
     : m_waitForUpdate(false)
+    , m_abortTimer(this, &PaymentRequestUpdateEvent::onTimerFired)
 {
 }
 
 PaymentRequestUpdateEvent::PaymentRequestUpdateEvent(const AtomicString& type, const PaymentRequestUpdateEventInit& init)
     : Event(type, init)
     , m_waitForUpdate(false)
+    , m_abortTimer(this, &PaymentRequestUpdateEvent::onTimerFired)
 {
 }
 
 } // namespace blink