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/pipeline_status.h"
18#include "media/base/renderer.h"
19#include "media/base/text_track.h"
20#include "media/base/time_source.h"
21#include "media/base/video_decoder.h"
22#include "media/base/video_decoder_config.h"
23#include "media/base/video_frame.h"
24#include "media/base/video_renderer.h"
25#include "testing/gmock/include/gmock/gmock.h"
26
27namespace media {
28
29class MockDemuxer : public Demuxer {
30 public:
31  MockDemuxer();
32  virtual ~MockDemuxer();
33
34  // Demuxer implementation.
35  MOCK_METHOD3(Initialize,
36               void(DemuxerHost* host, const PipelineStatusCB& cb, bool));
37  MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
38  MOCK_METHOD2(Seek, void(base::TimeDelta time, const PipelineStatusCB& cb));
39  MOCK_METHOD0(Stop, void());
40  MOCK_METHOD0(OnAudioRendererDisabled, void());
41  MOCK_METHOD1(GetStream, DemuxerStream*(DemuxerStream::Type));
42  MOCK_CONST_METHOD0(GetStartTime, base::TimeDelta());
43  MOCK_CONST_METHOD0(GetTimelineOffset, base::Time());
44  MOCK_CONST_METHOD0(GetLiveness, Liveness());
45
46 private:
47  DISALLOW_COPY_AND_ASSIGN(MockDemuxer);
48};
49
50class MockDemuxerStream : public DemuxerStream {
51 public:
52  explicit MockDemuxerStream(DemuxerStream::Type type);
53  virtual ~MockDemuxerStream();
54
55  // DemuxerStream implementation.
56  virtual Type type() OVERRIDE;
57  MOCK_METHOD1(Read, void(const ReadCB& read_cb));
58  virtual AudioDecoderConfig audio_decoder_config() OVERRIDE;
59  virtual VideoDecoderConfig video_decoder_config() OVERRIDE;
60  MOCK_METHOD0(EnableBitstreamConverter, void());
61  MOCK_METHOD0(SupportsConfigChanges, bool());
62
63  void set_audio_decoder_config(const AudioDecoderConfig& config);
64  void set_video_decoder_config(const VideoDecoderConfig& config);
65
66  virtual VideoRotation video_rotation() OVERRIDE;
67
68 private:
69  DemuxerStream::Type type_;
70  AudioDecoderConfig audio_decoder_config_;
71  VideoDecoderConfig video_decoder_config_;
72
73  DISALLOW_COPY_AND_ASSIGN(MockDemuxerStream);
74};
75
76class MockVideoDecoder : public VideoDecoder {
77 public:
78  MockVideoDecoder();
79  virtual ~MockVideoDecoder();
80
81  // VideoDecoder implementation.
82  virtual std::string GetDisplayName() const;
83  MOCK_METHOD4(Initialize, void(const VideoDecoderConfig& config,
84                                bool low_delay,
85                                const PipelineStatusCB& status_cb,
86                                const OutputCB& output_cb));
87  MOCK_METHOD2(Decode, void(const scoped_refptr<DecoderBuffer>& buffer,
88                            const DecodeCB&));
89  MOCK_METHOD1(Reset, void(const base::Closure&));
90  MOCK_CONST_METHOD0(HasAlpha, bool());
91
92 private:
93  DISALLOW_COPY_AND_ASSIGN(MockVideoDecoder);
94};
95
96class MockAudioDecoder : public AudioDecoder {
97 public:
98  MockAudioDecoder();
99  virtual ~MockAudioDecoder();
100
101  // AudioDecoder implementation.
102  virtual std::string GetDisplayName() const;
103  MOCK_METHOD3(Initialize,
104               void(const AudioDecoderConfig& config,
105                    const PipelineStatusCB& status_cb,
106                    const OutputCB& output_cb));
107  MOCK_METHOD2(Decode,
108               void(const scoped_refptr<DecoderBuffer>& buffer,
109                    const DecodeCB&));
110  MOCK_METHOD1(Reset, void(const base::Closure&));
111
112 private:
113  DISALLOW_COPY_AND_ASSIGN(MockAudioDecoder);
114};
115
116class MockVideoRenderer : public VideoRenderer {
117 public:
118  MockVideoRenderer();
119  virtual ~MockVideoRenderer();
120
121  // VideoRenderer implementation.
122  MOCK_METHOD8(Initialize, void(DemuxerStream* stream,
123                                bool low_delay,
124                                const PipelineStatusCB& init_cb,
125                                const StatisticsCB& statistics_cb,
126                                const BufferingStateCB& buffering_state_cb,
127                                const base::Closure& ended_cb,
128                                const PipelineStatusCB& error_cb,
129                                const TimeDeltaCB& get_time_cb));
130  MOCK_METHOD1(Flush, void(const base::Closure& callback));
131  MOCK_METHOD1(StartPlayingFrom, void(base::TimeDelta));
132
133 private:
134  DISALLOW_COPY_AND_ASSIGN(MockVideoRenderer);
135};
136
137class MockAudioRenderer : public AudioRenderer {
138 public:
139  MockAudioRenderer();
140  virtual ~MockAudioRenderer();
141
142  // AudioRenderer implementation.
143  MOCK_METHOD6(Initialize, void(DemuxerStream* stream,
144                                const PipelineStatusCB& init_cb,
145                                const StatisticsCB& statistics_cb,
146                                const BufferingStateCB& buffering_state_cb,
147                                const base::Closure& ended_cb,
148                                const PipelineStatusCB& error_cb));
149  MOCK_METHOD0(GetTimeSource, TimeSource*());
150  MOCK_METHOD1(Flush, void(const base::Closure& callback));
151  MOCK_METHOD0(StartPlaying, void());
152  MOCK_METHOD1(SetVolume, void(float volume));
153
154 private:
155  DISALLOW_COPY_AND_ASSIGN(MockAudioRenderer);
156};
157
158class MockRenderer : public Renderer {
159 public:
160  MockRenderer();
161  virtual ~MockRenderer();
162
163  // Renderer implementation.
164  MOCK_METHOD5(Initialize, void(const base::Closure& init_cb,
165                                const StatisticsCB& statistics_cb,
166                                const base::Closure& ended_cb,
167                                const PipelineStatusCB& error_cb,
168                                const BufferingStateCB& buffering_state_cb));
169  MOCK_METHOD1(Flush, void(const base::Closure& flush_cb));
170  MOCK_METHOD1(StartPlayingFrom, void(base::TimeDelta timestamp));
171  MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
172  MOCK_METHOD1(SetVolume, void(float volume));
173  MOCK_METHOD0(GetMediaTime, base::TimeDelta());
174  MOCK_METHOD0(HasAudio, bool());
175  MOCK_METHOD0(HasVideo, bool());
176  MOCK_METHOD1(SetCdm, void(MediaKeys* cdm));
177
178 private:
179  DISALLOW_COPY_AND_ASSIGN(MockRenderer);
180};
181
182class MockTimeSource : public TimeSource {
183 public:
184  MockTimeSource();
185  virtual ~MockTimeSource();
186
187  // TimeSource implementation.
188  MOCK_METHOD0(StartTicking, void());
189  MOCK_METHOD0(StopTicking, void());
190  MOCK_METHOD1(SetPlaybackRate, void(float));
191  MOCK_METHOD1(SetMediaTime, void(base::TimeDelta));
192  MOCK_METHOD0(CurrentMediaTime, base::TimeDelta());
193  MOCK_METHOD0(CurrentMediaTimeForSyncingVideo, base::TimeDelta());
194
195 private:
196  DISALLOW_COPY_AND_ASSIGN(MockTimeSource);
197};
198
199class MockTextTrack : public TextTrack {
200 public:
201  MockTextTrack();
202  virtual ~MockTextTrack();
203
204  MOCK_METHOD5(addWebVTTCue, void(const base::TimeDelta& start,
205                                  const base::TimeDelta& end,
206                                  const std::string& id,
207                                  const std::string& content,
208                                  const std::string& settings));
209
210 private:
211  DISALLOW_COPY_AND_ASSIGN(MockTextTrack);
212};
213
214class MockDecryptor : public Decryptor {
215 public:
216  MockDecryptor();
217  virtual ~MockDecryptor();
218
219  MOCK_METHOD2(RegisterNewKeyCB, void(StreamType stream_type,
220                                      const NewKeyCB& new_key_cb));
221  MOCK_METHOD3(Decrypt, void(StreamType stream_type,
222                             const scoped_refptr<DecoderBuffer>& encrypted,
223                             const DecryptCB& decrypt_cb));
224  MOCK_METHOD1(CancelDecrypt, void(StreamType stream_type));
225  MOCK_METHOD2(InitializeAudioDecoder,
226               void(const AudioDecoderConfig& config,
227                    const DecoderInitCB& init_cb));
228  MOCK_METHOD2(InitializeVideoDecoder,
229               void(const VideoDecoderConfig& config,
230                    const DecoderInitCB& init_cb));
231  MOCK_METHOD2(DecryptAndDecodeAudio,
232               void(const scoped_refptr<media::DecoderBuffer>& encrypted,
233                    const AudioDecodeCB& audio_decode_cb));
234  MOCK_METHOD2(DecryptAndDecodeVideo,
235               void(const scoped_refptr<media::DecoderBuffer>& encrypted,
236                    const VideoDecodeCB& video_decode_cb));
237  MOCK_METHOD1(ResetDecoder, void(StreamType stream_type));
238  MOCK_METHOD1(DeinitializeDecoder, void(StreamType stream_type));
239
240 private:
241  DISALLOW_COPY_AND_ASSIGN(MockDecryptor);
242};
243
244}  // namespace media
245
246#endif  // MEDIA_BASE_MOCK_FILTERS_H_
247