OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/basictypes.h" | 5 #include "base/basictypes.h" |
6 #include "base/bind.h" | 6 #include "base/bind.h" |
7 #include "base/memory/scoped_ptr.h" | 7 #include "base/memory/scoped_ptr.h" |
8 #include "base/message_loop.h" | 8 #include "base/message_loop.h" |
9 #include "media/base/decoder_buffer.h" | 9 #include "media/base/decoder_buffer.h" |
10 #include "media/base/demuxer_stream.h" | 10 #include "media/base/demuxer_stream.h" |
11 #include "media/filters/fake_demuxer_stream.h" | 11 #include "media/filters/fake_demuxer_stream.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 12 #include "testing/gtest/include/gtest/gtest.h" |
13 | 13 |
14 namespace media { | 14 namespace media { |
15 | 15 |
16 static const int kNumFramesInOneConfig = 9; | 16 static const int kNumBuffersInOneConfig = 9; |
17 static const int kNumFramesToReadFirst = 5; | 17 static const int kNumBuffersToReadFirst = 5; |
18 static const int kNumConfigs = 3; | 18 static const int kNumConfigs = 3; |
19 COMPILE_ASSERT(kNumFramesToReadFirst < kNumFramesInOneConfig, | 19 COMPILE_ASSERT(kNumBuffersToReadFirst < kNumBuffersInOneConfig, |
20 do_not_read_too_many_buffers); | 20 do_not_read_too_many_buffers); |
21 COMPILE_ASSERT(kNumConfigs > 0, need_multiple_configs_to_trigger_config_change); | 21 COMPILE_ASSERT(kNumConfigs > 0, need_multiple_configs_to_trigger_config_change); |
22 | 22 |
23 class FakeDemuxerStreamTest : public testing::Test { | 23 class FakeDemuxerStreamTest : public testing::Test { |
24 public: | 24 public: |
25 FakeDemuxerStreamTest() | 25 FakeDemuxerStreamTest() |
26 : status_(DemuxerStream::kAborted), | 26 : status_(DemuxerStream::kAborted), |
27 read_pending_(false) {} | 27 read_pending_(false) {} |
28 virtual ~FakeDemuxerStreamTest() {} | 28 virtual ~FakeDemuxerStreamTest() {} |
29 | 29 |
30 void BufferReady(DemuxerStream::Status status, | 30 void BufferReady(DemuxerStream::Status status, |
31 const scoped_refptr<DecoderBuffer>& buffer) { | 31 const scoped_refptr<DecoderBuffer>& buffer) { |
32 DCHECK(read_pending_); | 32 DCHECK(read_pending_); |
33 read_pending_ = false; | 33 read_pending_ = false; |
34 status_ = status; | 34 status_ = status; |
35 buffer_ = buffer; | 35 buffer_ = buffer; |
36 } | 36 } |
37 | 37 |
38 enum ReadResult { | 38 enum ReadResult { |
39 OK, | 39 OK, |
40 ABORTED, | 40 ABORTED, |
41 CONFIG_CHANGED, | 41 CONFIG_CHANGED, |
42 EOS, | 42 EOS, |
43 PENDING | 43 PENDING |
44 }; | 44 }; |
45 | 45 |
46 void EnterNormalReadState() { | 46 void EnterNormalReadState() { |
47 stream_.reset( | 47 stream_.reset( |
48 new FakeDemuxerStream(kNumConfigs, kNumFramesInOneConfig, false)); | 48 new FakeDemuxerStream(kNumConfigs, kNumBuffersInOneConfig, false)); |
49 for (int i = 0; i < kNumFramesToReadFirst; ++i) | 49 for (int i = 0; i < kNumBuffersToReadFirst; ++i) |
50 ReadAndExpect(OK); | |
51 } | |
52 | |
53 void EnterBeforeConfigChangedState() { | |
54 stream_.reset( | |
55 new FakeDemuxerStream(kNumConfigs, kNumFramesInOneConfig, false)); | |
56 for (int i = 0; i < kNumFramesInOneConfig; ++i) | |
57 ReadAndExpect(OK); | 50 ReadAndExpect(OK); |
58 } | 51 } |
59 | 52 |
60 void EnterBeforeEOSState() { | 53 void EnterBeforeEOSState() { |
61 stream_.reset(new FakeDemuxerStream(1, kNumFramesInOneConfig, false)); | 54 stream_.reset(new FakeDemuxerStream(1, kNumBuffersInOneConfig, false)); |
62 for (int i = 0; i < kNumFramesInOneConfig; ++i) | 55 for (int i = 0; i < kNumBuffersInOneConfig; ++i) |
63 ReadAndExpect(OK); | 56 ReadAndExpect(OK); |
64 } | 57 } |
65 | 58 |
66 void ExpectReadResult(ReadResult result) { | 59 void ExpectReadResult(ReadResult result) { |
67 switch (result) { | 60 switch (result) { |
68 case OK: | 61 case OK: |
69 EXPECT_FALSE(read_pending_); | 62 EXPECT_FALSE(read_pending_); |
70 EXPECT_EQ(DemuxerStream::kOk, status_); | 63 EXPECT_EQ(DemuxerStream::kOk, status_); |
71 ASSERT_TRUE(buffer_); | 64 ASSERT_TRUE(buffer_); |
72 EXPECT_FALSE(buffer_->IsEndOfStream()); | 65 EXPECT_FALSE(buffer_->IsEndOfStream()); |
(...skipping 26 matching lines...) Expand all Loading... | |
99 | 92 |
100 void ReadAndExpect(ReadResult result) { | 93 void ReadAndExpect(ReadResult result) { |
101 EXPECT_FALSE(read_pending_); | 94 EXPECT_FALSE(read_pending_); |
102 read_pending_ = true; | 95 read_pending_ = true; |
103 stream_->Read(base::Bind(&FakeDemuxerStreamTest::BufferReady, | 96 stream_->Read(base::Bind(&FakeDemuxerStreamTest::BufferReady, |
104 base::Unretained(this))); | 97 base::Unretained(this))); |
105 message_loop_.RunUntilIdle(); | 98 message_loop_.RunUntilIdle(); |
106 ExpectReadResult(result); | 99 ExpectReadResult(result); |
107 } | 100 } |
108 | 101 |
102 void ReadUntilPending() { | |
103 while (1) { | |
scherkus (not reviewing)
2013/05/28 15:56:57
for (;;) {} ?
xhwang
2013/05/28 19:34:10
Done.
| |
104 read_pending_ = true; | |
105 stream_->Read(base::Bind(&FakeDemuxerStreamTest::BufferReady, | |
106 base::Unretained(this))); | |
107 message_loop_.RunUntilIdle(); | |
108 if (read_pending_) | |
109 break; | |
110 } | |
111 } | |
112 | |
109 void SatisfyReadAndExpect(ReadResult result) { | 113 void SatisfyReadAndExpect(ReadResult result) { |
110 EXPECT_TRUE(read_pending_); | 114 EXPECT_TRUE(read_pending_); |
111 stream_->SatisfyRead(); | 115 stream_->SatisfyRead(); |
112 message_loop_.RunUntilIdle(); | 116 message_loop_.RunUntilIdle(); |
113 ExpectReadResult(result); | 117 ExpectReadResult(result); |
114 } | 118 } |
115 | 119 |
116 void Reset() { | 120 void Reset() { |
117 bool had_read_pending = read_pending_; | 121 bool had_read_pending = read_pending_; |
118 stream_->Reset(); | 122 stream_->Reset(); |
119 message_loop_.RunUntilIdle(); | 123 message_loop_.RunUntilIdle(); |
120 | 124 |
121 EXPECT_FALSE(read_pending_); | 125 EXPECT_FALSE(read_pending_); |
122 if (had_read_pending) | 126 if (had_read_pending) |
123 ExpectReadResult(ABORTED); | 127 ExpectReadResult(ABORTED); |
124 } | 128 } |
125 | 129 |
126 void TestRead(int num_configs, | 130 void TestRead(int num_configs, |
127 int num_frames_in_one_config, | 131 int num_buffers_in_one_config, |
128 bool is_encrypted) { | 132 bool is_encrypted) { |
129 stream_.reset(new FakeDemuxerStream( | 133 stream_.reset(new FakeDemuxerStream( |
130 num_configs, num_frames_in_one_config, is_encrypted)); | 134 num_configs, num_buffers_in_one_config, is_encrypted)); |
135 | |
136 int num_buffers_received = 0; | |
131 | 137 |
132 const VideoDecoderConfig& config = stream_->video_decoder_config(); | 138 const VideoDecoderConfig& config = stream_->video_decoder_config(); |
133 EXPECT_TRUE(config.IsValidConfig()); | 139 EXPECT_TRUE(config.IsValidConfig()); |
134 EXPECT_EQ(is_encrypted, config.is_encrypted()); | 140 EXPECT_EQ(is_encrypted, config.is_encrypted()); |
135 | 141 |
136 for (int i = 0; i < num_configs; ++i) { | 142 for (int i = 0; i < num_configs; ++i) { |
137 for (int j = 0; j < num_frames_in_one_config; ++j) | 143 for (int j = 0; j < num_buffers_in_one_config; ++j) { |
138 ReadAndExpect(OK); | 144 ReadAndExpect(OK); |
145 num_buffers_received++; | |
146 EXPECT_EQ(num_buffers_received, stream_->num_buffers_returned()); | |
147 } | |
139 | 148 |
140 if (i == num_configs - 1) | 149 if (i == num_configs - 1) |
141 ReadAndExpect(EOS); | 150 ReadAndExpect(EOS); |
142 else | 151 else |
143 ReadAndExpect(CONFIG_CHANGED); | 152 ReadAndExpect(CONFIG_CHANGED); |
144 } | 153 } |
145 | 154 |
146 // Will always get EOS after we hit EOS. | 155 // Will always get EOS after we hit EOS. |
147 ReadAndExpect(EOS); | 156 ReadAndExpect(EOS); |
157 | |
158 EXPECT_EQ(num_configs * num_buffers_in_one_config, num_buffers_received); | |
148 } | 159 } |
149 | 160 |
150 base::MessageLoop message_loop_; | 161 base::MessageLoop message_loop_; |
151 scoped_ptr<FakeDemuxerStream> stream_; | 162 scoped_ptr<FakeDemuxerStream> stream_; |
152 | 163 |
153 DemuxerStream::Status status_; | 164 DemuxerStream::Status status_; |
154 scoped_refptr<DecoderBuffer> buffer_; | 165 scoped_refptr<DecoderBuffer> buffer_; |
155 bool read_pending_; | 166 bool read_pending_; |
167 int num_buffers_received_; | |
156 | 168 |
157 private: | 169 private: |
158 DISALLOW_COPY_AND_ASSIGN(FakeDemuxerStreamTest); | 170 DISALLOW_COPY_AND_ASSIGN(FakeDemuxerStreamTest); |
159 }; | 171 }; |
160 | 172 |
161 TEST_F(FakeDemuxerStreamTest, Read_OneConfig) { | 173 TEST_F(FakeDemuxerStreamTest, Read_OneConfig) { |
162 TestRead(1, 5, false); | 174 TestRead(1, 5, false); |
163 } | 175 } |
164 | 176 |
165 TEST_F(FakeDemuxerStreamTest, Read_MultipleConfigs) { | 177 TEST_F(FakeDemuxerStreamTest, Read_MultipleConfigs) { |
166 TestRead(3, 5, false); | 178 TestRead(3, 5, false); |
167 } | 179 } |
168 | 180 |
169 TEST_F(FakeDemuxerStreamTest, Read_OneFramePerConfig) { | 181 TEST_F(FakeDemuxerStreamTest, Read_OneBufferPerConfig) { |
170 TestRead(3, 1, false); | 182 TestRead(3, 1, false); |
171 } | 183 } |
172 | 184 |
173 TEST_F(FakeDemuxerStreamTest, Read_Encrypted) { | 185 TEST_F(FakeDemuxerStreamTest, Read_Encrypted) { |
174 TestRead(6, 3, true); | 186 TestRead(6, 3, true); |
175 } | 187 } |
176 | 188 |
177 TEST_F(FakeDemuxerStreamTest, HoldRead_Normal) { | 189 TEST_F(FakeDemuxerStreamTest, HoldRead_Normal) { |
178 EnterNormalReadState(); | 190 EnterNormalReadState(); |
179 stream_->HoldNextRead(); | 191 stream_->HoldNextRead(); |
180 ReadAndExpect(PENDING); | 192 ReadAndExpect(PENDING); |
181 SatisfyReadAndExpect(OK); | 193 SatisfyReadAndExpect(OK); |
182 } | 194 } |
183 | 195 |
184 TEST_F(FakeDemuxerStreamTest, HoldRead_BeforeConfigChanged) { | 196 TEST_F(FakeDemuxerStreamTest, HoldRead_BeforeConfigChanged) { |
185 EnterBeforeConfigChangedState(); | 197 EnterNormalReadState(); |
186 stream_->HoldNextRead(); | 198 stream_->HoldNextConfigChangeRead(); |
187 ReadAndExpect(PENDING); | 199 ReadUntilPending(); |
188 SatisfyReadAndExpect(CONFIG_CHANGED); | 200 SatisfyReadAndExpect(CONFIG_CHANGED); |
189 } | 201 } |
190 | 202 |
191 TEST_F(FakeDemuxerStreamTest, HoldRead_BeforeEOS) { | 203 TEST_F(FakeDemuxerStreamTest, HoldRead_BeforeEOS) { |
192 EnterBeforeEOSState(); | 204 EnterBeforeEOSState(); |
193 stream_->HoldNextRead(); | 205 stream_->HoldNextRead(); |
194 ReadAndExpect(PENDING); | 206 ReadAndExpect(PENDING); |
195 SatisfyReadAndExpect(EOS); | 207 SatisfyReadAndExpect(EOS); |
196 } | 208 } |
197 | 209 |
(...skipping 12 matching lines...) Expand all Loading... | |
210 | 222 |
211 TEST_F(FakeDemuxerStreamTest, Reset_DuringPendingRead) { | 223 TEST_F(FakeDemuxerStreamTest, Reset_DuringPendingRead) { |
212 EnterNormalReadState(); | 224 EnterNormalReadState(); |
213 stream_->HoldNextRead(); | 225 stream_->HoldNextRead(); |
214 ReadAndExpect(PENDING); | 226 ReadAndExpect(PENDING); |
215 Reset(); | 227 Reset(); |
216 ReadAndExpect(OK); | 228 ReadAndExpect(OK); |
217 } | 229 } |
218 | 230 |
219 TEST_F(FakeDemuxerStreamTest, Reset_BeforeConfigChanged) { | 231 TEST_F(FakeDemuxerStreamTest, Reset_BeforeConfigChanged) { |
220 EnterBeforeConfigChangedState(); | 232 EnterNormalReadState(); |
221 stream_->HoldNextRead(); | 233 stream_->HoldNextConfigChangeRead(); |
222 ReadAndExpect(PENDING); | 234 ReadUntilPending(); |
223 Reset(); | 235 Reset(); |
224 ReadAndExpect(CONFIG_CHANGED); | 236 ReadAndExpect(CONFIG_CHANGED); |
225 } | 237 } |
226 | 238 |
227 TEST_F(FakeDemuxerStreamTest, Reset_BeforeEOS) { | 239 TEST_F(FakeDemuxerStreamTest, Reset_BeforeEOS) { |
228 EnterBeforeEOSState(); | 240 EnterBeforeEOSState(); |
229 stream_->HoldNextRead(); | 241 stream_->HoldNextRead(); |
230 ReadAndExpect(PENDING); | 242 ReadAndExpect(PENDING); |
231 Reset(); | 243 Reset(); |
232 ReadAndExpect(EOS); | 244 ReadAndExpect(EOS); |
233 } | 245 } |
234 | 246 |
235 } // namespace media | 247 } // namespace media |
OLD | NEW |