[Blink, RemotePlayback] Reject the prompt() with OperationError if there's a pending promise for th…

third_party/WebKit/Source/modules/remoteplayback/RemotePlayback.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/remoteplayback/RemotePlayback.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/HTMLNames.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
@@ skipping 71 matching lines @@
   // https://crbug.com/647441
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   if (m_mediaElement->fastHasAttribute(HTMLNames::disableremoteplaybackAttr)) {
     resolver->reject(DOMException::create(
         InvalidStateError, "disableRemotePlayback attribute is present."));
     return promise;
   }
 
-  // TODO(avayvod): should we have a separate flag to disable the user gesture
-  // requirement (for tests) or reuse the one for the PresentationRequest::start()?
+  if (m_promptPromiseResolver) {
+    resolver->reject(DOMException::create(
+        OperationError,
+        "A prompt is already being shown for this media element."));
+    return promise;
+  }
+
   if (!UserGestureIndicator::utilizeUserGesture()) {
     resolver->reject(DOMException::create(
         InvalidAccessError, "RemotePlayback::prompt() requires user gesture."));
     return promise;
   }
 
   if (m_state == WebRemotePlaybackState::Disconnected) {
-    m_promptPromiseResolvers.append(resolver);
+    m_promptPromiseResolver = resolver;
     m_mediaElement->requestRemotePlayback();
   } else {
     m_mediaElement->requestRemotePlaybackControl();
     // TODO(avayvod): Need to keep the resolver until user chooses to stop
     // the remote playback (resolve) or dismisses the UI (reject).
     // Steps 11 and 12 of the prompt() algorithm.
     // https://crbug.com/647441
     resolver->resolve();
   }
 
   return promise;
 }
 
 String RemotePlayback::state() const {
   return remotePlaybackStateToString(m_state);
 }
 
 bool RemotePlayback::hasPendingActivity() const {
   return hasEventListeners() || !m_availabilityObjects.isEmpty() ||
-         !m_promptPromiseResolvers.isEmpty();
+         m_promptPromiseResolver;
 }
 
 void RemotePlayback::stateChanged(WebRemotePlaybackState state) {
   // We may get a "disconnected" state change while in the "disconnected"
   // state if initiated connection fails. So cleanup the promise resolvers
   // before checking if anything changed.
   // TODO(avayvod): cleanup this logic when we implementing the "connecting"
   // state.
-  if (state != WebRemotePlaybackState::Disconnected) {
-    for (auto& resolver : m_promptPromiseResolvers)
-      resolver->resolve();
-  } else {
-    for (auto& resolver : m_promptPromiseResolvers)
-      resolver->reject(DOMException::create(
+  if (m_promptPromiseResolver) {
+    if (state != WebRemotePlaybackState::Disconnected)
+      m_promptPromiseResolver->resolve();
+    else
+      m_promptPromiseResolver->reject(DOMException::create(
           AbortError, "Failed to connect to the remote device."));
+    m_promptPromiseResolver = nullptr;
   }
-  m_promptPromiseResolvers.clear();
 
   if (m_state == state)
     return;
 
   m_state = state;
   dispatchEvent(Event::create(EventTypeNames::statechange));
 }
 
 void RemotePlayback::availabilityChanged(bool available) {
   if (m_availability == available)
     return;
 
   m_availability = available;
   for (auto& availabilityObject : m_availabilityObjects)
     availabilityObject->availabilityChanged(available);
 }
 
 void RemotePlayback::promptCancelled() {
-  for (auto& resolver : m_promptPromiseResolvers)
-    resolver->resolve();
-  m_promptPromiseResolvers.clear();
+  if (!m_promptPromiseResolver)
+    return;
+
+  m_promptPromiseResolver->resolve();
+  m_promptPromiseResolver = nullptr;
 }
 
 DEFINE_TRACE(RemotePlayback) {
   visitor->trace(m_availabilityObjects);
-  visitor->trace(m_promptPromiseResolvers);
+  visitor->trace(m_promptPromiseResolver);
   visitor->trace(m_mediaElement);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink