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
3// found in the LICENSE file.
4
5#ifndef MEDIA_BASE_MOCK_FILTERS_H_
6#define MEDIA_BASE_MOCK_FILTERS_H_
7
8#include <string>
9
10#include "base/callback.h"
11#include "media/base/audio_decoder.h"
12#include "media/base/audio_decoder_config.h"
13#include "media/base/audio_renderer.h"
14#include "media/base/decoder_buffer.h"
15#include "media/base/decryptor.h"
16#include "media/base/demuxer.h"
17#include "media/base/filter_collection.h"
18#include "media/base/pipeline_status.h"
19#include "media/base/text_track.h"
20#include "media/base/video_decoder.h"
21#include "media/base/video_decoder_config.h"
22#include "media/base/video_frame.h"
23#include "media/base/video_renderer.h"
24#include "testing/gmock/include/gmock/gmock.h"
25
26namespace media {
27
28class MockDemuxer : public Demuxer {
29 public:
30  MockDemuxer();
31  virtual ~MockDemuxer();
32
33  // Demuxer implementation.
34  MOCK_METHOD3(Initialize,
35               void(DemuxerHost* host, const PipelineStatusCB& cb, bool));
36  MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
37  MOCK_METHOD2(Seek, void(base::TimeDelta time, const PipelineStatusCB& cb));
38  MOCK_METHOD1(Stop, void(const base::Closure& callback));
39  MOCK_METHOD0(OnAudioRendererDisabled, void());
40  MOCK_METHOD1(GetStream, DemuxerStream*(DemuxerStream::Type));
41  MOCK_CONST_METHOD0(GetStartTime, base::TimeDelta());
42  MOCK_CONST_METHOD0(GetTimelineOffset, base::Time());
43  MOCK_CONST_METHOD0(GetLiveness, Liveness());
44
45 private:
46  DISALLOW_COPY_AND_ASSIGN(MockDemuxer);
47};
48
49class MockDemuxerStream : public DemuxerStream {
50 public:
51  explicit MockDemuxerStream(DemuxerStream::Type type);
52  virtual ~MockDemuxerStream();
53
54  // DemuxerStream implementation.
55  virtual Type type() OVERRIDE;
56  MOCK_METHOD1(Read, void(const ReadCB& read_cb));
57  virtual AudioDecoderConfig audio_decoder_config() OVERRIDE;
58  virtual VideoDecoderConfig video_decoder_config() OVERRIDE;
59  MOCK_METHOD0(EnableBitstreamConverter, void());
60  MOCK_METHOD0(SupportsConfigChanges, bool());
61
62  void set_audio_decoder_config(const AudioDecoderConfig& config);
63  void set_video_decoder_config(const VideoDecoderConfig& config);
64
65 private:
66  DemuxerStream::Type type_;
67  AudioDecoderConfig audio_decoder_config_;
68  VideoDecoderConfig video_decoder_config_;
69
70  DISALLOW_COPY_AND_ASSIGN(MockDemuxerStream);
71};
72
73class MockVideoDecoder : public VideoDecoder {
74 public:
75  MockVideoDecoder();
76  virtual ~MockVideoDecoder();
77
78  // VideoDecoder implementation.
79  MOCK_METHOD4(Initialize, void(const VideoDecoderConfig& config,
80                                bool low_delay,
81                                const PipelineStatusCB& status_cb,
82                                const OutputCB& output_cb));
83  MOCK_METHOD2(Decode, void(const scoped_refptr<DecoderBuffer>& buffer,
84                            const DecodeCB&));
85  MOCK_METHOD1(Reset, void(const base::Closure&));
86  MOCK_METHOD0(Stop, void());
87  MOCK_CONST_METHOD0(HasAlpha, bool());
88
89 private:
90  DISALLOW_COPY_AND_ASSIGN(MockVideoDecoder);
91};
92
93class MockAudioDecoder : public AudioDecoder {
94 public:
95  MockAudioDecoder();
96  virtual ~MockAudioDecoder();
97
98  // AudioDecoder implementation.
99  MOCK_METHOD3(Initialize,
100               void(const AudioDecoderConfig& config,
101                    const PipelineStatusCB& status_cb,
102                    const OutputCB& output_cb));
103  MOCK_METHOD2(Decode,
104               void(const scoped_refptr<DecoderBuffer>& buffer,
105                    const DecodeCB&));
106  MOCK_METHOD1(Reset, void(const base::Closure&));
107  MOCK_METHOD0(Stop, void());
108
109 private:
110  DISALLOW_COPY_AND_ASSIGN(MockAudioDecoder);
111};
112
113class MockVideoRenderer : public VideoRenderer {
114 public:
115  MockVideoRenderer();
116  virtual ~MockVideoRenderer();
117
118  // VideoRenderer implementation.
119  MOCK_METHOD9(Initialize, void(DemuxerStream* stream,
120                                bool low_delay,
121                                const PipelineStatusCB& init_cb,
122                                const StatisticsCB& statistics_cb,
123                                const TimeCB& time_cb,
124                                const base::Closure& ended_cb,
125                                const PipelineStatusCB& error_cb,
126                                const TimeDeltaCB& get_time_cb,
127                                const TimeDeltaCB& get_duration_cb));
128  MOCK_METHOD1(Play, void(const base::Closure& callback));
129  MOCK_METHOD1(Flush, void(const base::Closure& callback));
130  MOCK_METHOD2(Preroll, void(base::TimeDelta time, const PipelineStatusCB& cb));
131  MOCK_METHOD1(Stop, void(const base::Closure& callback));
132  MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
133
134 private:
135  DISALLOW_COPY_AND_ASSIGN(MockVideoRenderer);
136};
137
138class MockAudioRenderer : public AudioRenderer {
139 public:
140  MockAudioRenderer();
141  virtual ~MockAudioRenderer();
142
143  // AudioRenderer implementation.
144  MOCK_METHOD7(Initialize, void(DemuxerStream* stream,
145                                const PipelineStatusCB& init_cb,
146                                const StatisticsCB& statistics_cb,
147                                const base::Closure& underflow_cb,
148                                const TimeCB& time_cb,
149                                const base::Closure& ended_cb,
150                                const PipelineStatusCB& error_cb));
151  MOCK_METHOD0(StartRendering, void());
152  MOCK_METHOD0(StopRendering, void());
153  MOCK_METHOD1(Flush, void(const base::Closure& callback));
154  MOCK_METHOD1(Stop, void(const base::Closure& callback));
155  MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
156  MOCK_METHOD2(Preroll, void(base::TimeDelta time, const PipelineStatusCB& cb));
157  MOCK_METHOD1(SetVolume, void(float volume));
158  MOCK_METHOD0(ResumeAfterUnderflow, void());
159
160 private:
161  DISALLOW_COPY_AND_ASSIGN(MockAudioRenderer);
162};
163
164class MockTextTrack : public TextTrack {
165 public:
166  MockTextTrack();
167  virtual ~MockTextTrack();
168
169  MOCK_METHOD5(addWebVTTCue, void(const base::TimeDelta& start,
170                                  const base::TimeDelta& end,
171                                  const std::string& id,
172                                  const std::string& content,
173                                  const std::string& settings));
174
175 private:
176  DISALLOW_COPY_AND_ASSIGN(MockTextTrack);
177};
178
179class MockDecryptor : public Decryptor {
180 public:
181  MockDecryptor();
182  virtual ~MockDecryptor();
183
184  MOCK_METHOD2(RegisterNewKeyCB, void(StreamType stream_type,
185                                      const NewKeyCB& new_key_cb));
186  MOCK_METHOD3(Decrypt, void(StreamType stream_type,
187                             const scoped_refptr<DecoderBuffer>& encrypted,
188                             const DecryptCB& decrypt_cb));
189  MOCK_METHOD1(CancelDecrypt, void(StreamType stream_type));
190  MOCK_METHOD2(InitializeAudioDecoder,
191               void(const AudioDecoderConfig& config,
192                    const DecoderInitCB& init_cb));
193  MOCK_METHOD2(InitializeVideoDecoder,
194               void(const VideoDecoderConfig& config,
195                    const DecoderInitCB& init_cb));
196  MOCK_METHOD2(DecryptAndDecodeAudio,
197               void(const scoped_refptr<media::DecoderBuffer>& encrypted,
198                    const AudioDecodeCB& audio_decode_cb));
199  MOCK_METHOD2(DecryptAndDecodeVideo,
200               void(const scoped_refptr<media::DecoderBuffer>& encrypted,
201                    const VideoDecodeCB& video_decode_cb));
202  MOCK_METHOD1(ResetDecoder, void(StreamType stream_type));
203  MOCK_METHOD1(DeinitializeDecoder, void(StreamType stream_type));
204
205 private:
206  DISALLOW_COPY_AND_ASSIGN(MockDecryptor);
207};
208
209// Helper mock statistics callback.
210class MockStatisticsCB {
211 public:
212  MockStatisticsCB();
213  ~MockStatisticsCB();
214
215  MOCK_METHOD1(OnStatistics, void(const media::PipelineStatistics& statistics));
216};
217
218}  // namespace media
219
220#endif  // MEDIA_BASE_MOCK_FILTERS_H_
221