[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, connectedValue, ("connected"));
   DEFINE_STATIC_LOCAL(const AtomicString, disconnectedValue, ("disconnected"));
 
@@ skipping 29 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.

[Zhiqiang Zhang (Slow), 2016/10/13 15:23:11]

add a bug number?

[whywhat, 2016/10/14 19:58:19]

Done.

+  int id;
+  do {
+    id = getExecutionContext()->circularSequentialID();
+  } while (!m_availabilityCallbacks.add(id, callback).isNewEntry);

[bashi, 2016/10/13 00:45:46]

|callback| only has a weak reference to v8::Function and it could be
garbage-collected unless there is no owner of the function. This means that when
you keep |callback| in m_avaiabilityCallbacks, you need to set the v8 function
as a private property of the wrapper object of RemotePlayback. You can do that
by using [Custom=CallPrologue] or [Custom=CallEplilogue].

https://chromium.googlesource.com/chromium/src/+/master/third_party/WebKit/So...

In a custom binding, you will call V8PrivateProperty::getXXX().set() like
V8IDBObserver::constructorCustom()

This is a workaround to avoid circular dependency between v8 and blink objects.
When crbug.com/468240 is resolved we should be able to remove such workaround.
Sorry for inconvenience :(

[whywhat, 2016/10/14 19:58:19]

I think I need more info...

Should I add Prologue or Epilogue? I imagine I need to add custom handling to
both adding and removing callbacks?
V8IDBObserver has plenty of code in it which I have little idea about :) Is
copy/paste reliable? How do I test it actually works?
How do I pass the last callback I added to the HeapHashMap into that custom
method to bind it to the V8 callback?

Lastly, if I chose to implement the callback class myself, would I be able to
avoid this hassle? :)

[bashi, 2016/10/17 00:11:05]

Maybe either is fine.

As for removing, it depend on the relationship between the owner
(RemotePlayback?) and callbacks. If removal occurs regardless of the lifetime of
the owner, you may need to unregister callbacks. However it seems we don't
provide a way to do that. yukishiino@ ?
I think you just need to call V8PrivateProperty::getXXX().set(). It's hard to
test as we can't get v8 reference graphs from blink, but at least we should be
able to have layout tests.
I don't think you need to do it. The custom binding code is just for adding
owner -> callback reference in V8, and V8PrivateProperty does the job.
Unfortunately no. You will end up writing everything which the code generator
can generate...

+
+  if (!m_scriptState)
+    m_scriptState = scriptState;

[Zhiqiang Zhang (Slow), 2016/10/13 15:23:11]

Is this the same scriptState every time? Maybe yes or we don't care since it's
in the same ExecutionContext. Not sure.

[whywhat, 2016/10/14 19:58:19]

That's something I'm not 100% sure about. Other places using callbacks and
passing scriptState just acquire the value in their constructor (since it's
passed there) and keep it.

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

m_scriptState must be equal to scriptState.

You can just remove this code, or add DCHECK(m_scriptState == scriptState).

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

Do you mean I should remove the if and just always set m_scriptState to
scriptState or leave the if and add a DCHECK()?
I wish I could get ScriptState in the ctor and just save it there. Perhaps I
need to try to pass it in create().

[haraken, 2016/10/17 00:19:52]

Yes. You can save the ScriptState in the constructor and stop passing
ScriptState to these methods.

+
+  // Report the current availability via the callback.
+  getExecutionContext()->postTask(
+      BLINK_FROM_HERE,
+      createSameThreadTask(&RemotePlayback::notifyInitialAvailability,
+                           wrapPersistent(this), id),
+      "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."));
+    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)) {
+    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
       m_promptPromiseResolver->reject(DOMException::create(
           AbortError, "Failed to connect to the remote device."));
     m_promptPromiseResolver = nullptr;
   }
 
   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);
+  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