Remove MediaControls methods needed for the Cast button

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 29 matching lines @@
 }
 
 void RunNotifyInitialAvailabilityTask(ExecutionContext* context,
                                       std::unique_ptr<WTF::Closure> task) {
   probe::AsyncTask async_task(context, task.get());
   (*task)();
 }
 
 }  // anonymous namespace
 
+RemotePlayback::AvailabilityCallback::AvailabilityCallback(
+    RemotePlaybackAvailabilityCallback* callback)
+    : bindings_cb_(this, callback) {}
+
+RemotePlayback::AvailabilityCallback::AvailabilityCallback(
+    std::unique_ptr<WTF::Closure> callback)
+    : bindings_cb_(nullptr, nullptr), internal_cb_(std::move(callback)) {}
+
+void RemotePlayback::AvailabilityCallback::Run(RemotePlayback* remote_playback,
+                                               bool new_availability) {
+  if (internal_cb_) {
+    DCHECK(!bindings_cb_);
+    (*internal_cb_.get())();
+    return;
+  }
+
+  bindings_cb_->call(remote_playback, new_availability);
+}
+
+DEFINE_TRACE_WRAPPERS(RemotePlayback::AvailabilityCallback) {
+  visitor->TraceWrappers(bindings_cb_);
+}
+
 // static
 RemotePlayback* RemotePlayback::Create(HTMLMediaElement& element) {
   return new RemotePlayback(element);
 }
 
 RemotePlayback::RemotePlayback(HTMLMediaElement& element)
     : state_(element.IsPlayingRemotely()
                  ? WebRemotePlaybackState::kConnected
                  : WebRemotePlaybackState::kDisconnected),
       availability_(WebRemotePlaybackAvailability::kUnknown),
@@ skipping 19 matching lines @@
     return promise;
   }
 
   if (MemoryCoordinator::IsLowEndDevice()) {
     resolver->Reject(DOMException::Create(
         kNotSupportedError,
         "Availability monitoring is not supported on this device."));
     return promise;
   }
 
-  int id;
-  do {
-    id = GetExecutionContext()->CircularSequentialID();
-  } while (
-      !availability_callbacks_
-           .insert(id, TraceWrapperMember<RemotePlaybackAvailabilityCallback>(
-                           this, callback))
-           .is_new_entry);
-
-  // Report the current availability via the callback.
-  // TODO(yuryu): Wrapping notifyInitialAvailability with WTF::Closure as
-  // InspectorInstrumentation requires a globally unique pointer to track tasks.
-  // We can remove the wrapper if InspectorInstrumentation returns a task id.
-  std::unique_ptr<WTF::Closure> task = WTF::Bind(
-      &RemotePlayback::NotifyInitialAvailability, WrapPersistent(this), id);
-  probe::AsyncTaskScheduled(GetExecutionContext(), "watchAvailabilityCallback",
-                            task.get());
-  TaskRunnerHelper::Get(TaskType::kMediaElementEvent, GetExecutionContext())
-      ->PostTask(BLINK_FROM_HERE,
-                 WTF::Bind(RunNotifyInitialAvailabilityTask,
-                           WrapPersistent(GetExecutionContext()),
-                           WTF::Passed(std::move(task))));
+  int id = WatchAvailabilityInternal(new AvailabilityCallback(callback));
 
   // 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(ScriptState* script_state,
                                                       int id) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   if (media_element_->FastHasAttribute(HTMLNames::disableremoteplaybackAttr)) {
     resolver->Reject(DOMException::Create(
         kInvalidStateError, "disableRemotePlayback attribute is present."));
     return promise;
   }
 
-  auto iter = availability_callbacks_.Find(id);
-  if (iter == availability_callbacks_.end()) {
+  if (!CancelWatchAvailabilityInternal(id)) {
     resolver->Reject(DOMException::Create(
         kNotFoundError, "A callback with the given id is not found."));
     return promise;
   }
 
-  availability_callbacks_.erase(iter);
-
   resolver->Resolve();
   return promise;
 }
 
 ScriptPromise RemotePlayback::cancelWatchAvailability(
     ScriptState* script_state) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   if (media_element_->FastHasAttribute(HTMLNames::disableremoteplaybackAttr)) {
@@ skipping 41 matching lines @@
   }
 
   if (availability_ == WebRemotePlaybackAvailability::kSourceNotSupported ||
       availability_ == WebRemotePlaybackAvailability::kSourceNotCompatible) {
     resolver->Reject(DOMException::Create(
         kNotSupportedError,
         "The currentSrc is not compatible with remote playback"));
     return promise;
   }
 
