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 "media/base/filter_host.h" | 7 #include "media/base/filter_host.h" |
8 | 8 |
9 using ::testing::_; | 9 using ::testing::_; |
10 using ::testing::Invoke; | 10 using ::testing::Invoke; |
(...skipping 17 matching lines...) Expand all Loading... |
28 if (buffered_bytes_ > 0) | 28 if (buffered_bytes_ > 0) |
29 host()->SetBufferedBytes(buffered_bytes_); | 29 host()->SetBufferedBytes(buffered_bytes_); |
30 } | 30 } |
31 | 31 |
32 void MockDataSource::SetTotalAndBufferedBytes(int64 total_bytes, | 32 void MockDataSource::SetTotalAndBufferedBytes(int64 total_bytes, |
33 int64 buffered_bytes) { | 33 int64 buffered_bytes) { |
34 total_bytes_ = total_bytes; | 34 total_bytes_ = total_bytes; |
35 buffered_bytes_ = buffered_bytes; | 35 buffered_bytes_ = buffered_bytes; |
36 } | 36 } |
37 | 37 |
38 MockDataSourceFactory::MockDataSourceFactory(MockDataSource* data_source) | 38 MockDemuxerFactory::MockDemuxerFactory(MockDemuxer* demuxer) |
39 : data_source_(data_source), | 39 : demuxer_(demuxer), error_(PIPELINE_OK) { |
40 error_(PIPELINE_OK) { | |
41 } | 40 } |
42 | 41 |
43 void MockDataSourceFactory::SetError(PipelineError error) { | 42 MockDemuxerFactory::~MockDemuxerFactory() {} |
| 43 |
| 44 void MockDemuxerFactory::SetError(PipelineError error) { |
44 error_ = error; | 45 error_ = error; |
45 } | 46 } |
46 | 47 |
47 void MockDataSourceFactory::RunBuildCallback(const std::string& url, | 48 void MockDemuxerFactory::RunBuildCallback(const std::string& url, |
48 BuildCallback* callback) { | 49 BuildCallback* callback) { |
49 scoped_ptr<BuildCallback> cb(callback); | 50 scoped_ptr<BuildCallback> cb(callback); |
50 | 51 |
51 if (!data_source_.get()) { | 52 if (!demuxer_.get()) { |
52 cb->Run(PIPELINE_ERROR_REQUIRED_FILTER_MISSING, | 53 cb->Run(PIPELINE_ERROR_REQUIRED_FILTER_MISSING, |
53 static_cast<DataSource*>(NULL)); | 54 static_cast<Demuxer*>(NULL)); |
54 return; | 55 return; |
55 } | 56 } |
56 | 57 |
57 scoped_refptr<MockDataSource> data_source = data_source_; | 58 scoped_refptr<MockDemuxer> demuxer = demuxer_; |
58 data_source_ = NULL; | 59 demuxer_ = NULL; |
59 | 60 |
60 if (error_ == PIPELINE_OK) { | 61 if (error_ == PIPELINE_OK) { |
61 cb->Run(PIPELINE_OK, data_source.get()); | 62 cb->Run(PIPELINE_OK, demuxer.get()); |
62 return; | 63 return; |
63 } | 64 } |
64 | 65 |
65 cb->Run(error_, static_cast<DataSource*>(NULL)); | 66 cb->Run(error_, static_cast<Demuxer*>(NULL)); |
66 } | 67 } |
67 | 68 |
68 void MockDataSourceFactory::DestroyBuildCallback(const std::string& url, | 69 void MockDemuxerFactory::DestroyBuildCallback(const std::string& url, |
69 BuildCallback* callback) { | 70 BuildCallback* callback) { |
70 delete callback; | 71 delete callback; |
71 } | 72 } |
72 | 73 |
73 DataSourceFactory* MockDataSourceFactory::Clone() const { | 74 DemuxerFactory* MockDemuxerFactory::Clone() const { |
74 return new MockDataSourceFactory(data_source_.get()); | 75 return new MockDemuxerFactory(demuxer_.get()); |
75 } | 76 } |
76 | 77 |
77 MockDemuxer::MockDemuxer() {} | 78 MockDemuxer::MockDemuxer() |
| 79 : total_bytes_(-1), buffered_bytes_(-1), duration_() {} |
78 | 80 |
79 MockDemuxer::~MockDemuxer() {} | 81 MockDemuxer::~MockDemuxer() {} |
80 | 82 |
| 83 void MockDemuxer::set_host(FilterHost* filter_host) { |
| 84 Filter::set_host(filter_host); |
| 85 |
| 86 if (total_bytes_ > 0) |
| 87 host()->SetTotalBytes(total_bytes_); |
| 88 |
| 89 if (buffered_bytes_ > 0) |
| 90 host()->SetBufferedBytes(buffered_bytes_); |
| 91 |
| 92 if (duration_.InMilliseconds() > 0) |
| 93 host()->SetDuration(duration_); |
| 94 } |
| 95 |
| 96 void MockDemuxer::SetTotalAndBufferedBytesAndDuration( |
| 97 int64 total_bytes, int64 buffered_bytes, const base::TimeDelta& duration) { |
| 98 total_bytes_ = total_bytes; |
| 99 buffered_bytes_ = buffered_bytes; |
| 100 duration_ = duration; |
| 101 } |
| 102 |
81 MockDemuxerStream::MockDemuxerStream() {} | 103 MockDemuxerStream::MockDemuxerStream() {} |
82 | 104 |
83 MockDemuxerStream::~MockDemuxerStream() {} | 105 MockDemuxerStream::~MockDemuxerStream() {} |
84 | 106 |
85 MockVideoDecoder::MockVideoDecoder() {} | 107 MockVideoDecoder::MockVideoDecoder() {} |
86 | 108 |
87 MockVideoDecoder::~MockVideoDecoder() {} | 109 MockVideoDecoder::~MockVideoDecoder() {} |
88 | 110 |
89 MockAudioDecoder::MockAudioDecoder() {} | 111 MockAudioDecoder::MockAudioDecoder() {} |
90 | 112 |
91 MockAudioDecoder::~MockAudioDecoder() {} | 113 MockAudioDecoder::~MockAudioDecoder() {} |
92 | 114 |
93 MockVideoRenderer::MockVideoRenderer() {} | 115 MockVideoRenderer::MockVideoRenderer() {} |
94 | 116 |
95 MockVideoRenderer::~MockVideoRenderer() {} | 117 MockVideoRenderer::~MockVideoRenderer() {} |
96 | 118 |
97 MockAudioRenderer::MockAudioRenderer() {} | 119 MockAudioRenderer::MockAudioRenderer() {} |
98 | 120 |
99 MockAudioRenderer::~MockAudioRenderer() {} | 121 MockAudioRenderer::~MockAudioRenderer() {} |
100 | 122 |
101 MockFilterCollection::MockFilterCollection() | 123 MockFilterCollection::MockFilterCollection() |
102 : data_source_(new MockDataSource()), | 124 : demuxer_(new MockDemuxer()), |
103 demuxer_(new MockDemuxer()), | |
104 video_decoder_(new MockVideoDecoder()), | 125 video_decoder_(new MockVideoDecoder()), |
105 audio_decoder_(new MockAudioDecoder()), | 126 audio_decoder_(new MockAudioDecoder()), |
106 video_renderer_(new MockVideoRenderer()), | 127 video_renderer_(new MockVideoRenderer()), |
107 audio_renderer_(new MockAudioRenderer()) { | 128 audio_renderer_(new MockAudioRenderer()) { |
108 } | 129 } |
109 | 130 |
110 MockFilterCollection::~MockFilterCollection() {} | 131 MockFilterCollection::~MockFilterCollection() {} |
111 | 132 |
112 FilterCollection* MockFilterCollection::filter_collection( | 133 FilterCollection* MockFilterCollection::filter_collection( |
113 bool include_data_source, | 134 bool include_demuxer, |
114 bool run_build_callback, | 135 bool run_build_callback, |
115 PipelineError build_error) const { | 136 PipelineError build_error) const { |
116 FilterCollection* collection = new FilterCollection(); | 137 FilterCollection* collection = new FilterCollection(); |
117 | 138 |
118 MockDataSourceFactory* data_source_factory = | 139 MockDemuxerFactory* demuxer_factory = |
119 new MockDataSourceFactory(include_data_source ? data_source_ : NULL); | 140 new MockDemuxerFactory(include_demuxer ? demuxer_ : NULL); |
120 | 141 |
121 if (build_error != PIPELINE_OK) | 142 if (build_error != PIPELINE_OK) |
122 data_source_factory->SetError(build_error); | 143 demuxer_factory->SetError(build_error); |
123 | 144 |
124 if (run_build_callback) { | 145 if (run_build_callback) { |
125 ON_CALL(*data_source_factory, Build(_, NotNull())) | 146 ON_CALL(*demuxer_factory, Build(_, NotNull())).WillByDefault(Invoke( |
126 .WillByDefault(Invoke(data_source_factory, | 147 demuxer_factory, &MockDemuxerFactory::RunBuildCallback)); |
127 &MockDataSourceFactory::RunBuildCallback)); | |
128 } else { | 148 } else { |
129 ON_CALL(*data_source_factory, Build(_, NotNull())) | 149 ON_CALL(*demuxer_factory, Build(_, NotNull())).WillByDefault(Invoke( |
130 .WillByDefault(Invoke(data_source_factory, | 150 demuxer_factory, &MockDemuxerFactory::DestroyBuildCallback)); |
131 &MockDataSourceFactory::DestroyBuildCallback)); | |
132 } | 151 } |
133 EXPECT_CALL(*data_source_factory, Build(_, NotNull())); | 152 EXPECT_CALL(*demuxer_factory, Build(_, NotNull())); |
134 | 153 |
135 collection->SetDataSourceFactory(data_source_factory); | 154 collection->SetDemuxerFactory(demuxer_factory); |
136 collection->AddDemuxer(demuxer_); | |
137 collection->AddVideoDecoder(video_decoder_); | 155 collection->AddVideoDecoder(video_decoder_); |
138 collection->AddAudioDecoder(audio_decoder_); | 156 collection->AddAudioDecoder(audio_decoder_); |
139 collection->AddVideoRenderer(video_renderer_); | 157 collection->AddVideoRenderer(video_renderer_); |
140 collection->AddAudioRenderer(audio_renderer_); | 158 collection->AddAudioRenderer(audio_renderer_); |
141 return collection; | 159 return collection; |
142 } | 160 } |
143 | 161 |
144 void RunFilterCallback(::testing::Unused, FilterCallback* callback) { | 162 void RunFilterCallback(::testing::Unused, FilterCallback* callback) { |
145 callback->Run(); | 163 callback->Run(); |
146 delete callback; | 164 delete callback; |
147 } | 165 } |
148 | 166 |
| 167 void RunPipelineStatusCallback( |
| 168 PipelineError status, PipelineStatusCallback* callback) { |
| 169 callback->Run(status); |
| 170 delete callback; |
| 171 } |
| 172 |
149 void RunFilterCallback3(::testing::Unused, FilterCallback* callback, | 173 void RunFilterCallback3(::testing::Unused, FilterCallback* callback, |
150 ::testing::Unused) { | 174 ::testing::Unused) { |
151 callback->Run(); | 175 callback->Run(); |
152 delete callback; | 176 delete callback; |
153 } | 177 } |
154 | 178 |
155 void DestroyFilterCallback(::testing::Unused, FilterCallback* callback) { | 179 void DestroyFilterCallback(::testing::Unused, FilterCallback* callback) { |
156 delete callback; | 180 delete callback; |
157 } | 181 } |
158 | 182 |
159 void RunStopFilterCallback(FilterCallback* callback) { | 183 void RunStopFilterCallback(FilterCallback* callback) { |
160 callback->Run(); | 184 callback->Run(); |
161 delete callback; | 185 delete callback; |
162 } | 186 } |
163 | 187 |
164 MockFilter::MockFilter() { | 188 MockFilter::MockFilter() { |
165 } | 189 } |
166 | 190 |
167 MockFilter::~MockFilter() {} | 191 MockFilter::~MockFilter() {} |
168 | 192 |
169 MockStatisticsCallback::MockStatisticsCallback() {} | 193 MockStatisticsCallback::MockStatisticsCallback() {} |
170 | 194 |
171 MockStatisticsCallback::~MockStatisticsCallback() {} | 195 MockStatisticsCallback::~MockStatisticsCallback() {} |
172 | 196 |
173 } // namespace media | 197 } // namespace media |
OLD | NEW |