| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chromecast/browser/cast_media_blocker.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 | |
| 9 #include "base/memory/ptr_util.h" | |
| 10 #include "content/public/browser/media_session.h" | |
| 11 #include "content/public/browser/web_contents.h" | |
| 12 #include "content/public/test/test_content_client_initializer.h" | |
| 13 #include "content/public/test/test_renderer_host.h" | |
| 14 #include "content/public/test/web_contents_tester.h" | |
| 15 #include "testing/gmock/include/gmock/gmock.h" | |
| 16 #include "testing/gtest/include/gtest/gtest.h" | |
| 17 | |
| 18 namespace chromecast { | |
| 19 namespace shell { | |
| 20 | |
| 21 using ::testing::_; | |
| 22 using ::testing::Invoke; | |
| 23 | |
| 24 class MockMediaSession : public content::MediaSession { | |
| 25 public: | |
| 26 explicit MockMediaSession(content::MediaSession* session) { | |
| 27 // Delegate the calls to the real MediaSession. | |
| 28 ON_CALL(*this, Resume(_)) | |
| 29 .WillByDefault(Invoke(session, &MediaSession::Resume)); | |
| 30 ON_CALL(*this, Suspend(_)) | |
| 31 .WillByDefault(Invoke(session, &MediaSession::Suspend)); | |
| 32 ON_CALL(*this, Stop(_)).WillByDefault(Invoke(session, &MediaSession::Stop)); | |
| 33 } | |
| 34 ~MockMediaSession() {} | |
| 35 | |
| 36 MOCK_METHOD1(Resume, void(content::MediaSession::SuspendType)); | |
| 37 MOCK_METHOD1(Suspend, void(content::MediaSession::SuspendType)); | |
| 38 MOCK_METHOD1(Stop, void(content::MediaSession::SuspendType)); | |
| 39 | |
| 40 private: | |
| 41 DISALLOW_COPY_AND_ASSIGN(MockMediaSession); | |
| 42 }; | |
| 43 | |
| 44 class CastMediaBlockerTest : public content::RenderViewHostTestHarness { | |
| 45 public: | |
| 46 CastMediaBlockerTest() {} | |
| 47 ~CastMediaBlockerTest() override {} | |
| 48 | |
| 49 void SetUp() override { | |
| 50 initializer_ = base::MakeUnique<content::TestContentClientInitializer>(); | |
| 51 content::RenderViewHostTestHarness::SetUp(); | |
| 52 media_session_ = base::MakeUnique<MockMediaSession>( | |
| 53 content::MediaSession::Get(web_contents())); | |
| 54 media_blocker_ = base::MakeUnique<CastMediaBlocker>(media_session_.get(), | |
| 55 web_contents()); | |
| 56 | |
| 57 content::WebContentsTester::For(web_contents()) | |
| 58 ->NavigateAndCommit(GURL("https://www.youtube.com")); | |
| 59 } | |
| 60 | |
| 61 void TearDown() override { content::RenderViewHostTestHarness::TearDown(); } | |
| 62 | |
| 63 void MediaSessionChanged(bool controllable, bool suspended) { | |
| 64 media_blocker_->MediaSessionStateChanged(controllable, suspended); | |
| 65 } | |
| 66 | |
| 67 protected: | |
| 68 std::unique_ptr<content::TestContentClientInitializer> initializer_; | |
| 69 std::unique_ptr<MockMediaSession> media_session_; | |
| 70 std::unique_ptr<CastMediaBlocker> media_blocker_; | |
| 71 | |
| 72 private: | |
| 73 DISALLOW_COPY_AND_ASSIGN(CastMediaBlockerTest); | |
| 74 }; | |
| 75 | |
| 76 TEST_F(CastMediaBlockerTest, Block_Unblock_Suspended) { | |
| 77 // Testing block/unblock operations do nothing if media never plays. | |
| 78 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 79 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 80 media_blocker_->BlockMediaLoading(true); | |
| 81 media_blocker_->BlockMediaLoading(false); | |
| 82 | |
| 83 MediaSessionChanged(true, true); | |
| 84 media_blocker_->BlockMediaLoading(true); | |
| 85 media_blocker_->BlockMediaLoading(false); | |
| 86 | |
| 87 media_blocker_->BlockMediaLoading(true); | |
| 88 MediaSessionChanged(false, true); | |
| 89 media_blocker_->BlockMediaLoading(false); | |
| 90 } | |
| 91 | |
| 92 TEST_F(CastMediaBlockerTest, No_Block) { | |
| 93 // Tests CastMediaBlocker does nothing if block/unblock is not called. | |
| 94 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 95 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 96 | |
| 97 // Media becomes controllable/uncontrollable. | |
| 98 MediaSessionChanged(true, true); | |
| 99 MediaSessionChanged(false, true); | |
| 100 | |
| 101 // Media starts and stops. | |
| 102 MediaSessionChanged(false, false); | |
| 103 MediaSessionChanged(false, true); | |
| 104 | |
| 105 // Media starts, changes controllability and stops. | |
| 106 MediaSessionChanged(false, false); | |
| 107 MediaSessionChanged(true, false); | |
| 108 MediaSessionChanged(false, false); | |
| 109 MediaSessionChanged(false, true); | |
| 110 | |
| 111 // Media starts, changes controllability and stops. | |
| 112 MediaSessionChanged(false, false); | |
| 113 MediaSessionChanged(true, false); | |
| 114 MediaSessionChanged(true, true); | |
| 115 } | |
| 116 | |
| 117 TEST_F(CastMediaBlockerTest, Block_Before_Controllable) { | |
| 118 // Tests CastMediaBlocker only suspends when controllable. | |
| 119 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 120 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 121 media_blocker_->BlockMediaLoading(true); | |
| 122 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 123 | |
| 124 // Session becomes controllable | |
| 125 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 126 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 127 MediaSessionChanged(true, false); | |
| 128 } | |
| 129 | |
| 130 TEST_F(CastMediaBlockerTest, Block_After_Controllable) { | |
| 131 // Tests CastMediaBlocker suspends immediately on block if controllable. | |
| 132 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 133 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 134 MediaSessionChanged(true, false); | |
| 135 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 136 | |
| 137 // Block when media is playing | |
| 138 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 139 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 140 media_blocker_->BlockMediaLoading(true); | |
| 141 MediaSessionChanged(true, true); | |
| 142 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 143 | |
| 144 // Unblock | |
| 145 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 146 EXPECT_CALL(*media_session_, Resume(_)).Times(1); | |
| 147 media_blocker_->BlockMediaLoading(false); | |
| 148 } | |
| 149 | |
| 150 TEST_F(CastMediaBlockerTest, Block_Multiple) { | |
| 151 // Tests CastMediaBlocker repeatively suspends when blocked. | |
| 152 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 153 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 154 media_blocker_->BlockMediaLoading(true); | |
| 155 MediaSessionChanged(false, false); | |
| 156 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 157 | |
| 158 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 159 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 160 MediaSessionChanged(true, false); | |
| 161 MediaSessionChanged(true, true); | |
| 162 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 163 | |
| 164 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 165 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 166 MediaSessionChanged(true, false); | |
| 167 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 168 MediaSessionChanged(true, true); | |
| 169 | |
| 170 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 171 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 172 MediaSessionChanged(false, true); | |
| 173 MediaSessionChanged(false, false); | |
| 174 MediaSessionChanged(false, true); | |
| 175 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 176 } | |
| 177 | |
| 178 TEST_F(CastMediaBlockerTest, Block_Unblock_Uncontrollable) { | |
| 179 // Tests CastMediaBlocker does not suspend or resume when uncontrollable. | |
| 180 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 181 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 182 media_blocker_->BlockMediaLoading(true); | |
| 183 MediaSessionChanged(false, false); | |
| 184 media_blocker_->BlockMediaLoading(false); | |
| 185 media_blocker_->BlockMediaLoading(true); | |
| 186 MediaSessionChanged(false, true); | |
| 187 media_blocker_->BlockMediaLoading(false); | |
| 188 media_blocker_->BlockMediaLoading(true); | |
| 189 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 190 } | |
| 191 | |
| 192 TEST_F(CastMediaBlockerTest, Block_Unblock_Uncontrollable2) { | |
| 193 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 194 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 195 MediaSessionChanged(true, true); | |
| 196 media_blocker_->BlockMediaLoading(true); | |
| 197 MediaSessionChanged(false, true); | |
| 198 MediaSessionChanged(true, true); | |
| 199 MediaSessionChanged(true, false); | |
| 200 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 201 | |
| 202 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 203 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 204 MediaSessionChanged(false, false); | |
| 205 MediaSessionChanged(false, true); | |
| 206 MediaSessionChanged(true, true); | |
| 207 MediaSessionChanged(true, false); | |
| 208 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 209 | |
| 210 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 211 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 212 media_blocker_->BlockMediaLoading(false); | |
| 213 } | |
| 214 | |
| 215 TEST_F(CastMediaBlockerTest, Resume_When_Controllable) { | |
| 216 // Tests CastMediaBlocker will only resume after unblock when controllable. | |
| 217 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 218 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 219 MediaSessionChanged(true, false); | |
| 220 media_blocker_->BlockMediaLoading(true); | |
| 221 MediaSessionChanged(true, true); | |
| 222 MediaSessionChanged(false, true); | |
| 223 media_blocker_->BlockMediaLoading(false); | |
| 224 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 225 | |
| 226 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 227 EXPECT_CALL(*media_session_, Resume(_)).Times(1); | |
| 228 MediaSessionChanged(true, true); | |
| 229 } | |
| 230 | |
| 231 TEST_F(CastMediaBlockerTest, No_Resume) { | |
| 232 // Tests CastMediaBlocker will not resume if media starts playing by itself | |
| 233 // after unblock. | |
| 234 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 235 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 236 MediaSessionChanged(true, false); | |
| 237 media_blocker_->BlockMediaLoading(true); | |
| 238 MediaSessionChanged(true, true); | |
| 239 MediaSessionChanged(false, true); | |
| 240 media_blocker_->BlockMediaLoading(false); | |
| 241 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 242 | |
| 243 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 244 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 245 MediaSessionChanged(false, false); | |
| 246 } | |
| 247 | |
| 248 TEST_F(CastMediaBlockerTest, Block_Before_Resume) { | |
| 249 // Tests CastMediaBlocker does not resume if blocked again after an unblock. | |
| 250 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 251 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 252 MediaSessionChanged(true, false); | |
| 253 media_blocker_->BlockMediaLoading(true); | |
| 254 MediaSessionChanged(true, true); | |
| 255 MediaSessionChanged(false, true); | |
| 256 media_blocker_->BlockMediaLoading(false); | |
| 257 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 258 | |
| 259 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 260 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 261 media_blocker_->BlockMediaLoading(true); | |
| 262 MediaSessionChanged(true, true); | |
| 263 } | |
| 264 | |
| 265 TEST_F(CastMediaBlockerTest, Unblocked_Already_Playing) { | |
| 266 // Tests CastMediaBlocker does not resume if unblocked and media is playing. | |
| 267 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 268 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 269 MediaSessionChanged(true, false); | |
| 270 media_blocker_->BlockMediaLoading(true); | |
| 271 media_blocker_->BlockMediaLoading(false); | |
| 272 } | |
| 273 | |
| 274 } // namespace shell | |
| 275 } // namespace chromecast | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2510473002:
Reland: [chromecast] Make testnames consistent. (Closed)
