Add HTMLVideoElementTest

third_party/WebKit/Source/core/html/HTMLVideoElementTest.cpp

Index: third_party/WebKit/Source/core/html/HTMLVideoElementTest.cpp
diff --git a/third_party/WebKit/Source/core/html/HTMLVideoElementTest.cpp b/third_party/WebKit/Source/core/html/HTMLVideoElementTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fc52ebb629304027a08ee664745ea25d7492eb67
--- /dev/null
+++ b/third_party/WebKit/Source/core/html/HTMLVideoElementTest.cpp
@@ -0,0 +1,146 @@
+// 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 "config.h"
+#include "core/html/HTMLVideoElement.h"
+
+#include "core/dom/Document.h"
+#include "core/loader/EmptyClients.h"
+#include "core/page/NetworkStateNotifier.h"
+#include "core/testing/DummyPageHolder.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"
+
+namespace blink {
+
+namespace {
+
+class EmptyWebMediaPlayer : public WebMediaPlayer {

[sandersd (OOO until July 31), 2015/12/17 19:05:56]

It seems like this should be in a separate file, but I don't see empty
implementations of public classes. Is there a convention for this?

[philipj_slow, 2015/12/18 15:02:27]

Not that I'm aware of, until now we haven't had any use for an empty
implementation of this. Perhaps someone with more experience writing unit tests
inside Blink would know, maybe mlamouri@

[mlamouri (slow - plz ping), 2016/01/05 15:00:07]

What about doing something similar to:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

You could basically add a MockWebMediaPlayer that will mock all the methods.
WDYT?

+public:
+    void load(LoadType, const WebURL&, CORSMode) override { };
+    void play() override { };
+    void pause() override { };
+    bool supportsSave() const override { return false; };
+    void seek(double seconds) override { };
+    void setRate(double) override { };
+    void setVolume(double) override { };
+    WebTimeRanges buffered() const override { return WebTimeRanges(); };
+    WebTimeRanges seekable() const override { return WebTimeRanges(); };
+    void setSinkId(const WebString& sinkId, const WebSecurityOrigin&, WebSetSinkIdCallbacks*) override { };
+    bool hasVideo() const override { return false; };
+    bool hasAudio() const override { return false; };
+    WebSize naturalSize() const override { return WebSize(0, 0); };
+    bool paused() const override { return false; };
+    bool seeking() const override { return false; };
+    double duration() const override { return 0.0; };
+    double currentTime() const override { return 0.0; };
+    NetworkState networkState() const override { return NetworkStateEmpty; };
+    ReadyState readyState() const override { return ReadyStateHaveNothing; };
+    bool didLoadingProgress() override { return false; };
+    bool hasSingleSecurityOrigin() const override { return true; };
+    bool didPassCORSAccessCheck() const override { return true; };
+    double mediaTimeForTimeValue(double timeValue) const override { return timeValue; };
+    unsigned decodedFrameCount() const override { return 0; };
+    unsigned droppedFrameCount() const override { return 0; };
+    unsigned audioDecodedByteCount() const override { return 0; };
+    unsigned videoDecodedByteCount() const override { return 0; };
+    void paint(WebCanvas*, const WebRect&, unsigned char alpha, SkXfermode::Mode) override { };
+};
+
+class MockWebMediaPlayer : public EmptyWebMediaPlayer {
+public:
+    MOCK_METHOD1(setBufferingStrategy, void(BufferingStrategy));
+};
+
+class StubFrameLoaderClient : public EmptyFrameLoaderClient {
+public:
+    static PassOwnPtrWillBeRawPtr<StubFrameLoaderClient> create()
+    {
+        return adoptPtrWillBeNoop(new StubFrameLoaderClient);
+    }
+
+    PassOwnPtr<WebMediaPlayer> createWebMediaPlayer(HTMLMediaElement&, const WebURL&, WebMediaPlayerClient*) override
+    {
+        return adoptPtr(new MockWebMediaPlayer);
+    }
+};
+
+} // namespace
+
+class HTMLVideoElementTest : public ::testing::Test {

[sandersd (OOO until July 31), 2015/12/17 19:05:56]

The test cases here are better on HTMLMediaElement, but there is (identical)
logic in HTMLAudioElement::create and HTMLVideoElement::create that would need
to be copied again.

[philipj_slow, 2015/12/18 15:02:27]

Just HTMLVideoElementTest seems fine, if unit tests for HTMLAudioElement are
later also added I'm sure it can be refactored somehow.

+protected:
+    HTMLVideoElementTest()
+        : m_dummyPageHolder(DummyPageHolder::create(IntSize(640, 360), nullptr, StubFrameLoaderClient::create()))
+    {
+        // 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();
+    }
+
+    MockWebMediaPlayer* webMediaPlayer()
+    {
+        return static_cast<MockWebMediaPlayer*>(m_video->webMediaPlayer());
+    }
+
+    OwnPtr<DummyPageHolder> m_dummyPageHolder;
+    RefPtrWillBeMember<HTMLVideoElement> m_video;

[sof, 2016/01/05 18:51:48]

RefPtrWillBePersistent<>

[sandersd (OOO until July 31), 2016/01/08 00:02:11]

Done.

+};
+
+TEST_F(HTMLVideoElementTest, setBufferingStrategy_NonUserPause)
+{
+    setSrc("http://foo.bar/");
+    MockWebMediaPlayer* player = webMediaPlayer();
+    ASSERT_TRUE(player);
+
+    // On play, the strategy is set to normal.
+    EXPECT_CALL(*player, setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Normal));
+    m_video->play();
+    ::testing::Mock::VerifyAndClearExpectations(player);
+
+    // On a non-user pause, the strategy is not changed.
+    m_video->pause();
+    ::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, setBufferingStrategy_UserPause)
+{
+    setSrc("http://foo.bar/");
+    MockWebMediaPlayer* player = webMediaPlayer();
+    ASSERT_TRUE(player);
+
+    // On play, the strategy is set to normal.
+    EXPECT_CALL(*player, setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Normal));
+    video->play();
+    ::testing::Mock::VerifyAndClearExpectations(player);
+
+    // On a user pause, the strategy is set to aggressive.
+    EXPECT_CALL(*player, setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Aggressive));
+    {
+        UserGestureIndicator gesture(DefinitelyProcessingUserGesture);
+        video->pause();
+    }
+    ::testing::Mock::VerifyAndClearExpectations(player);
+
+    // On play, the strategy is set to normal.
+    EXPECT_CALL(*player, setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Normal));
+    video->play();
+    ::testing::Mock::VerifyAndClearExpectations(player);
+}
+
+} // namespace blink