media/base/test_helpers.cc

   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 #include "media/base/test_helpers.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/pickle.h"
  11 #include "base/run_loop.h"
  12 #include "base/test/test_timeouts.h"
  13 #include "base/time/time.h"
  14 #include "base/timer/timer.h"
  15 #include "media/base/audio_buffer.h"
  16 #include "media/base/bind_to_current_loop.h"
  17 #include "media/base/decoder_buffer.h"
  18 #include "ui/gfx/geometry/rect.h"
  19
  20 using ::testing::_;
  21 using ::testing::StrictMock;
  22
  23 namespace media {
  24
  25 // Utility mock for testing methods expecting Closures and PipelineStatusCBs.
  26 class MockCallback : public base::RefCountedThreadSafe<MockCallback> {
  27  public:
  28   MockCallback();
  29   MOCK_METHOD0(Run, void());
  30   MOCK_METHOD1(RunWithBool, void(bool));
  31   MOCK_METHOD1(RunWithStatus, void(PipelineStatus));
  32
  33  protected:
  34   friend class base::RefCountedThreadSafe<MockCallback>;
  35   virtual ~MockCallback();
  36
  37  private:
  38   DISALLOW_COPY_AND_ASSIGN(MockCallback);
  39 };
  40
  41 MockCallback::MockCallback() {}
  42 MockCallback::~MockCallback() {}
  43
  44 base::Closure NewExpectedClosure() {
  45   StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
  46   EXPECT_CALL(*callback, Run());
  47   return base::Bind(&MockCallback::Run, callback);
  48 }
  49
  50 base::Callback<void(bool)> NewExpectedBoolCB(bool success) {
  51   StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
  52   EXPECT_CALL(*callback, RunWithBool(success));
  53   return base::Bind(&MockCallback::RunWithBool, callback);
  54 }
  55
  56 PipelineStatusCB NewExpectedStatusCB(PipelineStatus status) {
  57   StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
  58   EXPECT_CALL(*callback, RunWithStatus(status));
  59   return base::Bind(&MockCallback::RunWithStatus, callback);
  60 }
  61
  62 WaitableMessageLoopEvent::WaitableMessageLoopEvent()
  63     : message_loop_(base::MessageLoop::current()),
  64       signaled_(false),
  65       status_(PIPELINE_OK) {
  66   DCHECK(message_loop_);
  67 }
  68
  69 WaitableMessageLoopEvent::~WaitableMessageLoopEvent() {}
  70
  71 base::Closure WaitableMessageLoopEvent::GetClosure() {
  72   DCHECK_EQ(message_loop_, base::MessageLoop::current());
  73   return BindToCurrentLoop(base::Bind(
  74       &WaitableMessageLoopEvent::OnCallback, base::Unretained(this),
  75       PIPELINE_OK));
  76 }
  77
  78 PipelineStatusCB WaitableMessageLoopEvent::GetPipelineStatusCB() {
  79   DCHECK_EQ(message_loop_, base::MessageLoop::current());
  80   return BindToCurrentLoop(base::Bind(
  81       &WaitableMessageLoopEvent::OnCallback, base::Unretained(this)));
  82 }
  83
  84 void WaitableMessageLoopEvent::RunAndWait() {
  85   RunAndWaitForStatus(PIPELINE_OK);
  86 }
  87
  88 void WaitableMessageLoopEvent::RunAndWaitForStatus(PipelineStatus expected) {
  89   DCHECK_EQ(message_loop_, base::MessageLoop::current());
  90   if (signaled_) {
  91     EXPECT_EQ(expected, status_);
  92     return;
  93   }
  94
  95   run_loop_.reset(new base::RunLoop());
  96   base::Timer timer(false, false);
  97   timer.Start(FROM_HERE, TestTimeouts::action_timeout(), base::Bind(
  98       &WaitableMessageLoopEvent::OnTimeout, base::Unretained(this)));
  99
 100   run_loop_->Run();
 101   EXPECT_TRUE(signaled_);
 102   EXPECT_EQ(expected, status_);
 103   run_loop_.reset();
 104 }
 105
 106 void WaitableMessageLoopEvent::OnCallback(PipelineStatus status) {
 107   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 108   signaled_ = true;
 109   status_ = status;
 110
 111   // |run_loop_| may be null if the callback fires before RunAndWaitForStatus().
 112   if (run_loop_)
 113     run_loop_->Quit();
 114 }
 115
 116 void WaitableMessageLoopEvent::OnTimeout() {
 117   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 118   ADD_FAILURE() << "Timed out waiting for message loop to quit";
 119   run_loop_->Quit();
 120 }
 121
 122 static VideoDecoderConfig GetTestConfig(VideoCodec codec,
 123                                         gfx::Size coded_size,
 124                                         bool is_encrypted) {
 125   gfx::Rect visible_rect(coded_size.width(), coded_size.height());
 126   gfx::Size natural_size = coded_size;
 127
 128   return VideoDecoderConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN,
 129       VideoFrame::YV12, coded_size, visible_rect, natural_size,
 130       NULL, 0, is_encrypted);
 131 }
 132
 133 static const gfx::Size kNormalSize(320, 240);
 134 static const gfx::Size kLargeSize(640, 480);
 135
 136 VideoDecoderConfig TestVideoConfig::Invalid() {
 137   return GetTestConfig(kUnknownVideoCodec, kNormalSize, false);
 138 }
 139
 140 VideoDecoderConfig TestVideoConfig::Normal() {
 141   return GetTestConfig(kCodecVP8, kNormalSize, false);
 142 }
 143
 144 VideoDecoderConfig TestVideoConfig::NormalEncrypted() {
 145   return GetTestConfig(kCodecVP8, kNormalSize, true);
 146 }
 147
 148 VideoDecoderConfig TestVideoConfig::Large() {
 149   return GetTestConfig(kCodecVP8, kLargeSize, false);
 150 }
 151
 152 VideoDecoderConfig TestVideoConfig::LargeEncrypted() {
 153   return GetTestConfig(kCodecVP8, kLargeSize, true);
 154 }
 155
 156 gfx::Size TestVideoConfig::NormalCodedSize() {
 157   return kNormalSize;
 158 }
 159
 160 gfx::Size TestVideoConfig::LargeCodedSize() {
 161   return kLargeSize;
 162 }
 163
 164 template <class T>
 165 scoped_refptr<AudioBuffer> MakeAudioBuffer(SampleFormat format,
 166                                            ChannelLayout channel_layout,
 167                                            size_t channel_count,
 168                                            int sample_rate,
 169                                            T start,
 170                                            T increment,
 171                                            size_t frames,
 172                                            base::TimeDelta timestamp) {
 173   const size_t channels = ChannelLayoutToChannelCount(channel_layout);
 174   scoped_refptr<AudioBuffer> output =
 175       AudioBuffer::CreateBuffer(format,
 176                                 channel_layout,
 177                                 static_cast<int>(channel_count),
 178                                 sample_rate,
 179                                 static_cast<int>(frames));
 180   output->set_timestamp(timestamp);
 181
 182   const bool is_planar =
 183       format == kSampleFormatPlanarS16 || format == kSampleFormatPlanarF32;
 184
 185   // Values in channel 0 will be:
 186   //   start
 187   //   start + increment
 188   //   start + 2 * increment, ...
 189   // While, values in channel 1 will be:
 190   //   start + frames * increment
 191   //   start + (frames + 1) * increment
 192   //   start + (frames + 2) * increment, ...
 193   for (size_t ch = 0; ch < channels; ++ch) {
 194     T* buffer =
 195         reinterpret_cast<T*>(output->channel_data()[is_planar ? ch : 0]);
 196     const T v = static_cast<T>(start + ch * frames * increment);
 197     for (size_t i = 0; i < frames; ++i) {
 198       buffer[is_planar ? i : ch + i * channels] =
 199           static_cast<T>(v + i * increment);
 200     }
 201   }
 202   return output;
 203 }
 204
 205 // Instantiate all the types of MakeAudioBuffer() and
 206 // MakeAudioBuffer() needed.
 207 #define DEFINE_MAKE_AUDIO_BUFFER_INSTANCE(type)              \
 208   template scoped_refptr<AudioBuffer> MakeAudioBuffer<type>( \
 209       SampleFormat format,                                   \
 210       ChannelLayout channel_layout,                          \
 211       size_t channel_count,                                  \
 212       int sample_rate,                                       \
 213       type start,                                            \
 214       type increment,                                        \
 215       size_t frames,                                         \
 216       base::TimeDelta start_time)
 217 DEFINE_MAKE_AUDIO_BUFFER_INSTANCE(uint8);
 218 DEFINE_MAKE_AUDIO_BUFFER_INSTANCE(int16);
 219 DEFINE_MAKE_AUDIO_BUFFER_INSTANCE(int32);
 220 DEFINE_MAKE_AUDIO_BUFFER_INSTANCE(float);
 221
 222 static const char kFakeVideoBufferHeader[] = "FakeVideoBufferForTest";
 223
 224 scoped_refptr<DecoderBuffer> CreateFakeVideoBufferForTest(
 225     const VideoDecoderConfig& config,
 226     base::TimeDelta timestamp, base::TimeDelta duration) {
 227   base::Pickle pickle;
 228   pickle.WriteString(kFakeVideoBufferHeader);
 229   pickle.WriteInt(config.coded_size().width());
 230   pickle.WriteInt(config.coded_size().height());
 231   pickle.WriteInt64(timestamp.InMilliseconds());
 232
 233   scoped_refptr<DecoderBuffer> buffer = DecoderBuffer::CopyFrom(
 234       static_cast<const uint8*>(pickle.data()),
 235       static_cast<int>(pickle.size()));
 236   buffer->set_timestamp(timestamp);
 237   buffer->set_duration(duration);
 238   buffer->set_is_key_frame(true);
 239
 240   return buffer;
 241 }
 242
 243 bool VerifyFakeVideoBufferForTest(
 244     const scoped_refptr<DecoderBuffer>& buffer,
 245     const VideoDecoderConfig& config) {
 246   // Check if the input |buffer| matches the |config|.
 247   base::PickleIterator pickle(base::Pickle(
 248       reinterpret_cast<const char*>(buffer->data()), buffer->data_size()));
 249   std::string header;
 250   int width = 0;
 251   int height = 0;
 252   bool success = pickle.ReadString(&header) && pickle.ReadInt(&width) &&
 253                  pickle.ReadInt(&height);
 254   return (success && header == kFakeVideoBufferHeader &&
 255           width == config.coded_size().width() &&
 256           height == config.coded_size().height());
 257 }
 258
 259 CallbackPairChecker::CallbackPairChecker() : expecting_b_(false) {
 260 }
 261
 262 CallbackPairChecker::~CallbackPairChecker() {
 263   EXPECT_FALSE(expecting_b_);
 264 }
 265
 266 void CallbackPairChecker::RecordACalled() {
 267   EXPECT_FALSE(expecting_b_);
 268   expecting_b_ = true;
 269 }
 270
 271 void CallbackPairChecker::RecordBCalled() {
 272   EXPECT_TRUE(expecting_b_);
 273   expecting_b_ = false;
 274 }
 275
 276 void AddLogEntryForTest(MediaLog::MediaLogLevel level,
 277                         const std::string& message) {
 278   DVLOG(1) << "Media log (" << MediaLog::MediaLogLevelToString(level)
 279            << "): " << message;
 280 }
 281
 282 }  // namespace media