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 "base/bind.h" | |
6 #include "base/bind_helpers.h" | |
7 #include "base/run_loop.h" | |
8 #include "base/test/simple_test_tick_clock.h" | |
9 #include "base/tuple.h" | |
10 #include "content/common/media/media_player_delegate_messages.h" | |
11 #include "content/public/renderer/render_view.h" | |
12 #include "content/public/test/render_view_test.h" | |
13 #include "content/renderer/media/renderer_webmediaplayer_delegate.h" | |
14 #include "content/renderer/render_process.h" | |
15 #include "testing/gmock/include/gmock/gmock.h" | |
16 #include "testing/gtest/include/gtest/gtest.h" | |
17 | |
18 namespace media { | |
19 | |
20 ACTION_P(RunClosure, closure) { | |
21 closure.Run(); | |
22 } | |
23 | |
24 class MockWebMediaPlayerDelegateObserver | |
25 : public WebMediaPlayerDelegate::Observer { | |
26 public: | |
27 MockWebMediaPlayerDelegateObserver() {} | |
28 ~MockWebMediaPlayerDelegateObserver() {} | |
29 | |
30 // WebMediaPlayerDelegate::Observer implementation. | |
31 MOCK_METHOD1(OnHidden, void(bool)); | |
32 MOCK_METHOD0(OnShown, void()); | |
33 MOCK_METHOD0(OnPlay, void()); | |
34 MOCK_METHOD0(OnPause, void()); | |
35 MOCK_METHOD1(OnVolumeMultiplierUpdate, void(double)); | |
36 }; | |
37 | |
38 class RendererWebMediaPlayerDelegateTest : public content::RenderViewTest { | |
39 public: | |
40 RendererWebMediaPlayerDelegateTest() {} | |
41 ~RendererWebMediaPlayerDelegateTest() override {} | |
42 | |
43 void SetUp() override { | |
44 RenderViewTest::SetUp(); | |
45 delegate_manager_.reset( | |
46 new RendererWebMediaPlayerDelegate(view_->GetMainRenderFrame())); | |
47 } | |
48 | |
49 void TearDown() override { | |
50 // Destruct the controller prior to any other tear down to avoid out of | |
51 // order destruction relative to the test render frame. | |
52 delegate_manager_.reset(); | |
53 RenderViewTest::TearDown(); | |
54 } | |
55 | |
56 protected: | |
57 IPC::TestSink& test_sink() { return render_thread_->sink(); } | |
58 | |
59 scoped_ptr<RendererWebMediaPlayerDelegate> delegate_manager_; | |
60 | |
61 private: | |
62 DISALLOW_COPY_AND_ASSIGN(RendererWebMediaPlayerDelegateTest); | |
63 }; | |
64 | |
65 TEST_F(RendererWebMediaPlayerDelegateTest, SendsMessagesCorrectly) { | |
66 testing::StrictMock<MockWebMediaPlayerDelegateObserver> observer; | |
67 const int delegate_id = delegate_manager_->AddObserver(&observer); | |
68 | |
69 // Verify the playing message. | |
70 { | |
71 const bool kHasVideo = true, kHasAudio = false, kIsRemote = false; | |
72 const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(5); | |
73 delegate_manager_->DidPlay(delegate_id, kHasVideo, kHasAudio, kIsRemote, | |
74 kDuration); | |
75 | |
76 const IPC::Message* msg = test_sink().GetUniqueMessageMatching( | |
77 MediaPlayerDelegateHostMsg_OnMediaPlaying::ID); | |
78 ASSERT_TRUE(msg); | |
79 | |
80 base::Tuple<int, bool, bool, bool, base::TimeDelta> result; | |
81 ASSERT_TRUE(MediaPlayerDelegateHostMsg_OnMediaPlaying::Read(msg, &result)); | |
82 EXPECT_EQ(delegate_id, base::get<0>(result)); | |
83 EXPECT_EQ(kHasVideo, base::get<1>(result)); | |
84 EXPECT_EQ(kHasAudio, base::get<2>(result)); | |
85 EXPECT_EQ(kIsRemote, base::get<3>(result)); | |
86 EXPECT_EQ(kDuration, base::get<4>(result)); | |
87 } | |
88 | |
89 // Verify the paused message. | |
90 { | |
91 test_sink().ClearMessages(); | |
92 const bool kReachedEndOfStream = true; | |
93 delegate_manager_->DidPause(delegate_id, kReachedEndOfStream); | |
94 | |
95 const IPC::Message* msg = test_sink().GetUniqueMessageMatching( | |
96 MediaPlayerDelegateHostMsg_OnMediaPaused::ID); | |
97 ASSERT_TRUE(msg); | |
98 | |
99 base::Tuple<int, bool> result; | |
100 ASSERT_TRUE(MediaPlayerDelegateHostMsg_OnMediaPaused::Read(msg, &result)); | |
101 EXPECT_EQ(delegate_id, base::get<0>(result)); | |
102 EXPECT_EQ(kReachedEndOfStream, base::get<1>(result)); | |
103 } | |
104 | |
105 // Verify the destruction message. | |
106 { | |
107 test_sink().ClearMessages(); | |
108 delegate_manager_->PlayerGone(delegate_id); | |
109 const IPC::Message* msg = test_sink().GetUniqueMessageMatching( | |
110 MediaPlayerDelegateHostMsg_OnMediaDestroyed::ID); | |
111 ASSERT_TRUE(msg); | |
112 | |
113 base::Tuple<int> result; | |
114 ASSERT_TRUE( | |
115 MediaPlayerDelegateHostMsg_OnMediaDestroyed::Read(msg, &result)); | |
116 EXPECT_EQ(delegate_id, base::get<0>(result)); | |
117 } | |
118 | |
119 delegate_manager_->RemoveObserver(delegate_id); | |
120 } | |
121 | |
122 TEST_F(RendererWebMediaPlayerDelegateTest, DeliversObserverNotifications) { | |
123 testing::StrictMock<MockWebMediaPlayerDelegateObserver> observer; | |
124 const int delegate_id = delegate_manager_->AddObserver(&observer); | |
125 | |
126 EXPECT_CALL(observer, OnHidden(false)); | |
127 delegate_manager_->WasHidden(); | |
128 | |
129 EXPECT_CALL(observer, OnShown()); | |
130 delegate_manager_->WasShown(); | |
131 | |
132 EXPECT_CALL(observer, OnPause()); | |
133 MediaPlayerDelegateMsg_Pause pause_msg(0, delegate_id); | |
134 delegate_manager_->OnMessageReceived(pause_msg); | |
135 | |
136 EXPECT_CALL(observer, OnPlay()); | |
137 MediaPlayerDelegateMsg_Play play_msg(0, delegate_id); | |
138 delegate_manager_->OnMessageReceived(play_msg); | |
139 | |
140 const double kTestMultiplier = 0.5; | |
141 EXPECT_CALL(observer, OnVolumeMultiplierUpdate(kTestMultiplier)); | |
142 MediaPlayerDelegateMsg_UpdateVolumeMultiplier volume_msg(0, delegate_id, | |
143 kTestMultiplier); | |
144 delegate_manager_->OnMessageReceived(volume_msg); | |
145 | |
146 EXPECT_CALL(observer, OnHidden(true)); | |
147 MediaPlayerDelegateMsg_SuspendAllMediaPlayers suspend_msg(0); | |
148 delegate_manager_->OnMessageReceived(suspend_msg); | |
149 | |
150 delegate_manager_->RemoveObserver(delegate_id); | |
151 } | |
152 | |
153 TEST_F(RendererWebMediaPlayerDelegateTest, IdleDelegatesAreSuspended) { | |
154 // Start the tick clock off at a non-null value. | |
155 base::SimpleTestTickClock tick_clock; | |
156 tick_clock.Advance(base::TimeDelta::FromSeconds(1234)); | |
157 | |
158 const base::TimeDelta kIdleTimeout = base::TimeDelta::FromSeconds(2); | |
159 delegate_manager_->EnableInstantIdleCleanupForTesting(kIdleTimeout, | |
160 &tick_clock); | |
161 | |
162 testing::StrictMock<MockWebMediaPlayerDelegateObserver> observer_1; | |
163 const int delegate_id_1 = delegate_manager_->AddObserver(&observer_1); | |
164 delegate_manager_->DidPlay(delegate_id_1, true, true, false, | |
165 base::TimeDelta()); | |
166 | |
167 // Never playing should count as idle. | |
168 testing::StrictMock<MockWebMediaPlayerDelegateObserver> observer_2; | |
169 const int delegate_id_2 = delegate_manager_->AddObserver(&observer_2); | |
170 | |
171 // Adding the observer should instantly queue the timeout task, once run the | |
172 // second delegate should be expired while the first is kept alive. | |
173 { | |
174 EXPECT_CALL(observer_2, OnHidden(true)) | |
175 .WillOnce(RunClosure(base::Bind( | |
176 &RendererWebMediaPlayerDelegate::PlayerGone, | |
177 base::Unretained(delegate_manager_.get()), delegate_id_2))); | |
178 base::RunLoop run_loop; | |
179 base::MessageLoop::current()->PostTask(FROM_HERE, run_loop.QuitClosure()); | |
180 tick_clock.Advance(kIdleTimeout + base::TimeDelta::FromMicroseconds(1)); | |
181 run_loop.Run(); | |
182 } | |
183 | |
184 // Pausing should also count as idle. | |
185 delegate_manager_->DidPause(delegate_id_1, false); | |
186 testing::StrictMock<MockWebMediaPlayerDelegateObserver> observer_3; | |
187 const int delegate_id_3 = delegate_manager_->AddObserver(&observer_3); | |
188 delegate_manager_->DidPlay(delegate_id_3, true, true, false, | |
189 base::TimeDelta()); | |
sandersd (OOO until July 31)
2016/02/27 00:26:23
What is the purpose of the third delegate? It seem
DaleCurtis
2016/02/27 00:55:23
The purpose of the third delegate is just to have
| |
190 | |
191 // Adding the observer should instantly queue the timeout task, once run the | |
192 // first delegate should be expired while the third is kept alive. | |
193 { | |
194 EXPECT_CALL(observer_1, OnHidden(true)) | |
195 .WillOnce(RunClosure(base::Bind( | |
196 &RendererWebMediaPlayerDelegate::PlayerGone, | |
197 base::Unretained(delegate_manager_.get()), delegate_id_1))); | |
198 base::RunLoop run_loop; | |
199 base::MessageLoop::current()->PostTask(FROM_HERE, run_loop.QuitClosure()); | |
200 tick_clock.Advance(kIdleTimeout + base::TimeDelta::FromMicroseconds(1)); | |
201 run_loop.Run(); | |
202 } | |
203 | |
204 delegate_manager_->RemoveObserver(delegate_id_1); | |
205 delegate_manager_->RemoveObserver(delegate_id_2); | |
206 delegate_manager_->RemoveObserver(delegate_id_3); | |
207 } | |
208 | |
209 } // namespace media | |
OLD | NEW |