Remove MediaControls methods needed for the Cast button

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

 // Copyright 2015 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/MediaControlsImpl.h"
 
 #include <limits>
 #include <memory>
 #include "core/HTMLNames.h"
 #include "core/css/StylePropertySet.h"
 #include "core/dom/ClientRect.h"
 #include "core/dom/Document.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/StyleEngine.h"
 #include "core/events/Event.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/shadow/MediaControlElementTypes.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutObject.h"
 #include "core/loader/EmptyClients.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/media_controls/elements/MediaControlCurrentTimeDisplayElement.h"
 #include "modules/media_controls/elements/MediaControlDownloadButtonElement.h"
 #include "modules/media_controls/elements/MediaControlTimelineElement.h"
 #include "modules/media_controls/elements/MediaControlVolumeSliderElement.h"
+#include "modules/remoteplayback/HTMLMediaElementRemotePlayback.h"
+#include "modules/remoteplayback/RemotePlayback.h"
 #include "platform/heap/Handle.h"
 #include "platform/testing/EmptyWebMediaPlayer.h"
 #include "platform/testing/HistogramTester.h"
 #include "platform/testing/TestingPlatformSupport.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/WebMouseEvent.h"
 #include "public/platform/WebScreenInfo.h"
 #include "public/platform/WebSize.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackAvailability.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackClient.h"
@@ skipping 15 matching lines @@
 
 class MockVideoWebMediaPlayer : public EmptyWebMediaPlayer {
  public:
   // WebMediaPlayer overrides:
   WebTimeRanges Seekable() const override { return seekable_; }
   bool HasVideo() const override { return true; }
 
   WebTimeRanges seekable_;
 };
 
-class MockWebRemotePlaybackClient : public WebRemotePlaybackClient {
- public:
-  void StateChanged(WebRemotePlaybackState) override {}
-  void AvailabilityChanged(
-      WebRemotePlaybackAvailability availability) override {
-    availability_ = availability;
-  }
-  void PromptCancelled() override {}
-  bool RemotePlaybackAvailable() const override {
-    return availability_ == WebRemotePlaybackAvailability::kDeviceAvailable;
-  }
-
- private:
-  WebRemotePlaybackAvailability availability_ =
-      WebRemotePlaybackAvailability::kUnknown;
-};
-
 class MockLayoutObject : public LayoutObject {
  public:
   MockLayoutObject(Node* node) : LayoutObject(node) {}
 
   const char* GetName() const override { return "MockLayoutObject"; }
   void UpdateLayout() override {}
   FloatRect LocalBoundingBoxRectForAccessibility() const override {
     return FloatRect();
   }
 };
 
 class StubLocalFrameClient : public EmptyLocalFrameClient {
  public:
   static StubLocalFrameClient* Create() { return new StubLocalFrameClient; }
 
   std::unique_ptr<WebMediaPlayer> CreateWebMediaPlayer(
       HTMLMediaElement&,
       const WebMediaPlayerSource&,
       WebMediaPlayerClient*) override {
     return WTF::WrapUnique(new MockVideoWebMediaPlayer);
   }
 
   WebRemotePlaybackClient* CreateWebRemotePlaybackClient(
-      HTMLMediaElement&) override {
-    if (!remote_playback_client_) {
-      remote_playback_client_ =
-          WTF::WrapUnique(new MockWebRemotePlaybackClient);
-    }
-    return remote_playback_client_.get();
+      HTMLMediaElement& element) override {
+    return HTMLMediaElementRemotePlayback::remote(element);
   }
-
- private:
-  std::unique_ptr<MockWebRemotePlaybackClient> remote_playback_client_;
 };
 
 Element* GetElementByShadowPseudoId(Node& root_node,
                                     const char* shadow_pseudo_id) {
   for (Element& element : ElementTraversal::DescendantsOf(root_node)) {
     if (element.ShadowPseudoId() == shadow_pseudo_id)
       return &element;
   }
   return nullptr;
 }
@@ skipping 98 matching lines @@
 
   void SetReady() {
     MediaControls().MediaElement().SetReadyState(
         HTMLMediaElement::kHaveEnoughData);
   }
 
   void MouseDownAt(WebFloatPoint pos);
   void MouseMoveTo(WebFloatPoint pos);
   void MouseUpAt(WebFloatPoint pos);
 
