[Android, RemotePlayback] Implement HTMLMediaElement.remote.connect().

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/dom/Document.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", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, disconnectedValue, ("disconnected", AtomicString::ConstructFromLiteral));
 
     switch (state) {
     case WebRemotePlaybackState::Connected:
         return connectedValue;
     case WebRemotePlaybackState::Disconnected:
         return disconnectedValue;
     }
 
     ASSERT_NOT_REACHED();
     return disconnectedValue;
 }
 
 } // anonymous namespace
 
 // static
 RemotePlayback* RemotePlayback::create(HTMLMediaElement& element)
 {
     ASSERT(element.document().frame());
 
-    RemotePlayback* remotePlayback = new RemotePlayback(
-        element.document().frame(),
-        element.isPlayingRemotely() ? WebRemotePlaybackState::Connected : WebRemotePlaybackState::Disconnected,
-        element.hasRemoteRoutes());
+    RemotePlayback* remotePlayback = new RemotePlayback(element);
     element.setRemotePlaybackClient(remotePlayback);
 
     return remotePlayback;
 }
 
-RemotePlayback::RemotePlayback(LocalFrame* frame, WebRemotePlaybackState state, bool availability)
-    : DOMWindowProperty(frame)
-    , m_state(state)
-    , m_availability(availability)
+RemotePlayback::RemotePlayback(HTMLMediaElement& element)
+    : DOMWindowProperty(element.document().frame())
+    , m_state(element.isPlayingRemotely() ? WebRemotePlaybackState::Connected : WebRemotePlaybackState::Disconnected)
+    , m_availability(element.hasRemoteRoutes())
+    , m_mediaElement(&element)
 {
 }
 
 const AtomicString& RemotePlayback::interfaceName() const
 {
     return EventTargetNames::RemotePlayback;
 }
 
 ExecutionContext* RemotePlayback::getExecutionContext() const
 {
@@ skipping 11 matching lines @@
     // 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's
     // no default controls, we should also start tracking availability on demand
     // meaning the Promise returned by getAvailability() will be resolved asynchronously.
     RemotePlaybackAvailability* availability = RemotePlaybackAvailability::take(resolver, m_availability);
     m_availabilityObjects.append(availability);
     resolver->resolve(availability);
     return promise;
 }
 
+ScriptPromise RemotePlayback::connect(ScriptState* scriptState)
+{
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    // TODO(avayvod): should we have a flag or reuse the one for the PresentationRequest::start().

[mlamouri (slow - plz ping), 2016/03/24 10:47:06]

nit: "a flag to disable user gesture requirement". I spent a couple of seconds
wondering what flag you were mentioning.

[whywhat, 2016/03/24 16:08:40]

Done.

+    if (!UserGestureIndicator::processingUserGesture()) {
+        resolver->reject(DOMException::create(InvalidAccessError, "RemotePlayback::connect() requires user gesture."));
+        return promise;
+    }
+
+    if (!m_mediaElement) {
+        resolver->reject(DOMException::create(InvalidStateError, "The RemotePlayback is no longer associated with a media element."));
+        return promise;
+    }
+
+    m_connectPromiseResolvers.append(resolver);

[mlamouri (slow - plz ping), 2016/03/24 10:47:06]

Should you add a TODO that we are only resolving them if it succeeds? because we
are not aware if it fails to connect, right?

[whywhat, 2016/03/24 16:08:40]

We're actually getting a disconnected state change if the connection fails so I
added code to reject the promise when this happens.

+    if (m_state == WebRemotePlaybackState::Disconnected)
+        m_mediaElement->requestRemotePlayback();
+    else
+        m_mediaElement->requestRemotePlaybackControl();
+
+    return promise;
+}
+
 String RemotePlayback::state() const
 {
     return remotePlaybackStateToString(m_state);
 }
 
 void RemotePlayback::stateChanged(WebRemotePlaybackState state)
 {
     if (m_state == state)
         return;
 
+    if (state != WebRemotePlaybackState::Disconnected) {
+        for (auto& resolver : m_connectPromiseResolvers)
+            resolver->resolve(true);
+        m_connectPromiseResolvers.clear();
+    }
+
     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);
 }
 
 DEFINE_TRACE(RemotePlayback)
 {
     visitor->trace(m_availabilityObjects);
+    visitor->trace(m_mediaElement);
+    visitor->trace(m_connectPromiseResolvers);
     RefCountedGarbageCollectedEventTargetWithInlineData<RemotePlayback>::trace(visitor);
     DOMWindowProperty::trace(visitor);
 }
 
 } // namespace blink