| // Copyright 2017 The Cobalt Authors. All Rights Reserved. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "cobalt/media_session/media_session.h" | |
| #include <limits> | |
| #include <memory> | |
| #include "base/message_loop/message_loop.h" | |
| #include "base/run_loop.h" | |
| #include "cobalt/bindings/testing/script_object_owner.h" | |
| #include "cobalt/media_session/media_session_client.h" | |
| #include "cobalt/script/callback_function.h" | |
| #include "cobalt/script/script_value.h" | |
| #include "cobalt/script/testing/fake_script_value.h" | |
| #include "cobalt/script/wrappable.h" | |
| #include "starboard/thread.h" | |
| #include "starboard/time.h" | |
| #include "testing/gmock/include/gmock/gmock.h" | |
| #include "testing/gtest/include/gtest/gtest.h" | |
| using ::cobalt::script::CallbackResult; | |
| using ::cobalt::script::ScriptValue; | |
| using ::cobalt::script::Wrappable; | |
| using ::cobalt::script::testing::FakeScriptValue; | |
| using ::testing::_; | |
| using ::testing::AnyNumber; | |
| using ::testing::AtLeast; | |
| using ::testing::InvokeWithoutArgs; | |
| using ::testing::Return; | |
| namespace cobalt { | |
| namespace media_session { | |
| namespace { | |
| class MockCallbackFunction : public MediaSession::MediaSessionActionHandler { | |
| public: | |
| MOCK_CONST_METHOD1( | |
| Run, ReturnValue(const MediaSessionActionDetails& action_details)); | |
| }; | |
| class MockMediaSession : public MediaSession { | |
| public: | |
| explicit MockMediaSession(MediaSessionClient* client) | |
| : MediaSession(client) {} | |
| MOCK_CONST_METHOD0(GetMonotonicNow, SbTimeMonotonic()); | |
| }; | |
| class MockMediaSessionClient : public MediaSessionClient { | |
| public: | |
| MockMediaSessionClient() : MediaSessionClient(new MockMediaSession(this)) {} | |
| MockMediaSession& mock_session() { | |
| return static_cast<MockMediaSession&>(*GetMediaSession().get()); | |
| } | |
| void OnMediaSessionStateChanged(const MediaSessionState& session_state) | |
| override { | |
| session_state_ = session_state; | |
| ++session_change_count_; | |
| } | |
| void WaitForSessionStateChange() { | |
| size_t current_change_count = session_change_count_; | |
| while (GetMediaSession()->IsChangeTaskQueuedForTesting()) { | |
| base::RunLoop().RunUntilIdle(); | |
| if (current_change_count != session_change_count_) { | |
| break; | |
| } | |
| SbThreadSleep(kSbTimeMillisecond); | |
| } | |
| } | |
| MediaSessionState GetMediaSessionState() const { return session_state_; } | |
| size_t GetMediaSessionChangeCount() const { return session_change_count_; } | |
| MediaSessionState session_state_; | |
| size_t session_change_count_ = 0; | |
| }; | |
| MATCHER_P(SeekTime, time, "") { | |
| return arg.action() == kMediaSessionActionSeekto && arg.seek_time() == time; | |
| } | |
| MATCHER_P2(SeekOffset, action, offset, "") { | |
| return arg.action() == action && arg.seek_offset() == offset; | |
| } | |
| MATCHER_P(SeekNoOffset, action, "") { | |
| return arg.action() == action && !arg.has_seek_offset(); | |
| } | |
| TEST(MediaSessionTest, MediaSessionTest) { | |
| base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT); | |
| MockMediaSessionClient client; | |
| scoped_refptr<MediaSession> session = client.GetMediaSession(); | |
| EXPECT_EQ(kMediaSessionPlaybackStateNone, session->playback_state()); | |
| session->set_playback_state(kMediaSessionPlaybackStatePlaying); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePlaying, | |
| client.GetMediaSessionState().actual_playback_state()); | |
| EXPECT_EQ(client.GetMediaSessionChangeCount(), 1); | |
| } | |
| TEST(MediaSessionTest, ActualPlaybackState) { | |
| base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT); | |
| MockMediaSessionClient client; | |
| scoped_refptr<MediaSession> session = client.GetMediaSession(); | |
| // Trigger a session state change without impacting playback state. | |
| session->set_metadata(new MediaMetadata); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(client.GetMediaSessionChangeCount(), 1); | |
| EXPECT_EQ(kMediaSessionPlaybackStateNone, | |
| client.GetMediaSessionState().actual_playback_state()); | |
| client.UpdatePlatformPlaybackState(kMediaSessionPlaybackStatePlaying); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePlaying, | |
| client.GetMediaSessionState().actual_playback_state()); | |
| session->set_playback_state(kMediaSessionPlaybackStatePlaying); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePlaying, | |
| client.GetMediaSessionState().actual_playback_state()); | |
| session->set_playback_state(kMediaSessionPlaybackStatePaused); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePlaying, | |
| client.GetMediaSessionState().actual_playback_state()); | |
| client.UpdatePlatformPlaybackState(kMediaSessionPlaybackStatePaused); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePaused, | |
| client.GetMediaSessionState().actual_playback_state()); | |
| session->set_playback_state(kMediaSessionPlaybackStateNone); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(kMediaSessionPlaybackStateNone, | |
| client.GetMediaSessionState().actual_playback_state()); | |
| client.UpdatePlatformPlaybackState(kMediaSessionPlaybackStateNone); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(kMediaSessionPlaybackStateNone, | |
| client.GetMediaSessionState().actual_playback_state()); | |
| EXPECT_GE(client.GetMediaSessionChangeCount(), 2); | |
| } | |
| TEST(MediaSessionTest, NullActionClears) { | |
| base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT); | |
| MockMediaSessionClient client; | |
| scoped_refptr<MediaSession> session = client.GetMediaSession(); | |
| // Trigger a session state change without impacting playback state. | |
| session->set_metadata(new MediaMetadata); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(client.GetMediaSessionChangeCount(), 1); | |
| MediaSessionState state = client.GetMediaSessionState(); | |
| EXPECT_EQ(kMediaSessionPlaybackStateNone, state.actual_playback_state()); | |
| EXPECT_EQ(0, state.available_actions().to_ulong()); | |
| MockCallbackFunction cf; | |
| EXPECT_CALL(cf, Run(_)) | |
| .Times(1) | |
| .WillRepeatedly(Return(CallbackResult<void>())); | |
| FakeScriptValue<MediaSession::MediaSessionActionHandler> holder(&cf); | |
| FakeScriptValue<MediaSession::MediaSessionActionHandler> null_holder(NULL); | |
| session->SetActionHandler(kMediaSessionActionPlay, holder); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(1, client.GetMediaSessionState().available_actions().to_ulong()); | |
| client.InvokeAction(kMediaSessionActionPlay); | |
| session->SetActionHandler(kMediaSessionActionPlay, null_holder); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(0, client.GetMediaSessionState().available_actions().to_ulong()); | |
| client.InvokeAction(kMediaSessionActionPlay); | |
| EXPECT_GE(client.GetMediaSessionChangeCount(), 3); | |
| } | |
| TEST(MediaSessionTest, AvailableActions) { | |
| base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT); | |
| MockMediaSessionClient client; | |
| MediaSessionState state; | |
| scoped_refptr<MediaSession> session = client.GetMediaSession(); | |
| // Trigger a session state change without impacting playback state. | |
| session->set_metadata(new MediaMetadata); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(client.GetMediaSessionChangeCount(), 1); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(kMediaSessionPlaybackStateNone, state.actual_playback_state()); | |
| EXPECT_EQ(0, state.available_actions().to_ulong()); | |
| MockCallbackFunction cf; | |
| EXPECT_CALL(cf, Run(_)).Times(0); | |
| FakeScriptValue<MediaSession::MediaSessionActionHandler> holder(&cf); | |
| session->SetActionHandler(kMediaSessionActionPlay, holder); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(1 << kMediaSessionActionPlay, | |
| state.available_actions().to_ulong()); | |
| session->SetActionHandler(kMediaSessionActionPause, holder); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(1 << kMediaSessionActionPlay, | |
| state.available_actions().to_ulong()); | |
| session->SetActionHandler(kMediaSessionActionSeekto, holder); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(1 << kMediaSessionActionPlay, state.available_actions().to_ulong()); | |
| client.UpdatePlatformPlaybackState(kMediaSessionPlaybackStatePlaying); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePlaying, state.actual_playback_state()); | |
| EXPECT_EQ(1 << kMediaSessionActionPause | 1 << kMediaSessionActionSeekto, | |
| state.available_actions().to_ulong()); | |
| session->set_playback_state(kMediaSessionPlaybackStatePlaying); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePlaying, state.actual_playback_state()); | |
| EXPECT_EQ(1 << kMediaSessionActionPause | 1 << kMediaSessionActionSeekto, | |
| state.available_actions().to_ulong()); | |
| session->set_playback_state(kMediaSessionPlaybackStatePaused); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePlaying, state.actual_playback_state()); | |
| EXPECT_EQ(1 << kMediaSessionActionPause | 1 << kMediaSessionActionSeekto, | |
| state.available_actions().to_ulong()); | |
| session->set_playback_state(kMediaSessionPlaybackStatePlaying); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePlaying, state.actual_playback_state()); | |
| EXPECT_EQ(1 << kMediaSessionActionPause | 1 << kMediaSessionActionSeekto, | |
| state.available_actions().to_ulong()); | |
| client.UpdatePlatformPlaybackState(kMediaSessionPlaybackStatePaused); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePlaying, state.actual_playback_state()); | |
| EXPECT_EQ(1 << kMediaSessionActionPause | 1 << kMediaSessionActionSeekto, | |
| state.available_actions().to_ulong()); | |
| session->set_playback_state(kMediaSessionPlaybackStateNone); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(kMediaSessionPlaybackStateNone, state.actual_playback_state()); | |
| EXPECT_EQ(1 << kMediaSessionActionPlay, state.available_actions().to_ulong()); | |
| session->set_playback_state(kMediaSessionPlaybackStatePaused); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePaused, state.actual_playback_state()); | |
| EXPECT_EQ(1 << kMediaSessionActionPlay | 1 << kMediaSessionActionSeekto, | |
| state.available_actions().to_ulong()); | |
| client.UpdatePlatformPlaybackState(kMediaSessionPlaybackStateNone); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(kMediaSessionPlaybackStatePaused, state.actual_playback_state()); | |
| EXPECT_EQ(1 << kMediaSessionActionPlay | 1 << kMediaSessionActionSeekto, | |
| state.available_actions().to_ulong()); | |
| } | |
| TEST(MediaSessionTest, SeekDetails) { | |
| base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT); | |
| MockMediaSessionClient client; | |
| scoped_refptr<MediaSession> session = client.GetMediaSession(); | |
| MockCallbackFunction cf; | |
| FakeScriptValue<MediaSession::MediaSessionActionHandler> holder(&cf); | |
| std::unique_ptr<MediaSessionActionDetails> details; | |
| session->SetActionHandler(kMediaSessionActionSeekto, holder); | |
| session->SetActionHandler(kMediaSessionActionSeekforward, holder); | |
| session->SetActionHandler(kMediaSessionActionSeekbackward, holder); | |
| EXPECT_CALL(cf, Run(SeekNoOffset(kMediaSessionActionSeekforward))) | |
| .WillOnce(Return(CallbackResult<void>())); | |
| client.InvokeAction(kMediaSessionActionSeekforward); | |
| EXPECT_CALL(cf, Run(SeekNoOffset(kMediaSessionActionSeekbackward))) | |
| .WillOnce(Return(CallbackResult<void>())); | |
| client.InvokeAction(kMediaSessionActionSeekbackward); | |
| EXPECT_CALL(cf, Run(SeekTime(1.2))).WillOnce(Return(CallbackResult<void>())); | |
| details.reset(new MediaSessionActionDetails()); | |
| details->set_action(kMediaSessionActionSeekto); | |
| details->set_seek_time(1.2); | |
| client.InvokeAction(std::move(details)); | |
| EXPECT_CALL(cf, Run(SeekOffset(kMediaSessionActionSeekforward, 3.4))) | |
| .WillOnce(Return(CallbackResult<void>())); | |
| details.reset(new MediaSessionActionDetails()); | |
| details->set_action(kMediaSessionActionSeekforward); | |
| details->set_seek_offset(3.4); | |
| client.InvokeAction(std::move(details)); | |
| EXPECT_CALL(cf, Run(SeekOffset(kMediaSessionActionSeekbackward, 5.6))) | |
| .WillOnce(Return(CallbackResult<void>())); | |
| details.reset(new MediaSessionActionDetails()); | |
| details->set_action(kMediaSessionActionSeekbackward); | |
| details->set_seek_offset(5.6); | |
| client.InvokeAction(std::move(details)); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_GE(client.GetMediaSessionChangeCount(), 0); | |
| } | |
| TEST(MediaSessionTest, PositionState) { | |
| base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT); | |
| MockMediaSessionClient client; | |
| MockMediaSession& session = client.mock_session(); | |
| MediaSessionState state; | |
| SbTimeMonotonic start_time = 1111111111; | |
| base::Optional<MediaPositionState> position_state; | |
| position_state.emplace(); | |
| position_state->set_duration(100.0); | |
| position_state->set_position(10.0); | |
| // Trigger a session state change without impacting playback state. | |
| session.set_metadata(new MediaMetadata); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(client.GetMediaSessionChangeCount(), 1); | |
| // Position state not yet reported | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(0, | |
| state.GetCurrentPlaybackPosition(start_time + 999 * kSbTimeSecond)); | |
| EXPECT_EQ(0, state.duration()); | |
| EXPECT_EQ(0.0, state.actual_playback_rate()); | |
| // Forward playback | |
| EXPECT_CALL(session, GetMonotonicNow()).WillOnce(Return(start_time)); | |
| position_state->set_playback_rate(1.0); | |
| session.SetPositionState(position_state); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ((10 + 50) * kSbTimeSecond, | |
| state.GetCurrentPlaybackPosition(start_time + 50 * kSbTimeSecond)); | |
| EXPECT_EQ(100 * kSbTimeSecond, | |
| state.GetCurrentPlaybackPosition(start_time + 150 * kSbTimeSecond)); | |
| EXPECT_EQ(100 * kSbTimeSecond, state.duration()); | |
| EXPECT_EQ(1.0, state.actual_playback_rate()); | |
| // Fast playback | |
| EXPECT_CALL(session, GetMonotonicNow()).WillOnce(Return(start_time)); | |
| position_state->set_playback_rate(2.0); | |
| session.SetPositionState(position_state); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ((10 + 2 * 20) * kSbTimeSecond, | |
| state.GetCurrentPlaybackPosition(start_time + 20 * kSbTimeSecond)); | |
| EXPECT_EQ(100 * kSbTimeSecond, | |
| state.GetCurrentPlaybackPosition(start_time + 50 * kSbTimeSecond)); | |
| EXPECT_EQ(100 * kSbTimeSecond, state.duration()); | |
| EXPECT_EQ(2.0, state.actual_playback_rate()); | |
| // Reverse playback | |
| EXPECT_CALL(session, GetMonotonicNow()).WillOnce(Return(start_time)); | |
| position_state->set_playback_rate(-1.0); | |
| session.SetPositionState(position_state); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(0 * kSbTimeSecond, | |
| state.GetCurrentPlaybackPosition(start_time + 20 * kSbTimeSecond)); | |
| EXPECT_EQ((10 - 3) * kSbTimeSecond, | |
| state.GetCurrentPlaybackPosition(start_time + 3 * kSbTimeSecond)); | |
| EXPECT_EQ(100 * kSbTimeSecond, state.duration()); | |
| EXPECT_EQ(-1.0, state.actual_playback_rate()); | |
| // Indefinite duration (live) playback | |
| EXPECT_CALL(session, GetMonotonicNow()).WillOnce(Return(start_time)); | |
| position_state->set_duration(std::numeric_limits<double>::infinity()); | |
| position_state->set_playback_rate(1.0); | |
| session.SetPositionState(position_state); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(10 * kSbTimeSecond + 1 * kSbTimeDay, | |
| state.GetCurrentPlaybackPosition(start_time + 1 * kSbTimeDay)); | |
| EXPECT_EQ(kSbTimeMax, state.duration()); | |
| EXPECT_EQ(1.0, state.actual_playback_rate()); | |
| // Paused playback | |
| // (Actual playback rate is 0.0, so position is the last reported position. | |
| // The web app should update position and playback states together.) | |
| session.set_playback_state(kMediaSessionPlaybackStatePaused); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(10 * kSbTimeSecond, | |
| state.GetCurrentPlaybackPosition(start_time + 999 * kSbTimeSecond)); | |
| EXPECT_EQ(kSbTimeMax, state.duration()); | |
| EXPECT_EQ(0.0, state.actual_playback_rate()); | |
| session.set_playback_state(kMediaSessionPlaybackStatePlaying); | |
| // Position state cleared | |
| EXPECT_CALL(session, GetMonotonicNow()).WillOnce(Return(start_time)); | |
| session.SetPositionState(base::nullopt); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| EXPECT_EQ(0, | |
| state.GetCurrentPlaybackPosition(start_time + 999 * kSbTimeSecond)); | |
| EXPECT_EQ(0, state.duration()); | |
| EXPECT_EQ(0.0, state.actual_playback_rate()); | |
| EXPECT_GE(client.GetMediaSessionChangeCount(), 3); | |
| } | |
| TEST(MediaSessionTest, Metadata) { | |
| base::MessageLoop message_loop(base::MessageLoop::TYPE_DEFAULT); | |
| MockMediaSessionClient client; | |
| MockMediaSession& session = client.mock_session(); | |
| MediaSessionState state; | |
| MediaMetadataInit init_metadata; | |
| base::Optional<MediaMetadataInit> state_metadata; | |
| // Trigger a session state change without impacting metadata. | |
| session.set_playback_state(kMediaSessionPlaybackStateNone); | |
| client.WaitForSessionStateChange(); | |
| EXPECT_EQ(client.GetMediaSessionChangeCount(), 1); | |
| // Metadata not yet set | |
| state = client.GetMediaSessionState(); | |
| state_metadata = state.metadata(); | |
| EXPECT_FALSE(state.has_metadata()); | |
| EXPECT_FALSE(state_metadata.has_value()); | |
| // Set metadata and make sure it gets into the MediaSessionState | |
| init_metadata = MediaMetadataInit(); | |
| init_metadata.set_title("title"); | |
| init_metadata.set_artist("artist"); | |
| init_metadata.set_album("album"); | |
| MediaImage art_image; | |
| art_image.set_src("http://art.image"); | |
| script::Sequence<MediaImage> artwork; | |
| artwork.push_back(art_image); | |
| init_metadata.set_artwork(artwork); | |
| session.set_metadata( | |
| scoped_refptr<MediaMetadata>(new MediaMetadata(init_metadata))); | |
| client.WaitForSessionStateChange(); | |
| state = client.GetMediaSessionState(); | |
| state_metadata = state.metadata(); | |
| EXPECT_TRUE(state.has_metadata()); | |
| EXPECT_TRUE(state_metadata.has_value()); | |
| EXPECT_EQ("title", state_metadata->title()); | |
| EXPECT_EQ("artist", state_metadata->artist()); | |
| EXPECT_EQ("album", state_metadata->album()); | |
| EXPECT_EQ(1, state_metadata->artwork().size()); | |
| EXPECT_EQ("http://art.image", state_metadata->artwork().at(0).src()); | |
| EXPECT_GE(client.GetMediaSessionChangeCount(), 2); | |
| } | |
| } // namespace | |
| } // namespace media_session | |
| } // namespace cobalt |