[Blink, RemotePlayback] watchAvailability() implementation.

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"
 #include "core/dom/Document.h"
+#include "core/dom/ExecutionContextTask.h"
 #include "core/events/Event.h"
 #include "core/html/HTMLMediaElement.h"
 #include "modules/EventTargetModules.h"
-#include "modules/remoteplayback/RemotePlaybackAvailability.h"
 #include "platform/UserGestureIndicator.h"
 
 namespace blink {
 
 namespace {
 
 const AtomicString& remotePlaybackStateToString(WebRemotePlaybackState state) {
   DEFINE_STATIC_LOCAL(const AtomicString, connectingValue, ("connecting"));
   DEFINE_STATIC_LOCAL(const AtomicString, connectedValue, ("connected"));
   DEFINE_STATIC_LOCAL(const AtomicString, disconnectedValue, ("disconnected"));
@@ skipping 32 matching lines @@
       m_mediaElement(&element) {}
 
 const AtomicString& RemotePlayback::interfaceName() const {
   return EventTargetNames::RemotePlayback;
 }
 
 ExecutionContext* RemotePlayback::getExecutionContext() const {
   return &m_mediaElement->document();
 }
 
-ScriptPromise RemotePlayback::getAvailability(ScriptState* scriptState) {
+ScriptPromise RemotePlayback::watchAvailability(
+    ScriptState* scriptState,
+    RemotePlaybackAvailabilityCallback* callback) {
   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): implement steps 4 and 5 of the algorithm.
+  // https://crbug.com/655233
+  int id;
+  do {
+    id = getExecutionContext()->circularSequentialID();
+  } while (!m_availabilityCallbacks.add(id, callback).isNewEntry);
+
+  if (!m_scriptState)
+    m_scriptState = scriptState;
+
+  // Report the current availability via the callback.
+  getExecutionContext()->postTask(
+      BLINK_FROM_HERE,
+      createSameThreadTask(&RemotePlayback::notifyInitialAvailability,
+                           wrapPersistent(this), id),

[haraken, 2016/10/15 01:52:45]

Would you help me understand why you need to post a task?

[mlamouri (slow - plz ping), 2016/10/15 18:14:00]

I'm not avayvod@ but I think this is because the spec says to queue a task.

[whywhat, 2016/10/16 03:41:40]

There's also an issue of calling the callback before the promise is resolved, I
think the developers would expect the callback to fire after and could do some
setup in the promise resolution.

+      "watchAvailabilityCallback");
+
   // TODO(avayvod): Currently the availability is tracked for each media element
   // as soon as it's created, we probably want to limit that to when the
   // page/element is visible (see https://crbug.com/597281) and has default
   // controls. If there are no default controls, we should also start tracking
-  // availability on demand meaning the Promise returned by getAvailability()
+  // availability on demand meaning the Promise returned by watchAvailability()
   // will be resolved asynchronously.
-  RemotePlaybackAvailability* availability =
-      RemotePlaybackAvailability::take(resolver, m_availability);
-  m_availabilityObjects.append(availability);
-  resolver->resolve(availability);
+  resolver->resolve(id);
+  return promise;
+}
+
+ScriptPromise RemotePlayback::cancelWatchAvailability(ScriptState* scriptState,
+                                                      int id) {
+  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;
+  }
+
+  auto iter = m_availabilityCallbacks.find(id);
+  if (iter == m_availabilityCallbacks.end()) {
+    resolver->reject(DOMException::create(
+        NotFoundError, "A callback with the given id is not found."));

[mlamouri (slow - plz ping), 2016/10/15 18:14:00]

s/is not found/was not found/ ?

+    return promise;
+  }
+
+  m_availabilityCallbacks.remove(iter);
+
+  resolver->resolve();
+  return promise;
+}
+
+ScriptPromise RemotePlayback::cancelWatchAvailability(
+    ScriptState* scriptState) {
+  ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+  ScriptPromise promise = resolver->promise();
+
+  if (m_mediaElement->fastHasAttribute(HTMLNames::disableremoteplaybackAttr)) {

[mlamouri (slow - plz ping), 2016/10/15 18:14:00]

Here and above, there is an issue where we don't cancel the callbacks when
`disableRemotePlayback` is set but we do prevent cancelling. I've open a spec
bug. No need to change this CL because we should address this on the spec side
first. Likely, we will cancel all the callbacks if `disableRemotePlayback` is
set to true.

[whywhat, 2016/10/16 03:41:40]

Right, thanks for filing the spec bug. Cancelling the callbacks sgtm.

+    resolver->reject(DOMException::create(
+        InvalidStateError, "disableRemotePlayback attribute is present."));
+    return promise;
+  }
+
+  m_availabilityCallbacks.clear();
+
+  resolver->resolve();
   return promise;
 }
 
 ScriptPromise RemotePlayback::prompt(ScriptState* scriptState) {
-  // TODO(avayvod): implement steps 4, 5, 8, 9 of the algorithm.
+  // 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;
   }
 
@@ skipping 23 matching lines @@
   }
 
   return promise;
 }
 
 String RemotePlayback::state() const {
   return remotePlaybackStateToString(m_state);
 }
 
 bool RemotePlayback::hasPendingActivity() const {
-  return hasEventListeners() || !m_availabilityObjects.isEmpty() ||
+  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(m_scriptState.get(), this, m_availability);
+}
+
 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 (m_promptPromiseResolver) {
     if (state != WebRemotePlaybackState::Disconnected)
       m_promptPromiseResolver->resolve();
     else
@@ skipping 17 matching lines @@
       dispatchEvent(Event::create(EventTypeNames::disconnect));
       break;
   }
 }
 
 void RemotePlayback::availabilityChanged(bool available) {
   if (m_availability == available)
     return;
 
   m_availability = available;
-  for (auto& availabilityObject : m_availabilityObjects)
-    availabilityObject->availabilityChanged(available);
+  for (auto& callback : m_availabilityCallbacks.values())
+    callback->call(m_scriptState.get(), this, m_availability);
 }
 
 void RemotePlayback::promptCancelled() {
   if (!m_promptPromiseResolver)
     return;
 
   m_promptPromiseResolver->reject(
       DOMException::create(NotAllowedError, "The prompt was dismissed."));
   m_promptPromiseResolver = nullptr;
 }
 
 DEFINE_TRACE(RemotePlayback) {
-  visitor->trace(m_availabilityObjects);
+  visitor->trace(m_availabilityCallbacks);
   visitor->trace(m_promptPromiseResolver);
   visitor->trace(m_mediaElement);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink