Remove MediaControls methods needed for the Cast button

third_party/WebKit/Source/modules/media_controls/MediaControlsMediaEventListener.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/media_controls/MediaControlsMediaEventListener.h"
 
 #include "core/events/Event.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/track/TextTrackList.h"
 #include "modules/media_controls/MediaControlsImpl.h"
+#include "modules/remoteplayback/HTMLMediaElementRemotePlayback.h"
+#include "modules/remoteplayback/RemotePlayback.h"
 
 namespace blink {
 
 MediaControlsMediaEventListener::MediaControlsMediaEventListener(
     MediaControlsImpl* media_controls)
     : EventListener(kCPPEventListenerType), media_controls_(media_controls) {
   if (GetMediaElement().isConnected())
     Attach();
 }
 
@@ skipping 23 matching lines @@
   TextTrackList* text_tracks = GetMediaElement().textTracks();
   text_tracks->addEventListener(EventTypeNames::addtrack, this, false);
   text_tracks->addEventListener(EventTypeNames::change, this, false);
   text_tracks->addEventListener(EventTypeNames::removetrack, this, false);
 
   // Keypress events.
   if (media_controls_->PanelElement()) {
     media_controls_->PanelElement()->addEventListener(EventTypeNames::keypress,
                                                       this, false);
   }
+
+  RemotePlayback* remote = GetRemotePlayback();
+  if (remote) {
+    remote->addEventListener(EventTypeNames::connect, this);
+    remote->addEventListener(EventTypeNames::connecting, this);
+    remote->addEventListener(EventTypeNames::disconnect, this);
+
+    if (remote_playback_availability_callback_id_ == -1) {
+      remote_playback_availability_callback_id_ =
+          remote->WatchAvailabilityInternal(
+              new RemotePlayback::AvailabilityCallback(
+                  WTF::Bind(&MediaControlsMediaEventListener::
+                                OnRemotePlaybackAvailabilityChanged,
+                            WrapPersistent(this))));
+    }
+  }
 }
 
 void MediaControlsMediaEventListener::Detach() {
   DCHECK(!GetMediaElement().isConnected());
 
   media_controls_->GetDocument().removeEventListener(
       EventTypeNames::fullscreenchange, this, false);
 
   TextTrackList* text_tracks = GetMediaElement().textTracks();
   text_tracks->removeEventListener(EventTypeNames::addtrack, this, false);
   text_tracks->removeEventListener(EventTypeNames::change, this, false);
   text_tracks->removeEventListener(EventTypeNames::removetrack, this, false);
 
   if (media_controls_->PanelElement()) {
     media_controls_->PanelElement()->removeEventListener(
         EventTypeNames::keypress, this, false);
   }
+
+  RemotePlayback* remote = GetRemotePlayback();
+  if (remote) {
+    remote->removeEventListener(EventTypeNames::connect, this);
+    remote->removeEventListener(EventTypeNames::connecting, this);
+    remote->removeEventListener(EventTypeNames::disconnect, this);
+
+    DCHECK_NE(-1, remote_playback_availability_callback_id_);
+    remote->CancelWatchAvailabilityInternal(
+        remote_playback_availability_callback_id_);
+    remote_playback_availability_callback_id_ = -1;
+  }
 }
 
 bool MediaControlsMediaEventListener::operator==(
     const EventListener& other) const {
   return this == &other;
 }
 
 HTMLMediaElement& MediaControlsMediaEventListener::GetMediaElement() {
   return media_controls_->MediaElement();
 }
 
+RemotePlayback* MediaControlsMediaEventListener::GetRemotePlayback() {
+  return HTMLMediaElementRemotePlayback::remote(GetMediaElement());
+}
+
 void MediaControlsMediaEventListener::handleEvent(
     ExecutionContext* execution_context,
     Event* event) {
   if (event->type() == EventTypeNames::volumechange) {
     media_controls_->OnVolumeChange();
     return;
   }
   if (event->type() == EventTypeNames::focusin) {
     media_controls_->OnFocusIn();
     return;
@@ skipping 48 matching lines @@
     return;
   }
 
   // Keypress events.
   if (event->type() == EventTypeNames::keypress) {
     if (event->currentTarget() == media_controls_->PanelElement())
       media_controls_->OnPanelKeypress();
     return;
   }
 
+  // RemotePlayback state change events.
+  if (event->type() == EventTypeNames::connect ||
+      event->type() == EventTypeNames::connecting ||
+      event->type() == EventTypeNames::disconnect) {
+    media_controls_->RefreshCastButtonVisibility();
+    return;
+  }
+
   NOTREACHED();
 }
 
+void MediaControlsMediaEventListener::OnRemotePlaybackAvailabilityChanged() {
+  media_controls_->RefreshCastButtonVisibility();
+}
+
 DEFINE_TRACE(MediaControlsMediaEventListener) {
   EventListener::Trace(visitor);
   visitor->Trace(media_controls_);
 }
 
 }  // namespace blink