-  if (state_ == WebRemotePlaybackState::kDisconnected) {
-    prompt_promise_resolver_ = resolver;
-    media_element_->RequestRemotePlayback();
-  } else {
-    prompt_promise_resolver_ = resolver;
-    media_element_->RequestRemotePlaybackControl();
-  }
+  prompt_promise_resolver_ = resolver;
+  PromptInternal();
 
   return promise;
 }
 
 String RemotePlayback::state() const {
   return RemotePlaybackStateToString(state_);
 }
 
 bool RemotePlayback::HasPendingActivity() const {
   return HasEventListeners() || !availability_callbacks_.IsEmpty() ||
          prompt_promise_resolver_;
 }
 
+void RemotePlayback::PromptInternal() {
+  if (state_ == WebRemotePlaybackState::kDisconnected)
+    media_element_->RequestRemotePlayback();
+  else
+    media_element_->RequestRemotePlaybackControl();
+}
+
+int RemotePlayback::WatchAvailabilityInternal(AvailabilityCallback* callback) {
+  int id;
+  do {
+    id = GetExecutionContext()->CircularSequentialID();
+  } while (!availability_callbacks_.insert(id, callback).is_new_entry);
+
+  // Report the current availability via the callback.
+  // TODO(yuryu): Wrapping notifyInitialAvailability with WTF::Closure as
+  // InspectorInstrumentation requires a globally unique pointer to track tasks.
+  // We can remove the wrapper if InspectorInstrumentation returns a task id.
+  std::unique_ptr<WTF::Closure> task = WTF::Bind(
+      &RemotePlayback::NotifyInitialAvailability, WrapPersistent(this), id);
+  probe::AsyncTaskScheduled(GetExecutionContext(), "watchAvailabilityCallback",
+                            task.get());
+  TaskRunnerHelper::Get(TaskType::kMediaElementEvent, GetExecutionContext())
+      ->PostTask(BLINK_FROM_HERE,
+                 WTF::Bind(RunNotifyInitialAvailabilityTask,
+                           WrapPersistent(GetExecutionContext()),
+                           WTF::Passed(std::move(task))));
+  return id;
+}
+
+bool RemotePlayback::CancelWatchAvailabilityInternal(int id) {
+  auto iter = availability_callbacks_.Find(id);
+  if (iter == availability_callbacks_.end())
+    return false;
+  availability_callbacks_.erase(iter);
+  return true;
+}
+
 void RemotePlayback::NotifyInitialAvailability(int callback_id) {
   // May not find the callback if the website cancels it fast enough.
   auto iter = availability_callbacks_.Find(callback_id);
   if (iter == availability_callbacks_.end())
     return;
 
-  iter->value->call(this, RemotePlaybackAvailable());
+  iter->value->Run(this, RemotePlaybackAvailable());
 }
 
 void RemotePlayback::StateChanged(WebRemotePlaybackState state) {
   if (state_ == state)
     return;
 
   if (prompt_promise_resolver_) {
     // Changing state to Disconnected from "disconnected" or "connecting" means
     // that establishing connection with remote playback device failed.
     // Changing state to anything else means the state change intended by
@@ skipping 31 matching lines @@
   if (availability_ == availability)
     return;
 
   bool old_availability = RemotePlaybackAvailable();
   availability_ = availability;
   bool new_availability = RemotePlaybackAvailable();
   if (new_availability == old_availability)
     return;
 
   for (auto& callback : availability_callbacks_.Values())
-    callback->call(this, new_availability);
+    callback->Run(this, new_availability);
 }
 
 void RemotePlayback::PromptCancelled() {
   if (!prompt_promise_resolver_)
     return;
 
   prompt_promise_resolver_->Reject(
       DOMException::Create(kNotAllowedError, "The prompt was dismissed."));
   prompt_promise_resolver_ = nullptr;
 }
@@ skipping 15 matching lines @@
     media_element_->RequestRemotePlaybackStop();
 }
 
 DEFINE_TRACE(RemotePlayback) {
   visitor->Trace(availability_callbacks_);
   visitor->Trace(prompt_promise_resolver_);
   visitor->Trace(media_element_);
   EventTargetWithInlineData::Trace(visitor);
 }
 
-DEFINE_TRACE_WRAPPERS(RemotePlayback) {
-  for (auto callback : availability_callbacks_.Values()) {
-    visitor->TraceWrappers(callback);
-  }
-  EventTargetWithInlineData::TraceWrappers(visitor);
-}
-
 }  // namespace blink