Home | History | Annotate | Download | only in base
      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/video_decoder.h"
     20 #include "media/base/video_decoder_config.h"
     21 #include "media/base/video_frame.h"
     22 #include "media/base/video_renderer.h"
     23 #include "testing/gmock/include/gmock/gmock.h"
     24 
     25 namespace media {
     26 
     27 class MockDemuxer : public Demuxer {
     28  public:
     29   MockDemuxer();
     30   virtual ~MockDemuxer();
     31 
     32   // Demuxer implementation.
     33   MOCK_METHOD2(Initialize, void(DemuxerHost* host, const PipelineStatusCB& cb));
     34   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
     35   MOCK_METHOD2(Seek, void(base::TimeDelta time, const PipelineStatusCB& cb));
     36   MOCK_METHOD1(Stop, void(const base::Closure& callback));
     37   MOCK_METHOD0(OnAudioRendererDisabled, void());
     38   MOCK_METHOD1(GetStream, DemuxerStream*(DemuxerStream::Type));
     39   MOCK_CONST_METHOD0(GetStartTime, base::TimeDelta());
     40 
     41  private:
     42   DISALLOW_COPY_AND_ASSIGN(MockDemuxer);
     43 };
     44 
     45 class MockDemuxerStream : public DemuxerStream {
     46  public:
     47   explicit MockDemuxerStream(DemuxerStream::Type type);
     48   virtual ~MockDemuxerStream();
     49 
     50   // DemuxerStream implementation.
     51   virtual Type type() OVERRIDE;
     52   MOCK_METHOD1(Read, void(const ReadCB& read_cb));
     53   virtual AudioDecoderConfig audio_decoder_config() OVERRIDE;
     54   virtual VideoDecoderConfig video_decoder_config() OVERRIDE;
     55   MOCK_METHOD0(EnableBitstreamConverter, void());
     56 
     57   void set_audio_decoder_config(const AudioDecoderConfig& config);
     58   void set_video_decoder_config(const VideoDecoderConfig& config);
     59 
     60  private:
     61   DemuxerStream::Type type_;
     62   AudioDecoderConfig audio_decoder_config_;
     63   VideoDecoderConfig video_decoder_config_;
     64 
     65   DISALLOW_COPY_AND_ASSIGN(MockDemuxerStream);
     66 };
     67 
     68 class MockVideoDecoder : public VideoDecoder {
     69  public:
     70   MockVideoDecoder();
     71   virtual ~MockVideoDecoder();
     72 
     73   // VideoDecoder implementation.
     74   MOCK_METHOD2(Initialize, void(const VideoDecoderConfig& config,
     75                                 const PipelineStatusCB&));
     76   MOCK_METHOD2(Decode, void(const scoped_refptr<DecoderBuffer>& buffer,
     77                             const DecodeCB&));
     78   MOCK_METHOD1(Reset, void(const base::Closure&));
     79   MOCK_METHOD1(Stop, void(const base::Closure&));
     80   MOCK_CONST_METHOD0(HasAlpha, bool());
     81 
     82  private:
     83   DISALLOW_COPY_AND_ASSIGN(MockVideoDecoder);
     84 };
     85 
     86 class MockAudioDecoder : public AudioDecoder {
     87  public:
     88   MockAudioDecoder();
     89   virtual ~MockAudioDecoder();
     90 
     91   // AudioDecoder implementation.
     92   MOCK_METHOD3(Initialize, void(DemuxerStream*,
     93                                 const PipelineStatusCB&,
     94                                 const StatisticsCB&));
     95   MOCK_METHOD1(Read, void(const ReadCB&));
     96   MOCK_METHOD0(bits_per_channel, int(void));
     97   MOCK_METHOD0(channel_layout, ChannelLayout(void));
     98   MOCK_METHOD0(samples_per_second, int(void));
     99   MOCK_METHOD1(Reset, void(const base::Closure&));
    100 
    101  private:
    102   DISALLOW_COPY_AND_ASSIGN(MockAudioDecoder);
    103 };
    104 
    105 class MockVideoRenderer : public VideoRenderer {
    106  public:
    107   MockVideoRenderer();
    108   virtual ~MockVideoRenderer();
    109 
    110   // VideoRenderer implementation.
    111   MOCK_METHOD9(Initialize, void(DemuxerStream* stream,
    112                                 const PipelineStatusCB& init_cb,
    113                                 const StatisticsCB& statistics_cb,
    114                                 const TimeCB& time_cb,
    115                                 const NaturalSizeChangedCB& size_changed_cb,
    116                                 const base::Closure& ended_cb,
    117                                 const PipelineStatusCB& error_cb,
    118                                 const TimeDeltaCB& get_time_cb,
    119                                 const TimeDeltaCB& get_duration_cb));
    120   MOCK_METHOD1(Play, void(const base::Closure& callback));
    121   MOCK_METHOD1(Pause, void(const base::Closure& callback));
    122   MOCK_METHOD1(Flush, void(const base::Closure& callback));
    123   MOCK_METHOD2(Preroll, void(base::TimeDelta time, const PipelineStatusCB& cb));
    124   MOCK_METHOD1(Stop, void(const base::Closure& callback));
    125   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
    126 
    127  private:
    128   DISALLOW_COPY_AND_ASSIGN(MockVideoRenderer);
    129 };
    130 
    131 class MockAudioRenderer : public AudioRenderer {
    132  public:
    133   MockAudioRenderer();
    134   virtual ~MockAudioRenderer();
    135 
    136   // AudioRenderer implementation.
    137   MOCK_METHOD8(Initialize, void(DemuxerStream* stream,
    138                                 const PipelineStatusCB& init_cb,
    139                                 const StatisticsCB& statistics_cb,
    140                                 const base::Closure& underflow_cb,
    141                                 const TimeCB& time_cb,
    142                                 const base::Closure& ended_cb,
    143                                 const base::Closure& disabled_cb,
    144                                 const PipelineStatusCB& error_cb));
    145   MOCK_METHOD1(Play, void(const base::Closure& callback));
    146   MOCK_METHOD1(Pause, void(const base::Closure& callback));
    147   MOCK_METHOD1(Flush, void(const base::Closure& callback));
    148   MOCK_METHOD1(Stop, void(const base::Closure& callback));
    149   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
    150   MOCK_METHOD2(Preroll, void(base::TimeDelta time, const PipelineStatusCB& cb));
    151   MOCK_METHOD1(SetVolume, void(float volume));
    152   MOCK_METHOD0(ResumeAfterUnderflow, void());
    153 
    154  private:
    155   DISALLOW_COPY_AND_ASSIGN(MockAudioRenderer);
    156 };
    157 
    158 class MockDecryptor : public Decryptor {
    159  public:
    160   MockDecryptor();
    161   virtual ~MockDecryptor();
    162 
    163   MOCK_METHOD2(RegisterNewKeyCB, void(StreamType stream_type,
    164                                       const NewKeyCB& new_key_cb));
    165   MOCK_METHOD3(Decrypt, void(StreamType stream_type,
    166                              const scoped_refptr<DecoderBuffer>& encrypted,
    167                              const DecryptCB& decrypt_cb));
    168   MOCK_METHOD1(CancelDecrypt, void(StreamType stream_type));
    169   MOCK_METHOD2(InitializeAudioDecoder,
    170                void(const AudioDecoderConfig& config,
    171                     const DecoderInitCB& init_cb));
    172   MOCK_METHOD2(InitializeVideoDecoder,
    173                void(const VideoDecoderConfig& config,
    174                     const DecoderInitCB& init_cb));
    175   MOCK_METHOD2(DecryptAndDecodeAudio,
    176                void(const scoped_refptr<media::DecoderBuffer>& encrypted,
    177                     const AudioDecodeCB& audio_decode_cb));
    178   MOCK_METHOD2(DecryptAndDecodeVideo,
    179                void(const scoped_refptr<media::DecoderBuffer>& encrypted,
    180                     const VideoDecodeCB& video_decode_cb));
    181   MOCK_METHOD1(ResetDecoder, void(StreamType stream_type));
    182   MOCK_METHOD1(DeinitializeDecoder, void(StreamType stream_type));
    183 
    184  private:
    185   DISALLOW_COPY_AND_ASSIGN(MockDecryptor);
    186 };
    187 
    188 // Helper mock statistics callback.
    189 class MockStatisticsCB {
    190  public:
    191   MockStatisticsCB();
    192   ~MockStatisticsCB();
    193 
    194   MOCK_METHOD1(OnStatistics, void(const media::PipelineStatistics& statistics));
    195 };
    196 
    197 }  // namespace media
    198 
    199 #endif  // MEDIA_BASE_MOCK_FILTERS_H_
    200