Disable background video track behind a feature flag

third_party/WebKit/Source/core/html/HTMLVideoElementTest.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 "core/html/HTMLVideoElement.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/loader/EmptyClients.h"
 #include "core/page/NetworkStateNotifier.h"
 #include "core/testing/DummyPageHolder.h"
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/WebMediaPlayer.h"
 #include "public/platform/WebSize.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
@@ skipping 33 matching lines @@
   unsigned decodedFrameCount() const override { return 0; };
   unsigned droppedFrameCount() const override { return 0; };
   size_t audioDecodedByteCount() const override { return 0; };
   size_t videoDecodedByteCount() const override { return 0; };
   void paint(WebCanvas*, const WebRect&, SkPaint&) override{};
 };
 
 class MockWebMediaPlayer : public EmptyWebMediaPlayer {
  public:
   MOCK_METHOD1(setBufferingStrategy, void(BufferingStrategy));
+  MOCK_METHOD1(selectedVideoTrackChanged,
+               void(blink::WebMediaPlayer::TrackId*));
+  MOCK_CONST_METHOD0(hasAudio, bool());
+  MOCK_CONST_METHOD0(hasVideo, bool());
 };
 
 class StubFrameLoaderClient : public EmptyFrameLoaderClient {
  public:
   static StubFrameLoaderClient* create() { return new StubFrameLoaderClient; }
 
   std::unique_ptr<WebMediaPlayer> createWebMediaPlayer(
       HTMLMediaElement&,
       const WebMediaPlayerSource&,
       WebMediaPlayerClient*) override {
@@ skipping 13 matching lines @@
     // TODO(sandersd): This should be done by a settings initializer.
     networkStateNotifier().setWebConnection(WebConnectionTypeWifi, 54.0);
     m_video = HTMLVideoElement::create(m_dummyPageHolder->document());
   }
 
   void setSrc(const AtomicString& url) {
     m_video->setSrc(url);
     testing::runPendingTasks();
   }
 
+  void setReadyState(HTMLMediaElement::ReadyState state) {
+    m_video->setReadyState(state);
+  }
+
+  void hide() { m_video->hidden(); }
+
+  void show() { m_video->shown(); }
+
   MockWebMediaPlayer* webMediaPlayer() {
     return static_cast<MockWebMediaPlayer*>(m_video->webMediaPlayer());
   }
 
   std::unique_ptr<DummyPageHolder> m_dummyPageHolder;
   Persistent<HTMLVideoElement> m_video;
 };
 
 TEST_F(HTMLVideoElementTest, setBufferingStrategy_NonUserPause) {
   setSrc("http://foo.bar/");
@@ skipping 38 matching lines @@
   }
   ::testing::Mock::VerifyAndClearExpectations(player);
 
   // On play, the strategy is set to normal.
   EXPECT_CALL(*player,
               setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Normal));
   m_video->play();
   ::testing::Mock::VerifyAndClearExpectations(player);
 }
 
+TEST_F(HTMLVideoElementTest, unselectSelectVideoTrackWhenHiddenAndShown) {
+  RuntimeEnabledFeatures::setBackgroundVideoTrackOptimizationEnabled(true);
+
+  setSrc("http://foo.bar/");
+  MockWebMediaPlayer* player = webMediaPlayer();
+  ASSERT_TRUE(player);
+
+  EXPECT_CALL(*player, hasAudio()).WillRepeatedly(::testing::Return(true));
+  EXPECT_CALL(*player, hasVideo()).WillRepeatedly(::testing::Return(true));
+
+  setReadyState(HTMLMediaElement::kHaveMetadata);
+
+  EXPECT_CALL(*player, selectedVideoTrackChanged(nullptr));
+  hide();
+  ::testing::Mock::VerifyAndClearExpectations(player);
+
+  EXPECT_CALL(*player, selectedVideoTrackChanged(::testing::_));
+  show();
+  ::testing::Mock::VerifyAndClearExpectations(player);
+}

[mlamouri (slow - plz ping), 2016/11/12 23:35:48]

tests <3

+
 }  // namespace blink