[Blink, RemotePlaybackAPI] Create WebRemotePlaybackClient in HTMLMediaElement ctor to avoid lazy in…

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 22 matching lines @@
       return disconnectedValue;
   }
 
   ASSERT_NOT_REACHED();
   return disconnectedValue;
 }
 
 }  // 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;
+RemotePlayback* RemotePlayback::create(HTMLMediaElement& element) {
+  return new RemotePlayback(element);
 }
 
-RemotePlayback::RemotePlayback(ScriptState* scriptState,
-                               HTMLMediaElement& element)
+RemotePlayback::RemotePlayback(HTMLMediaElement& element)
     : ActiveScriptWrappable(this),
-      m_scriptState(scriptState),
       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 {
   return &m_mediaElement->document();
 }
 
 ScriptPromise RemotePlayback::watchAvailability(
+    ScriptState* scriptState,
     RemotePlaybackAvailabilityCallback* callback) {
-  ScriptPromiseResolver* resolver =
-      ScriptPromiseResolver::create(m_scriptState.get());
+  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
@@ skipping 15 matching lines @@
   // 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 watchAvailability()
   // will be resolved asynchronously.
   resolver->resolve(id);
   return promise;
 }
 
-ScriptPromise RemotePlayback::cancelWatchAvailability(int id) {
-  ScriptPromiseResolver* resolver =
-      ScriptPromiseResolver::create(m_scriptState.get());
+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() {
-  ScriptPromiseResolver* resolver =
-      ScriptPromiseResolver::create(m_scriptState.get());
+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() {
+ScriptPromise RemotePlayback::prompt(ScriptState* scriptState) {
   // TODO(avayvod): implement steps 5, 8, 9 of the algorithm.
   // https://crbug.com/647441
-  ScriptPromiseResolver* resolver =
-      ScriptPromiseResolver::create(m_scriptState.get());
+  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;
   }
 
   if (m_promptPromiseResolver) {
     resolver->reject(DOMException::create(
@@ skipping 120 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(RemotePlayback) {
   for (auto callback : m_availabilityCallbacks.values()) {
     visitor->traceWrappers(callback);
   }
   EventTargetWithInlineData::traceWrappers(visitor);
 }
 
 }  // namespace blink