OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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 "media/base/mock_filters.h" | 5 #include "media/base/mock_filters.h" |
6 | 6 |
| 7 #include "base/logging.h" |
7 #include "media/base/filter_host.h" | 8 #include "media/base/filter_host.h" |
8 | 9 |
9 using ::testing::_; | 10 using ::testing::_; |
10 using ::testing::Invoke; | 11 using ::testing::Invoke; |
11 using ::testing::NotNull; | 12 using ::testing::NotNull; |
12 | 13 |
13 namespace media { | 14 namespace media { |
14 | 15 |
15 MockDataSource::MockDataSource() | 16 MockDataSource::MockDataSource() |
16 : total_bytes_(-1), | 17 : total_bytes_(-1), |
(...skipping 12 matching lines...) Expand all Loading... |
29 host()->SetBufferedBytes(buffered_bytes_); | 30 host()->SetBufferedBytes(buffered_bytes_); |
30 } | 31 } |
31 | 32 |
32 void MockDataSource::SetTotalAndBufferedBytes(int64 total_bytes, | 33 void MockDataSource::SetTotalAndBufferedBytes(int64 total_bytes, |
33 int64 buffered_bytes) { | 34 int64 buffered_bytes) { |
34 total_bytes_ = total_bytes; | 35 total_bytes_ = total_bytes; |
35 buffered_bytes_ = buffered_bytes; | 36 buffered_bytes_ = buffered_bytes; |
36 } | 37 } |
37 | 38 |
38 MockDemuxerFactory::MockDemuxerFactory(MockDemuxer* demuxer) | 39 MockDemuxerFactory::MockDemuxerFactory(MockDemuxer* demuxer) |
39 : demuxer_(demuxer), error_(PIPELINE_OK) { | 40 : demuxer_(demuxer), status_(PIPELINE_OK) { |
40 } | 41 } |
41 | 42 |
42 MockDemuxerFactory::~MockDemuxerFactory() {} | 43 MockDemuxerFactory::~MockDemuxerFactory() {} |
43 | 44 |
44 void MockDemuxerFactory::SetError(PipelineError error) { | 45 void MockDemuxerFactory::SetError(PipelineStatus error) { |
45 error_ = error; | 46 DCHECK_NE(error, PIPELINE_OK); |
| 47 status_ = error; |
46 } | 48 } |
47 | 49 |
48 void MockDemuxerFactory::RunBuildCallback(const std::string& url, | 50 void MockDemuxerFactory::RunBuildCallback(const std::string& url, |
49 BuildCallback* callback) { | 51 BuildCallback* callback) { |
50 scoped_ptr<BuildCallback> cb(callback); | 52 scoped_ptr<BuildCallback> cb(callback); |
51 | 53 |
52 if (!demuxer_.get()) { | 54 if (!demuxer_.get()) { |
53 cb->Run(PIPELINE_ERROR_REQUIRED_FILTER_MISSING, | 55 cb->Run(PIPELINE_ERROR_REQUIRED_FILTER_MISSING, |
54 static_cast<Demuxer*>(NULL)); | 56 static_cast<Demuxer*>(NULL)); |
55 return; | 57 return; |
56 } | 58 } |
57 | 59 |
58 scoped_refptr<MockDemuxer> demuxer = demuxer_; | 60 scoped_refptr<MockDemuxer> demuxer = demuxer_; |
59 demuxer_ = NULL; | 61 demuxer_ = NULL; |
60 | 62 |
61 if (error_ == PIPELINE_OK) { | 63 if (status_ == PIPELINE_OK) { |
62 cb->Run(PIPELINE_OK, demuxer.get()); | 64 cb->Run(PIPELINE_OK, demuxer.get()); |
63 return; | 65 return; |
64 } | 66 } |
65 | 67 |
66 cb->Run(error_, static_cast<Demuxer*>(NULL)); | 68 cb->Run(status_, static_cast<Demuxer*>(NULL)); |
67 } | 69 } |
68 | 70 |
69 void MockDemuxerFactory::DestroyBuildCallback(const std::string& url, | 71 void MockDemuxerFactory::DestroyBuildCallback(const std::string& url, |
70 BuildCallback* callback) { | 72 BuildCallback* callback) { |
71 delete callback; | 73 delete callback; |
72 } | 74 } |
73 | 75 |
74 DemuxerFactory* MockDemuxerFactory::Clone() const { | 76 DemuxerFactory* MockDemuxerFactory::Clone() const { |
75 return new MockDemuxerFactory(demuxer_.get()); | 77 return new MockDemuxerFactory(demuxer_.get()); |
76 } | 78 } |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
126 audio_decoder_(new MockAudioDecoder()), | 128 audio_decoder_(new MockAudioDecoder()), |
127 video_renderer_(new MockVideoRenderer()), | 129 video_renderer_(new MockVideoRenderer()), |
128 audio_renderer_(new MockAudioRenderer()) { | 130 audio_renderer_(new MockAudioRenderer()) { |
129 } | 131 } |
130 | 132 |
131 MockFilterCollection::~MockFilterCollection() {} | 133 MockFilterCollection::~MockFilterCollection() {} |
132 | 134 |
133 FilterCollection* MockFilterCollection::filter_collection( | 135 FilterCollection* MockFilterCollection::filter_collection( |
134 bool include_demuxer, | 136 bool include_demuxer, |
135 bool run_build_callback, | 137 bool run_build_callback, |
136 PipelineError build_error) const { | 138 PipelineStatus build_status) const { |
137 FilterCollection* collection = new FilterCollection(); | 139 FilterCollection* collection = new FilterCollection(); |
138 | 140 |
139 MockDemuxerFactory* demuxer_factory = | 141 MockDemuxerFactory* demuxer_factory = |
140 new MockDemuxerFactory(include_demuxer ? demuxer_ : NULL); | 142 new MockDemuxerFactory(include_demuxer ? demuxer_ : NULL); |
141 | 143 |
142 if (build_error != PIPELINE_OK) | 144 if (build_status != PIPELINE_OK) |
143 demuxer_factory->SetError(build_error); | 145 demuxer_factory->SetError(build_status); |
144 | 146 |
145 if (run_build_callback) { | 147 if (run_build_callback) { |
146 ON_CALL(*demuxer_factory, Build(_, NotNull())).WillByDefault(Invoke( | 148 ON_CALL(*demuxer_factory, Build(_, NotNull())).WillByDefault(Invoke( |
147 demuxer_factory, &MockDemuxerFactory::RunBuildCallback)); | 149 demuxer_factory, &MockDemuxerFactory::RunBuildCallback)); |
148 } else { | 150 } else { |
149 ON_CALL(*demuxer_factory, Build(_, NotNull())).WillByDefault(Invoke( | 151 ON_CALL(*demuxer_factory, Build(_, NotNull())).WillByDefault(Invoke( |
150 demuxer_factory, &MockDemuxerFactory::DestroyBuildCallback)); | 152 demuxer_factory, &MockDemuxerFactory::DestroyBuildCallback)); |
151 } | 153 } |
152 EXPECT_CALL(*demuxer_factory, Build(_, NotNull())); | 154 EXPECT_CALL(*demuxer_factory, Build(_, NotNull())); |
153 | 155 |
154 collection->SetDemuxerFactory(demuxer_factory); | 156 collection->SetDemuxerFactory(demuxer_factory); |
155 collection->AddVideoDecoder(video_decoder_); | 157 collection->AddVideoDecoder(video_decoder_); |
156 collection->AddAudioDecoder(audio_decoder_); | 158 collection->AddAudioDecoder(audio_decoder_); |
157 collection->AddVideoRenderer(video_renderer_); | 159 collection->AddVideoRenderer(video_renderer_); |
158 collection->AddAudioRenderer(audio_renderer_); | 160 collection->AddAudioRenderer(audio_renderer_); |
159 return collection; | 161 return collection; |
160 } | 162 } |
161 | 163 |
162 void RunFilterCallback(::testing::Unused, FilterCallback* callback) { | 164 void RunFilterCallback(::testing::Unused, FilterCallback* callback) { |
163 callback->Run(); | 165 callback->Run(); |
164 delete callback; | 166 delete callback; |
165 } | 167 } |
166 | 168 |
167 void RunPipelineStatusCallback( | 169 void RunPipelineStatusCallback( |
168 PipelineError status, PipelineStatusCallback* callback) { | 170 PipelineStatus status, PipelineStatusCallback* callback) { |
169 callback->Run(status); | 171 callback->Run(status); |
170 delete callback; | 172 delete callback; |
171 } | 173 } |
172 | 174 |
173 void RunFilterCallback3(::testing::Unused, FilterCallback* callback, | 175 void RunFilterCallback3(::testing::Unused, FilterCallback* callback, |
174 ::testing::Unused) { | 176 ::testing::Unused) { |
175 callback->Run(); | 177 callback->Run(); |
176 delete callback; | 178 delete callback; |
177 } | 179 } |
178 | 180 |
179 void DestroyFilterCallback(::testing::Unused, FilterCallback* callback) { | 181 void DestroyFilterCallback(::testing::Unused, FilterCallback* callback) { |
180 delete callback; | 182 delete callback; |
181 } | 183 } |
182 | 184 |
183 void RunStopFilterCallback(FilterCallback* callback) { | 185 void RunStopFilterCallback(FilterCallback* callback) { |
184 callback->Run(); | 186 callback->Run(); |
185 delete callback; | 187 delete callback; |
186 } | 188 } |
187 | 189 |
188 MockFilter::MockFilter() { | 190 MockFilter::MockFilter() { |
189 } | 191 } |
190 | 192 |
191 MockFilter::~MockFilter() {} | 193 MockFilter::~MockFilter() {} |
192 | 194 |
193 MockStatisticsCallback::MockStatisticsCallback() {} | 195 MockStatisticsCallback::MockStatisticsCallback() {} |
194 | 196 |
195 MockStatisticsCallback::~MockStatisticsCallback() {} | 197 MockStatisticsCallback::~MockStatisticsCallback() {} |
196 | 198 |
197 } // namespace media | 199 } // namespace media |
OLD | NEW |