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_TEST_HELPERS_H_
      6 #define MEDIA_BASE_TEST_HELPERS_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/callback.h"
     10 #include "media/base/channel_layout.h"
     11 #include "media/base/pipeline_status.h"
     12 #include "media/base/sample_format.h"
     13 #include "media/base/video_decoder_config.h"
     14 #include "testing/gmock/include/gmock/gmock.h"
     15 #include "ui/gfx/size.h"
     16 
     17 namespace base {
     18 class MessageLoop;
     19 class TimeDelta;
     20 }
     21 
     22 namespace media {
     23 
     24 class AudioBuffer;
     25 class DecoderBuffer;
     26 
     27 // Return a callback that expects to be run once.
     28 base::Closure NewExpectedClosure();
     29 PipelineStatusCB NewExpectedStatusCB(PipelineStatus status);
     30 
     31 // Helper class for running a message loop until a callback has run. Useful for
     32 // testing classes that run on more than a single thread.
     33 //
     34 // Events are intended for single use and cannot be reset.
     35 class WaitableMessageLoopEvent {
     36  public:
     37   WaitableMessageLoopEvent();
     38   ~WaitableMessageLoopEvent();
     39 
     40   // Returns a thread-safe closure that will signal |this| when executed.
     41   base::Closure GetClosure();
     42   PipelineStatusCB GetPipelineStatusCB();
     43 
     44   // Runs the current message loop until |this| has been signaled.
     45   //
     46   // Fails the test if the timeout is reached.
     47   void RunAndWait();
     48 
     49   // Runs the current message loop until |this| has been signaled and asserts
     50   // that the |expected| status was received.
     51   //
     52   // Fails the test if the timeout is reached.
     53   void RunAndWaitForStatus(PipelineStatus expected);
     54 
     55  private:
     56   void OnCallback(PipelineStatus status);
     57   void OnTimeout();
     58 
     59   base::MessageLoop* message_loop_;
     60   bool signaled_;
     61   PipelineStatus status_;
     62 
     63   DISALLOW_COPY_AND_ASSIGN(WaitableMessageLoopEvent);
     64 };
     65 
     66 // Provides pre-canned VideoDecoderConfig. These types are used for tests that
     67 // don't care about detailed parameters of the config.
     68 class TestVideoConfig {
     69  public:
     70   // Returns a configuration that is invalid.
     71   static VideoDecoderConfig Invalid();
     72 
     73   static VideoDecoderConfig Normal();
     74   static VideoDecoderConfig NormalEncrypted();
     75 
     76   // Returns a configuration that is larger in dimensions than Normal().
     77   static VideoDecoderConfig Large();
     78   static VideoDecoderConfig LargeEncrypted();
     79 
     80   // Returns coded size for Normal and Large config.
     81   static gfx::Size NormalCodedSize();
     82   static gfx::Size LargeCodedSize();
     83 
     84  private:
     85   DISALLOW_IMPLICIT_CONSTRUCTORS(TestVideoConfig);
     86 };
     87 
     88 // Create an AudioBuffer containing |frames| frames of data, where each sample
     89 // is of type T.  |start| and |increment| are used to specify the values for the
     90 // samples, which are created in channel order.  The value for frame and channel
     91 // is determined by:
     92 //
     93 //   |start| + |channel| * |frames| * |increment| + index * |increment|
     94 //
     95 // E.g., for a stereo buffer the values in channel 0 will be:
     96 //   start
     97 //   start + increment
     98 //   start + 2 * increment, ...
     99 //
    100 // While, values in channel 1 will be:
    101 //   start + frames * increment
    102 //   start + (frames + 1) * increment
    103 //   start + (frames + 2) * increment, ...
    104 //
    105 // |start_time| will be used as the start time for the samples.
    106 template <class T>
    107 scoped_refptr<AudioBuffer> MakeAudioBuffer(SampleFormat format,
    108                                            ChannelLayout channel_layout,
    109                                            size_t channel_count,
    110                                            int sample_rate,
    111                                            T start,
    112                                            T increment,
    113                                            size_t frames,
    114                                            base::TimeDelta timestamp);
    115 
    116 // Create a fake video DecoderBuffer for testing purpose. The buffer contains
    117 // part of video decoder config info embedded so that the testing code can do
    118 // some sanity check.
    119 scoped_refptr<DecoderBuffer> CreateFakeVideoBufferForTest(
    120     const VideoDecoderConfig& config,
    121     base::TimeDelta timestamp,
    122     base::TimeDelta duration);
    123 
    124 // Verify if a fake video DecoderBuffer is valid.
    125 bool VerifyFakeVideoBufferForTest(const scoped_refptr<DecoderBuffer>& buffer,
    126                                   const VideoDecoderConfig& config);
    127 
    128 // Used to verify that the each call to A() is followed by a call to B(),
    129 // before the next call to A(). There may be any number of pairs (including 0).
    130 class CallbackPairChecker {
    131  public:
    132   CallbackPairChecker();
    133   ~CallbackPairChecker();
    134   void RecordACalled();
    135   void RecordBCalled();
    136 
    137  private:
    138   bool expecting_b_;
    139 };
    140 
    141 }  // namespace media
    142 
    143 #endif  // MEDIA_BASE_TEST_HELPERS_H_
    144