[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 27 matching lines @@
 }
 
 }  // anonymous namespace
 
 // static
 RemotePlayback* RemotePlayback::create(ScriptState* scriptState,
                                        HTMLMediaElement& element) {
   DCHECK(element.document().frame());
   DCHECK(scriptState);
 
-  RemotePlayback* remotePlayback = new RemotePlayback(scriptState, element);
-  element.setRemotePlaybackClient(remotePlayback);
-
-  return remotePlayback;
+  return new RemotePlayback(scriptState, element);
 }
 
 RemotePlayback::RemotePlayback(ScriptState* scriptState,
                                HTMLMediaElement& element)
     : ActiveScriptWrappable(this),
       m_scriptState(scriptState),
       m_state(element.isPlayingRemotely()
                   ? WebRemotePlaybackState::Connected
                   : WebRemotePlaybackState::Disconnected),
-      m_availability(element.hasRemoteRoutes()),
+      m_routeAvailable(false),
+      m_sourceCompatible(false),
       m_mediaElement(&element) {}
 
 const AtomicString& RemotePlayback::interfaceName() const {
   return EventTargetNames::RemotePlayback;
 }
 
 ExecutionContext* RemotePlayback::getExecutionContext() const {
   return &m_mediaElement->document();
 }
 
@@ skipping 96 matching lines @@
         "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_routeAvailable) {
+    resolver->reject(DOMException::create(NotFoundError,
+                                          "No remote playback devices found."));
+    return promise;
+  }
+
+  if (!m_sourceCompatible) {
+    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, m_routeAvailable && m_sourceCompatible);
 }
 
 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(bool isRouteAvailable,
+                                         bool isSourceCompatible) {
+  if (m_routeAvailable == isRouteAvailable &&
+      m_sourceCompatible == isSourceCompatible) {
+    return;
+  }
+
+  bool oldAvailability = m_routeAvailable && m_sourceCompatible;
+  m_routeAvailable = isRouteAvailable;
+  m_sourceCompatible = isSourceCompatible;
+
+  bool newAvailability = isRouteAvailable && isSourceCompatible;
+  if (newAvailability == oldAvailability)
     return;
 
-  m_availability = available;
   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_routeAvailable && m_sourceCompatible;
+}
+
 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