+  bool HasAvailabilityCallbacks(RemotePlayback* remote_playback) {
+    return !remote_playback->availability_callbacks_.IsEmpty();
+  }
+
  private:
   std::unique_ptr<DummyPageHolder> page_holder_;
   Persistent<MediaControlsImpl> media_controls_;
   HistogramTester histogram_tester_;
 };
 
 void MediaControlsImplTest::MouseDownAt(WebFloatPoint pos) {
   WebMouseEvent mouse_down_event(WebInputEvent::kMouseDown,
                                  pos /* client pos */, pos /* screen pos */,
                                  WebPointerProperties::Button::kLeft, 1,
@@ skipping 101 matching lines @@
   Element* cast_button = GetElementByShadowPseudoId(
       MediaControls(), "-internal-media-controls-cast-button");
   ASSERT_NE(nullptr, cast_button);
 
   ASSERT_FALSE(IsElementVisible(*cast_button));
   SimulateRouteAvailable();
   ASSERT_TRUE(IsElementVisible(*cast_button));
 
   MediaControls().MediaElement().SetBooleanAttribute(
       HTMLNames::disableremoteplaybackAttr, true);
+  testing::RunPendingTasks();
   ASSERT_FALSE(IsElementVisible(*cast_button));
 
   MediaControls().MediaElement().SetBooleanAttribute(
       HTMLNames::disableremoteplaybackAttr, false);
+  testing::RunPendingTasks();
   ASSERT_TRUE(IsElementVisible(*cast_button));
 }
 
 TEST_F(MediaControlsImplTest, CastOverlayDefault) {
   Element* cast_overlay_button = GetElementByShadowPseudoId(
       MediaControls(), "-internal-media-controls-overlay-cast-button");
   ASSERT_NE(nullptr, cast_overlay_button);
 
   SimulateRouteAvailable();
   ASSERT_TRUE(IsElementVisible(*cast_overlay_button));
 }
 
 TEST_F(MediaControlsImplTest, CastOverlayDisableRemotePlaybackAttr) {
   Element* cast_overlay_button = GetElementByShadowPseudoId(
       MediaControls(), "-internal-media-controls-overlay-cast-button");
   ASSERT_NE(nullptr, cast_overlay_button);
 
   ASSERT_FALSE(IsElementVisible(*cast_overlay_button));
   SimulateRouteAvailable();
   ASSERT_TRUE(IsElementVisible(*cast_overlay_button));
 
   MediaControls().MediaElement().SetBooleanAttribute(
       HTMLNames::disableremoteplaybackAttr, true);
+  testing::RunPendingTasks();
   ASSERT_FALSE(IsElementVisible(*cast_overlay_button));
 
   MediaControls().MediaElement().SetBooleanAttribute(
       HTMLNames::disableremoteplaybackAttr, false);
+  testing::RunPendingTasks();
   ASSERT_TRUE(IsElementVisible(*cast_overlay_button));
 }
 
 TEST_F(MediaControlsImplTest, CastOverlayMediaControlsDisabled) {
   Element* cast_overlay_button = GetElementByShadowPseudoId(
       MediaControls(), "-internal-media-controls-overlay-cast-button");
   ASSERT_NE(nullptr, cast_overlay_button);
 
   EXPECT_FALSE(IsElementVisible(*cast_overlay_button));
   SimulateRouteAvailable();
@@ skipping 447 matching lines @@
   // Pressing a key prevents controls from hiding.
   MediaControls().PanelElement()->DispatchEvent(Event::Create("keypress"));
   platform->RunForPeriodSeconds(2);
   EXPECT_TRUE(IsElementVisible(*panel));
 
   // Once user interaction stops, controls can hide.
   platform->RunForPeriodSeconds(2);
   EXPECT_FALSE(IsElementVisible(*panel));
 }
 
+TEST_F(MediaControlsImplTest,
+       RemovingFromDocumentRemovesListenersAndCallbacks) {
+  auto page_holder = DummyPageHolder::Create();
+
+  HTMLMediaElement* element =
+      HTMLVideoElement::Create(page_holder->GetDocument());
+  element->SetBooleanAttribute(HTMLNames::controlsAttr, true);
+  page_holder->GetDocument().body()->AppendChild(element);
+
+  RemotePlayback* remote_playback =
+      HTMLMediaElementRemotePlayback::remote(*element);
+
+  EXPECT_TRUE(remote_playback->HasEventListeners());
+  EXPECT_TRUE(HasAvailabilityCallbacks(remote_playback));
+
+  WeakPersistent<HTMLMediaElement> weak_persistent_video = element;
+  {
+    Persistent<HTMLMediaElement> persistent_video = element;
+    page_holder->GetDocument().body()->setInnerHTML("");
+
+    // When removed from the document, the event listeners should have been
+    // dropped.
+    EXPECT_FALSE(remote_playback->HasEventListeners());
+    EXPECT_FALSE(HasAvailabilityCallbacks(remote_playback));
+  }
+
+  testing::RunPendingTasks();
+
+  ThreadState::Current()->CollectAllGarbage();
+
+  // It has been GC'd.
+  EXPECT_EQ(nullptr, weak_persistent_video);
+}
+
+TEST_F(MediaControlsImplTest,
+       ReInsertingInDocumentRestoresListenersAndCallbacks) {
+  auto page_holder = DummyPageHolder::Create();
+
+  HTMLMediaElement* element =
+      HTMLVideoElement::Create(page_holder->GetDocument());
+  element->SetBooleanAttribute(HTMLNames::controlsAttr, true);
+  page_holder->GetDocument().body()->AppendChild(element);
+
+  RemotePlayback* remote_playback =
+      HTMLMediaElementRemotePlayback::remote(*element);
+
+  // This should be a no-op. We keep a reference on the media element to avoid
+  // an unexpected GC.
+  {
+    Persistent<HTMLMediaElement> video_holder = element;
+    page_holder->GetDocument().body()->RemoveChild(element);
+    page_holder->GetDocument().body()->AppendChild(video_holder.Get());
+    EXPECT_TRUE(remote_playback->HasEventListeners());
+    EXPECT_TRUE(HasAvailabilityCallbacks(remote_playback));
+  }
+}
+
 }  // namespace blink