media/base/mock_filters.h

   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
  27 namespace media {
  28
  29 class 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(GetTimelineOffset, base::Time());
  43   MOCK_CONST_METHOD0(GetLiveness, Liveness());
  44
  45  private:
  46   DISALLOW_COPY_AND_ASSIGN(MockDemuxer);
  47 };
  48
  49 class 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   virtual VideoRotation video_rotation() OVERRIDE;
  66
  67  private:
  68   DemuxerStream::Type type_;
  69   AudioDecoderConfig audio_decoder_config_;
  70   VideoDecoderConfig video_decoder_config_;
  71
  72   DISALLOW_COPY_AND_ASSIGN(MockDemuxerStream);
  73 };
  74
  75 class MockVideoDecoder : public VideoDecoder {
  76  public:
  77   MockVideoDecoder();
  78   virtual ~MockVideoDecoder();
  79
  80   // VideoDecoder implementation.
  81   virtual std::string GetDisplayName() const;
  82   MOCK_METHOD4(Initialize, void(const VideoDecoderConfig& config,
  83                                 bool low_delay,
  84                                 const PipelineStatusCB& status_cb,
  85                                 const OutputCB& output_cb));
  86   MOCK_METHOD2(Decode, void(const scoped_refptr<DecoderBuffer>& buffer,
  87                             const DecodeCB&));
  88   MOCK_METHOD1(Reset, void(const base::Closure&));
  89   MOCK_CONST_METHOD0(HasAlpha, bool());
  90
  91  private:
  92   DISALLOW_COPY_AND_ASSIGN(MockVideoDecoder);
  93 };
  94
  95 class MockAudioDecoder : public AudioDecoder {
  96  public:
  97   MockAudioDecoder();
  98   virtual ~MockAudioDecoder();
  99
 100   // AudioDecoder implementation.
 101   virtual std::string GetDisplayName() const;
 102   MOCK_METHOD3(Initialize,
 103                void(const AudioDecoderConfig& config,
 104                     const PipelineStatusCB& status_cb,
 105                     const OutputCB& output_cb));
 106   MOCK_METHOD2(Decode,
 107                void(const scoped_refptr<DecoderBuffer>& buffer,
 108                     const DecodeCB&));
 109   MOCK_METHOD1(Reset, void(const base::Closure&));
 110
 111  private:
 112   DISALLOW_COPY_AND_ASSIGN(MockAudioDecoder);
 113 };
 114
 115 class MockVideoRenderer : public VideoRenderer {
 116  public:
 117   MockVideoRenderer();
 118   virtual ~MockVideoRenderer();
 119
 120   // VideoRenderer implementation.
 121   MOCK_METHOD10(Initialize, void(DemuxerStream* stream,
 122                                  bool low_delay,
 123                                  const PipelineStatusCB& init_cb,
 124                                  const StatisticsCB& statistics_cb,
 125                                  const TimeCB& time_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                                  const TimeDeltaCB& get_duration_cb));
 131   MOCK_METHOD1(Flush, void(const base::Closure& callback));
 132   MOCK_METHOD0(StartPlaying, void());
 133
 134  private:
 135   DISALLOW_COPY_AND_ASSIGN(MockVideoRenderer);
 136 };
 137
 138 class 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 TimeCB& time_cb,
 148                                 const BufferingStateCB& buffering_state_cb,
 149                                 const base::Closure& ended_cb,
 150                                 const PipelineStatusCB& error_cb));
 151   MOCK_METHOD0(GetTimeSource, TimeSource*());
 152   MOCK_METHOD1(Flush, void(const base::Closure& callback));
 153   MOCK_METHOD0(StartPlaying, void());
 154   MOCK_METHOD1(SetVolume, void(float volume));
 155
 156  private:
 157   DISALLOW_COPY_AND_ASSIGN(MockAudioRenderer);
 158 };
 159
 160 class MockRenderer : public Renderer {
 161  public:
 162   MockRenderer();
 163   virtual ~MockRenderer();
 164
 165   // Renderer implementation.
 166   MOCK_METHOD6(Initialize, void(const base::Closure& init_cb,
 167                                 const StatisticsCB& statistics_cb,
 168                                 const base::Closure& ended_cb,
 169                                 const PipelineStatusCB& error_cb,
 170                                 const BufferingStateCB& buffering_state_cb,
 171                                 const TimeDeltaCB& get_duration_cb));
 172   MOCK_METHOD1(Flush, void(const base::Closure& flush_cb));
 173   MOCK_METHOD1(StartPlayingFrom, void(base::TimeDelta timestamp));
 174   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
 175   MOCK_METHOD1(SetVolume, void(float volume));
 176   MOCK_METHOD0(GetMediaTime, base::TimeDelta());
 177   MOCK_METHOD0(HasAudio, bool());
 178   MOCK_METHOD0(HasVideo, bool());
 179   MOCK_METHOD1(SetCdm, void(MediaKeys* cdm));
 180
 181  private:
 182   DISALLOW_COPY_AND_ASSIGN(MockRenderer);
 183 };
 184
 185 class MockTimeSource : public TimeSource {
 186  public:
 187   MockTimeSource();
 188   virtual ~MockTimeSource();
 189
 190   // TimeSource implementation.
 191   MOCK_METHOD0(StartTicking, void());
 192   MOCK_METHOD0(StopTicking, void());
 193   MOCK_METHOD1(SetPlaybackRate, void(float));
 194   MOCK_METHOD1(SetMediaTime, void(base::TimeDelta));
 195   MOCK_METHOD0(CurrentMediaTime, base::TimeDelta());
 196
 197  private:
 198   DISALLOW_COPY_AND_ASSIGN(MockTimeSource);
 199 };
 200
 201 class MockTextTrack : public TextTrack {
 202  public:
 203   MockTextTrack();
 204   virtual ~MockTextTrack();
 205
 206   MOCK_METHOD5(addWebVTTCue, void(const base::TimeDelta& start,
 207                                   const base::TimeDelta& end,
 208                                   const std::string& id,
 209                                   const std::string& content,
 210                                   const std::string& settings));
 211
 212  private:
 213   DISALLOW_COPY_AND_ASSIGN(MockTextTrack);
 214 };
 215
 216 class MockDecryptor : public Decryptor {
 217  public:
 218   MockDecryptor();
 219   virtual ~MockDecryptor();
 220
 221   MOCK_METHOD2(RegisterNewKeyCB, void(StreamType stream_type,
 222                                       const NewKeyCB& new_key_cb));
 223   MOCK_METHOD3(Decrypt, void(StreamType stream_type,
 224                              const scoped_refptr<DecoderBuffer>& encrypted,
 225                              const DecryptCB& decrypt_cb));
 226   MOCK_METHOD1(CancelDecrypt, void(StreamType stream_type));
 227   MOCK_METHOD2(InitializeAudioDecoder,
 228                void(const AudioDecoderConfig& config,
 229                     const DecoderInitCB& init_cb));
 230   MOCK_METHOD2(InitializeVideoDecoder,
 231                void(const VideoDecoderConfig& config,
 232                     const DecoderInitCB& init_cb));
 233   MOCK_METHOD2(DecryptAndDecodeAudio,
 234                void(const scoped_refptr<media::DecoderBuffer>& encrypted,
 235                     const AudioDecodeCB& audio_decode_cb));
 236   MOCK_METHOD2(DecryptAndDecodeVideo,
 237                void(const scoped_refptr<media::DecoderBuffer>& encrypted,
 238                     const VideoDecodeCB& video_decode_cb));
 239   MOCK_METHOD1(ResetDecoder, void(StreamType stream_type));
 240   MOCK_METHOD1(DeinitializeDecoder, void(StreamType stream_type));
 241
 242  private:
 243   DISALLOW_COPY_AND_ASSIGN(MockDecryptor);
 244 };
 245
 246 // Helper mock statistics callback.
 247 class MockStatisticsCB {
 248  public:
 249   MockStatisticsCB();
 250   ~MockStatisticsCB();
 251
 252   MOCK_METHOD1(OnStatistics, void(const media::PipelineStatistics& statistics));
 253 };
 254
 255 }  // namespace media
 256
 257 #endif  // MEDIA_BASE_MOCK_FILTERS_H_