[RemotePlayback] Keep track of source compatibility and reject prompt() correspondingly

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 "bindings/modules/v8/RemotePlaybackAvailabilityCallback.h"
 #include "core/HTMLNames.h"
 #include "core/dom/DOMException.h"
@@ skipping 31 matching lines @@
 // static
 RemotePlayback* RemotePlayback::create(HTMLMediaElement& element) {
   return new RemotePlayback(element);
 }
 
 RemotePlayback::RemotePlayback(HTMLMediaElement& element)
     : ActiveScriptWrappable(this),
       m_state(element.isPlayingRemotely()
                   ? WebRemotePlaybackState::Connected
                   : WebRemotePlaybackState::Disconnected),
-      m_availability(element.hasRemoteRoutes()),
+      m_availability(WebRemotePlaybackAvailability::Unknown),
       m_mediaElement(&element) {}
 
 const AtomicString& RemotePlayback::interfaceName() const {
   return EventTargetNames::RemotePlayback;
 }
 
 ExecutionContext* RemotePlayback::getExecutionContext() const {
   return &m_mediaElement->document();
 }
 
@@ skipping 71 matching lines @@
     return promise;
   }
 
   m_availabilityCallbacks.clear();
 
   resolver->resolve();
   return promise;
 }
 
 ScriptPromise RemotePlayback::prompt(ScriptState* scriptState) {
-  // TODO(avayvod): implement steps 5, 8, 9 of the algorithm.
-  // 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;
   }
 
   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;
   }
 
+  // TODO(avayvod): don't do this check on low-end devices - merge with
+  // https://codereview.chromium.org/2475293003
+  if (m_availability == WebRemotePlaybackAvailability::DeviceNotAvailable) {
+    resolver->reject(DOMException::create(NotFoundError,
+                                          "No remote playback devices found."));
+    return promise;
+  }
+
+  if (m_availability == WebRemotePlaybackAvailability::SourceNotSupported ||
+      m_availability == WebRemotePlaybackAvailability::SourceNotCompatible) {
+    resolver->reject(DOMException::create(
+        NotSupportedError,
+        "The currentSrc is not compatible with remote playback"));
+    return promise;
+  }
+
   if (m_state == WebRemotePlaybackState::Disconnected) {
     m_promptPromiseResolver = resolver;
     m_mediaElement->requestRemotePlayback();
   } else {
     m_promptPromiseResolver = resolver;
     m_mediaElement->requestRemotePlaybackControl();
   }
 
   return promise;
 }
 
 String RemotePlayback::state() const {
   return remotePlaybackStateToString(m_state);
 }
 
 bool RemotePlayback::hasPendingActivity() const {
   return hasEventListeners() || !m_availabilityCallbacks.isEmpty() ||
          m_promptPromiseResolver;
 }
 
 void RemotePlayback::notifyInitialAvailability(int callbackId) {
   // May not find the callback if the website cancels it fast enough.
   auto iter = m_availabilityCallbacks.find(callbackId);
   if (iter == m_availabilityCallbacks.end())
     return;
 
-  iter->value->call(this, m_availability);
+  iter->value->call(this, remotePlaybackAvailable());
 }
 
 void RemotePlayback::stateChanged(WebRemotePlaybackState state) {
   if (m_state == state)
     return;
 
   if (m_promptPromiseResolver) {
     // Changing state to Disconnected from "disconnected" or "connecting" means
     // that establishing connection with remote playback device failed.
     // Changing state to anything else means the state change intended by
@@ skipping 19 matching lines @@
       break;
     case WebRemotePlaybackState::Connected:
       dispatchEvent(Event::create(EventTypeNames::connect));
       break;
     case WebRemotePlaybackState::Disconnected:
       dispatchEvent(Event::create(EventTypeNames::disconnect));
       break;
   }
 }
 
-void RemotePlayback::availabilityChanged(bool available) {
-  if (m_availability == available)
+void RemotePlayback::availabilityChanged(
+    WebRemotePlaybackAvailability availability) {
+  if (m_availability == availability)
     return;
 
-  m_availability = available;
+  bool oldAvailability = remotePlaybackAvailable();
+  m_availability = availability;
+  bool newAvailability = remotePlaybackAvailable();
+  if (newAvailability == oldAvailability)
+    return;
+
   for (auto& callback : m_availabilityCallbacks.values())
-    callback->call(this, m_availability);
+    callback->call(this, newAvailability);
 }
 
 void RemotePlayback::promptCancelled() {
   if (!m_promptPromiseResolver)
     return;
 
   m_promptPromiseResolver->reject(
       DOMException::create(NotAllowedError, "The prompt was dismissed."));
   m_promptPromiseResolver = nullptr;
 }
 
+bool RemotePlayback::remotePlaybackAvailable() const {
+  return m_availability == WebRemotePlaybackAvailability::DeviceAvailable;
+}
+
 void RemotePlayback::remotePlaybackDisabled() {
   if (m_promptPromiseResolver) {
     m_promptPromiseResolver->reject(DOMException::create(
         InvalidStateError, "disableRemotePlayback attribute is present."));
     m_promptPromiseResolver = nullptr;
   }
 
   m_availabilityCallbacks.clear();
 
   if (m_state != WebRemotePlaybackState::Disconnected)
@@ skipping 15 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(RemotePlayback) {
   for (auto callback : m_availabilityCallbacks.values()) {
     visitor->traceWrappers(callback);
   }
   EventTargetWithInlineData::traceWrappers(visitor);
 }
 
 }  // namespace blink