[Android, RemotePlayback] Make RemotePlayback classes ActiveScriptWrappable's

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/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/events/Event.h"
@@ skipping 29 matching lines @@
 {
     ASSERT(element.document().frame());
 
     RemotePlayback* remotePlayback = new RemotePlayback(element);
     element.setRemotePlaybackClient(remotePlayback);
 
     return remotePlayback;
 }
 
 RemotePlayback::RemotePlayback(HTMLMediaElement& element)
-    : DOMWindowProperty(element.document().frame())
+    : ActiveScriptWrappable(this)
+    , ContextLifecycleObserver(&element.document())
     , 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
 {
-    if (!m_frame)
-        return 0;
-    return m_frame->document();
+    return ContextLifecycleObserver::getExecutionContext();
 }
 
 ScriptPromise RemotePlayback::getAvailability(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     // 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's
@@ skipping 26 matching lines @@
     }
 
     return promise;
 }
 
 String RemotePlayback::state() const
 {
     return remotePlaybackStateToString(m_state);
 }
 
+bool RemotePlayback::hasPendingActivity() const
+{
+    return hasEventListeners()
+        || !m_availabilityObjects.isEmpty()
+        || !m_connectPromiseResolvers.isEmpty();
+}
+
 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 (state != WebRemotePlaybackState::Disconnected) {
         for (auto& resolver : m_connectPromiseResolvers)
             resolver->resolve(true);
@@ skipping 13 matching lines @@
 void RemotePlayback::availabilityChanged(bool available)
 {
     if (m_availability == available)
         return;
 
     m_availability = available;
     for (auto& availabilityObject : m_availabilityObjects)
         availabilityObject->availabilityChanged(available);
 }
 
 void RemotePlayback::connectCancelled()

[haraken, 2016/06/03 14:14:36]

Not directly related to this CL, I think you need to call connectCancelled()
when ContextLifecycleObserver::stop() is called (i.e., when the execution
context stopped).

If you really need to have a pointer to ExecutionContext, you should just add
Member<ExecutionContext>.

[whywhat, 2016/06/03 14:33:45]

You mean LifecycleObserver::contextDestroyed() ? Done.
I wish I knew what I really need. All I know is that executionContext() needs to
be implemented for EventTarget. I have no idea whether I need to keep the
context alive or observe it. Seems like the latter is what's used by other
modules.

Any clarifications are welcome :)

 {
     for (auto& resolver : m_connectPromiseResolvers)
         resolver->resolve(false);
     m_connectPromiseResolvers.clear();
 }
 
 DEFINE_TRACE(RemotePlayback)
 {
     visitor->trace(m_availabilityObjects);
+    visitor->trace(m_connectPromiseResolvers);
     visitor->trace(m_mediaElement);
-    visitor->trace(m_connectPromiseResolvers);
     EventTargetWithInlineData::trace(visitor);
-    DOMWindowProperty::trace(visitor);
+    ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink