Remove MediaControls methods needed for the Cast button

third_party/WebKit/Source/modules/media_controls/MediaControlsImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 11 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/media_controls/MediaControlsImpl.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ClientRect.h"
 #include "core/dom/Fullscreen.h"
+#include "core/dom/MutationCallback.h"
+#include "core/dom/MutationObserver.h"
+#include "core/dom/MutationObserverInit.h"
+#include "core/dom/MutationRecord.h"
 #include "core/dom/ResizeObserver.h"
 #include "core/dom/ResizeObserverCallback.h"
 #include "core/dom/ResizeObserverEntry.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/MouseEvent.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/media/HTMLMediaElementControlsList.h"
@@ skipping 14 matching lines @@
 #include "modules/media_controls/elements/MediaControlOverlayEnclosureElement.h"
 #include "modules/media_controls/elements/MediaControlOverlayPlayButtonElement.h"
 #include "modules/media_controls/elements/MediaControlPanelElement.h"
 #include "modules/media_controls/elements/MediaControlPanelEnclosureElement.h"
 #include "modules/media_controls/elements/MediaControlPlayButtonElement.h"
 #include "modules/media_controls/elements/MediaControlRemainingTimeDisplayElement.h"
 #include "modules/media_controls/elements/MediaControlTextTrackListElement.h"
 #include "modules/media_controls/elements/MediaControlTimelineElement.h"
 #include "modules/media_controls/elements/MediaControlToggleClosedCaptionsButtonElement.h"
 #include "modules/media_controls/elements/MediaControlVolumeSliderElement.h"
+#include "modules/remoteplayback/HTMLMediaElementRemotePlayback.h"
+#include "modules/remoteplayback/RemotePlayback.h"
 #include "platform/EventDispatchForbiddenScope.h"
 
 namespace blink {
 
 namespace {
 
 // TODO(steimel): should have better solution than hard-coding pixel values.
 // Defined in core/css/mediaControls.css, core/css/mediaControlsAndroid.css,
 // and core/paint/MediaControlsPainter.cpp.
 constexpr int kOverlayPlayButtonWidth = 48;
@@ skipping 49 matching lines @@
     return false;
 
   // The page disabled the button via the attribute.
   if (media_element.ControlsListInternal()->ShouldHideRemotePlayback()) {
     UseCounter::Count(
         media_element.GetDocument(),
         UseCounter::kHTMLMediaElementControlsListNoRemotePlayback);
     return false;
   }
 
-  return media_element.HasRemoteRoutes();
+  RemotePlayback* remote =
+      HTMLMediaElementRemotePlayback::remote(media_element);
+  return remote && remote->RemotePlaybackAvailable();
 }
 
 bool PreferHiddenVolumeControls(const Document& document) {
   return !document.GetSettings() ||
          document.GetSettings()->GetPreferHiddenVolumeControls();
 }
 
 }  // anonymous namespace
 
 class MediaControlsImpl::BatchedControlUpdate {
@@ skipping 40 matching lines @@
 
   DEFINE_INLINE_TRACE() {
     visitor->Trace(controls_);
     ResizeObserverCallback::Trace(visitor);
   }
 
  private:
   Member<MediaControlsImpl> controls_;
 };
 
+// Observes changes to the HTMLMediaElement attributes that affect controls.
+// Currently only observes the disableRemotePlayback attribute.
+class MediaControlsImpl::MediaElementMutationCallback
+    : public MutationCallback {
+ public:
+  explicit MediaElementMutationCallback(MediaControlsImpl* controls)
+      : controls_(controls) {
+    observer_ = MutationObserver::Create(this);
+    Vector<String> filter;
+    filter.push_back(HTMLNames::disableremoteplaybackAttr.ToString());
+    MutationObserverInit init;
+    init.setAttributeOldValue(true);
+    init.setAttributes(true);
+    init.setAttributeFilter(filter);
+    observer_->observe(&controls_->MediaElement(), init, ASSERT_NO_EXCEPTION);
+  }
+
+  DEFINE_INLINE_VIRTUAL_TRACE() {
+    visitor->Trace(controls_);
+    visitor->Trace(observer_);
+    MutationCallback::Trace(visitor);
+  }
+
+  void Disconnect() { observer_->disconnect(); }
+
+ private:
+  void Call(const HeapVector<Member<MutationRecord>>& records,
+            MutationObserver*) override {
+    for (const auto& record : records) {
+      if (record->type() != "attributes")
+        continue;
+
+      const Element& element = *ToElement(record->target());
+      if (record->oldValue() == element.getAttribute(record->attributeName()))
+        continue;
+
+      DCHECK_EQ(HTMLNames::disableremoteplaybackAttr.ToString(),
+                record->attributeName());
+      controls_->RefreshCastButtonVisibility();
+      return;
+    }
+  }
+
+  ExecutionContext* GetExecutionContext() const override {
+    return &controls_->GetDocument();
+  }
+
+  Member<MediaControlsImpl> controls_;
+  Member<MutationObserver> observer_;
+};
+
 MediaControls* MediaControlsImpl::Factory::Create(
     HTMLMediaElement& media_element,
     ShadowRoot& shadow_root) {
   return MediaControlsImpl::Create(media_element, shadow_root);
 }
 
 MediaControlsImpl::MediaControlsImpl(HTMLMediaElement& media_element)
     : HTMLDivElement(media_element.GetDocument()),
       MediaControls(media_element),
       overlay_enclosure_(nullptr),
@@ skipping 204 matching lines @@
     orientation_lock_delegate_->Attach();
 
   if (!resize_observer_) {
     resize_observer_ =
         ResizeObserver::Create(MediaElement().GetDocument(),
                                new MediaControlsResizeObserverCallback(this));
     HTMLMediaElement& html_media_element = MediaElement();
     resize_observer_->observe(&html_media_element);
   }
 
+  if (!element_mutation_callback_)
+    element_mutation_callback_ = new MediaElementMutationCallback(this);
+
   return HTMLDivElement::InsertedInto(root);
 }
 
 void MediaControlsImpl::RemovedFrom(ContainerNode*) {
   DCHECK(!MediaElement().isConnected());
 
   // TODO(mlamouri): we hide show the controls instead of having
   // HTMLMediaElement do it.
 
   window_event_listener_->Stop();
   media_event_listener_->Detach();
   if (orientation_lock_delegate_)
     orientation_lock_delegate_->Detach();
 
   resize_observer_.Clear();
+
+  if (element_mutation_callback_) {
+    element_mutation_callback_->Disconnect();
+    element_mutation_callback_.Clear();
+  }
 }
 
 void MediaControlsImpl::Reset() {
   EventDispatchForbiddenScope::AllowUserAgentEvents allow_events_in_shadow;
   BatchedControlUpdate batch(this);
 
   const double duration = MediaElement().duration();
   duration_display_->setTextContent(
       LayoutTheme::GetTheme().FormatMediaControlsTime(duration));
   duration_display_->SetCurrentValue(duration);
@@ skipping 65 matching lines @@
   panel_->MakeOpaque();
 }
 
 void MediaControlsImpl::MakeTransparent() {
   panel_->MakeTransparent();
 }
 
 bool MediaControlsImpl::ShouldHideMediaControls(unsigned behavior_flags) const {
   // Never hide for a media element without visual representation.
   if (!MediaElement().IsHTMLVideoElement() || !MediaElement().HasVideo() ||
-      MediaElement().IsPlayingRemotely() ||
       toHTMLVideoElement(MediaElement()).GetMediaRemotingStatus() ==
           HTMLVideoElement::MediaRemotingStatus::kStarted) {
     return false;
   }
 
+  RemotePlayback* remote =
+      HTMLMediaElementRemotePlayback::remote(MediaElement());
+  if (remote && remote->GetState() != WebRemotePlaybackState::kDisconnected)
+    return false;
+
   // Keep the controls visible as long as the timer is running.
   const bool ignore_wait_for_timer = behavior_flags & kIgnoreWaitForTimer;
   if (!ignore_wait_for_timer && keep_showing_until_timer_fires_)
     return false;
 
   // Don't hide if the mouse is over the controls.
   const bool ignore_controls_hover = behavior_flags & kIgnoreControlsHover;
   if (!ignore_controls_hover && panel_->IsHovered())
     return false;
 
@@ skipping 119 matching lines @@
     overlay_cast_button_->TryShowOverlay();
     cast_button_->SetIsWanted(false);
   } else if (MediaElement().ShouldShowControls()) {
     overlay_cast_button_->SetIsWanted(false);
     cast_button_->SetIsWanted(true);
   }
 }
 
 void MediaControlsImpl::ShowOverlayCastButtonIfNeeded() {
   if (MediaElement().ShouldShowControls() ||
-      !ShouldShowCastButton(MediaElement()))
+      !ShouldShowCastButton(MediaElement())) {
     return;
+  }
 
   overlay_cast_button_->TryShowOverlay();
   ResetHideMediaControlsTimer();
 }
 
 void MediaControlsImpl::EnterFullscreen() {
   Fullscreen::RequestFullscreen(MediaElement());
 }
 
 void MediaControlsImpl::ExitFullscreen() {
   Fullscreen::ExitFullscreen(GetDocument());
 }
 
