| 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 ON_CALL(*this, DidReceiveAction(_)) | |
| 34 .WillByDefault(Invoke(session, &MediaSession::DidReceiveAction)); | |
| 35 } | |
| 36 ~MockMediaSession() {} | |
| 37 | |
| 38 MOCK_METHOD1(Resume, void(content::MediaSession::SuspendType)); | |
| 39 MOCK_METHOD1(Suspend, void(content::MediaSession::SuspendType)); | |
| 40 MOCK_METHOD1(Stop, void(content::MediaSession::SuspendType)); | |
| 41 MOCK_METHOD1(DidReceiveAction, void(blink::mojom::MediaSessionAction)); | |
| 42 | |
| 43 private: | |
| 44 DISALLOW_COPY_AND_ASSIGN(MockMediaSession); | |
| 45 }; | |
| 46 | |
| 47 class CastMediaBlockerTest : public content::RenderViewHostTestHarness { | |
| 48 public: | |
| 49 CastMediaBlockerTest() {} | |
| 50 ~CastMediaBlockerTest() override {} | |
| 51 | |
| 52 void SetUp() override { | |
| 53 initializer_ = base::MakeUnique<content::TestContentClientInitializer>(); | |
| 54 content::RenderViewHostTestHarness::SetUp(); | |
| 55 media_session_ = base::MakeUnique<MockMediaSession>( | |
| 56 content::MediaSession::Get(web_contents())); | |
| 57 media_blocker_ = base::MakeUnique<CastMediaBlocker>(media_session_.get(), | |
| 58 web_contents()); | |
| 59 | |
| 60 content::WebContentsTester::For(web_contents()) | |
| 61 ->NavigateAndCommit(GURL("https://www.youtube.com")); | |
| 62 } | |
| 63 | |
| 64 void TearDown() override { content::RenderViewHostTestHarness::TearDown(); } | |
| 65 | |
| 66 void MediaSessionChanged(bool controllable, bool suspended) { | |
| 67 media_blocker_->MediaSessionStateChanged(controllable, suspended); | |
| 68 } | |
| 69 | |
| 70 protected: | |
| 71 std::unique_ptr<content::TestContentClientInitializer> initializer_; | |
| 72 std::unique_ptr<MockMediaSession> media_session_; | |
| 73 std::unique_ptr<CastMediaBlocker> media_blocker_; | |
| 74 | |
| 75 private: | |
| 76 DISALLOW_COPY_AND_ASSIGN(CastMediaBlockerTest); | |
| 77 }; | |
| 78 | |
| 79 // TODO(derekjchow): Make the tests pass on cast testbots. | |
| 80 // crbug.com/665118 | |
| 81 | |
| 82 TEST_F(CastMediaBlockerTest, DISABLED_Block_Unblock_Suspended) { | |
| 83 // Testing block/unblock operations do nothing if media never plays. | |
| 84 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 85 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 86 media_blocker_->BlockMediaLoading(true); | |
| 87 media_blocker_->BlockMediaLoading(false); | |
| 88 | |
| 89 MediaSessionChanged(true, true); | |
| 90 media_blocker_->BlockMediaLoading(true); | |
| 91 media_blocker_->BlockMediaLoading(false); | |
| 92 | |
| 93 media_blocker_->BlockMediaLoading(true); | |
| 94 MediaSessionChanged(false, true); | |
| 95 media_blocker_->BlockMediaLoading(false); | |
| 96 } | |
| 97 | |
| 98 TEST_F(CastMediaBlockerTest, DISABLED_No_Block) { | |
| 99 // Tests CastMediaBlocker does nothing if block/unblock is not called. | |
| 100 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 101 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 102 | |
| 103 // Media becomes controllable/uncontrollable. | |
| 104 MediaSessionChanged(true, true); | |
| 105 MediaSessionChanged(false, true); | |
| 106 | |
| 107 // Media starts and stops. | |
| 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(false, false); | |
| 115 MediaSessionChanged(false, true); | |
| 116 | |
| 117 // Media starts, changes controllability and stops. | |
| 118 MediaSessionChanged(false, false); | |
| 119 MediaSessionChanged(true, false); | |
| 120 MediaSessionChanged(true, true); | |
| 121 } | |
| 122 | |
| 123 TEST_F(CastMediaBlockerTest, DISABLED_Block_Before_Controllable) { | |
| 124 // Tests CastMediaBlocker only suspends when controllable. | |
| 125 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 126 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 127 media_blocker_->BlockMediaLoading(true); | |
| 128 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 129 | |
| 130 // Session becomes controllable | |
| 131 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 132 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 133 MediaSessionChanged(true, false); | |
| 134 } | |
| 135 | |
| 136 TEST_F(CastMediaBlockerTest, DISABLED_Block_After_Controllable) { | |
| 137 // Tests CastMediaBlocker suspends immediately on block if controllable. | |
| 138 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 139 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 140 MediaSessionChanged(true, false); | |
| 141 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 142 | |
| 143 // Block when media is playing | |
| 144 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 145 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 146 media_blocker_->BlockMediaLoading(true); | |
| 147 MediaSessionChanged(true, true); | |
| 148 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 149 | |
| 150 // Unblock | |
| 151 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 152 EXPECT_CALL(*media_session_, Resume(_)).Times(1); | |
| 153 media_blocker_->BlockMediaLoading(false); | |
| 154 } | |
| 155 | |
| 156 TEST_F(CastMediaBlockerTest, DISABLED_Block_Multiple) { | |
| 157 // Tests CastMediaBlocker repeatively suspends when blocked. | |
| 158 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 159 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 160 media_blocker_->BlockMediaLoading(true); | |
| 161 MediaSessionChanged(false, false); | |
| 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 MediaSessionChanged(true, true); | |
| 168 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 169 | |
| 170 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 171 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 172 MediaSessionChanged(true, false); | |
| 173 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 174 MediaSessionChanged(true, true); | |
| 175 | |
| 176 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 177 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 178 MediaSessionChanged(false, true); | |
| 179 MediaSessionChanged(false, false); | |
| 180 MediaSessionChanged(false, true); | |
| 181 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 182 } | |
| 183 | |
| 184 TEST_F(CastMediaBlockerTest, DISABLED_Block_Unblock_Uncontrollable) { | |
| 185 // Tests CastMediaBlocker does not suspend or resume when uncontrollable. | |
| 186 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 187 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 188 media_blocker_->BlockMediaLoading(true); | |
| 189 MediaSessionChanged(false, false); | |
| 190 media_blocker_->BlockMediaLoading(false); | |
| 191 media_blocker_->BlockMediaLoading(true); | |
| 192 MediaSessionChanged(false, true); | |
| 193 media_blocker_->BlockMediaLoading(false); | |
| 194 media_blocker_->BlockMediaLoading(true); | |
| 195 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 196 } | |
| 197 | |
| 198 TEST_F(CastMediaBlockerTest, DISABLED_Block_Unblock_Uncontrollable2) { | |
| 199 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 200 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 201 MediaSessionChanged(true, true); | |
| 202 media_blocker_->BlockMediaLoading(true); | |
| 203 MediaSessionChanged(false, true); | |
| 204 MediaSessionChanged(true, true); | |
| 205 MediaSessionChanged(true, false); | |
| 206 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 207 | |
| 208 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 209 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 210 MediaSessionChanged(false, false); | |
| 211 MediaSessionChanged(false, true); | |
| 212 MediaSessionChanged(true, true); | |
| 213 MediaSessionChanged(true, false); | |
| 214 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 215 | |
| 216 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 217 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 218 media_blocker_->BlockMediaLoading(false); | |
| 219 } | |
| 220 | |
| 221 TEST_F(CastMediaBlockerTest, DISABLED_Resume_When_Controllable) { | |
| 222 // Tests CastMediaBlocker will only resume after unblock when controllable. | |
| 223 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 224 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 225 MediaSessionChanged(true, false); | |
| 226 media_blocker_->BlockMediaLoading(true); | |
| 227 MediaSessionChanged(true, true); | |
| 228 MediaSessionChanged(false, true); | |
| 229 media_blocker_->BlockMediaLoading(false); | |
| 230 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 231 | |
| 232 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 233 EXPECT_CALL(*media_session_, Resume(_)).Times(1); | |
| 234 MediaSessionChanged(true, true); | |
| 235 } | |
| 236 | |
| 237 TEST_F(CastMediaBlockerTest, DISABLED_No_Resume) { | |
| 238 // Tests CastMediaBlocker will not resume if media starts playing by itself | |
| 239 // after unblock. | |
| 240 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 241 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 242 MediaSessionChanged(true, false); | |
| 243 media_blocker_->BlockMediaLoading(true); | |
| 244 MediaSessionChanged(true, true); | |
| 245 MediaSessionChanged(false, true); | |
| 246 media_blocker_->BlockMediaLoading(false); | |
| 247 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 248 | |
| 249 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 250 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 251 MediaSessionChanged(false, false); | |
| 252 } | |
| 253 | |
| 254 TEST_F(CastMediaBlockerTest, DISABLED_Block_Before_Resume) { | |
| 255 // Tests CastMediaBlocker does not resume if blocked again after an unblock. | |
| 256 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 257 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 258 MediaSessionChanged(true, false); | |
| 259 media_blocker_->BlockMediaLoading(true); | |
| 260 MediaSessionChanged(true, true); | |
| 261 MediaSessionChanged(false, true); | |
| 262 media_blocker_->BlockMediaLoading(false); | |
| 263 testing::Mock::VerifyAndClearExpectations(media_session_.get()); | |
| 264 | |
| 265 EXPECT_CALL(*media_session_, Suspend(_)).Times(0); | |
| 266 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 267 media_blocker_->BlockMediaLoading(true); | |
| 268 MediaSessionChanged(true, true); | |
| 269 } | |
| 270 | |
| 271 TEST_F(CastMediaBlockerTest, DISABLED_Unblocked_Already_Playing) { | |
| 272 // Tests CastMediaBlocker does not resume if unblocked and media is playing. | |
| 273 EXPECT_CALL(*media_session_, Suspend(_)).Times(1); | |
| 274 EXPECT_CALL(*media_session_, Resume(_)).Times(0); | |
| 275 MediaSessionChanged(true, false); | |
| 276 media_blocker_->BlockMediaLoading(true); | |
| 277 media_blocker_->BlockMediaLoading(false); | |
| 278 } | |
| 279 | |
| 280 } // namespace shell | |
| 281 } // namespace chromecast | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2502143002:
Revert of [chromecast] Make testnames consistent. (Closed)