-void MediaControlsImpl::StartedCasting() {
-  cast_button_->SetIsPlayingRemotely(true);
-  overlay_cast_button_->SetIsPlayingRemotely(true);
-}
-
-void MediaControlsImpl::StoppedCasting() {
-  cast_button_->SetIsPlayingRemotely(false);
-  overlay_cast_button_->SetIsPlayingRemotely(false);
+void MediaControlsImpl::RemotePlaybackStateChanged() {
+  cast_button_->UpdateDisplayType();
+  overlay_cast_button_->UpdateDisplayType();
 }
 
 void MediaControlsImpl::DefaultEventHandler(Event* event) {
   HTMLDivElement::DefaultEventHandler(event);
 
   // Do not handle events to not interfere with the rest of the page if no
   // controls should be visible.
   if (!MediaElement().ShouldShowControls())
     return;
 
@@ skipping 403 matching lines @@
 void MediaControlsImpl::HideAllMenus() {
   window_event_listener_->Stop();
 
   if (overflow_list_->IsWanted())
     overflow_list_->SetIsWanted(false);
   if (text_track_list_->IsWanted())
     text_track_list_->SetVisible(false);
 }
 
 DEFINE_TRACE(MediaControlsImpl) {
+  visitor->Trace(element_mutation_callback_);
   visitor->Trace(resize_observer_);
   visitor->Trace(panel_);
   visitor->Trace(overlay_play_button_);
   visitor->Trace(overlay_enclosure_);
   visitor->Trace(play_button_);
   visitor->Trace(current_time_display_);
   visitor->Trace(timeline_);
   visitor->Trace(mute_button_);
   visitor->Trace(volume_slider_);
   visitor->Trace(toggle_closed_captions_button_);
   visitor->Trace(fullscreen_button_);
   visitor->Trace(download_button_);
   visitor->Trace(duration_display_);
   visitor->Trace(enclosure_);
   visitor->Trace(text_track_list_);
   visitor->Trace(overflow_menu_);
   visitor->Trace(overflow_list_);
   visitor->Trace(cast_button_);
   visitor->Trace(overlay_cast_button_);
   visitor->Trace(media_event_listener_);
   visitor->Trace(window_event_listener_);
   visitor->Trace(orientation_lock_delegate_);
   MediaControls::Trace(visitor);
   HTMLDivElement::Trace(visitor);
 }
 
 }  // namespace blink