Remove DemuxerStream::GetAVStream() once and for all.

media/filters/ffmpeg_video_decoder_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <deque>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/memory/singleton.h"
 #include "base/string_util.h"
 #include "media/base/data_buffer.h"
 #include "media/base/filters.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
 #include "media/base/video_frame.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/video/video_decode_engine.h"
 #include "media/video/video_decode_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::DoAll;
 using ::testing::Message;
 using ::testing::Return;
 using ::testing::ReturnNull;
+using ::testing::ReturnRef;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
 using ::testing::WithArg;
 using ::testing::Invoke;
 
 namespace media {
 
+static const VideoFrame::Format kVideoFormat = VideoFrame::YV12;
 static const gfx::Size kCodedSize(1280, 720);
 static const gfx::Rect kVisibleRect(1280, 720);
 static const gfx::Size kNaturalSize(1280, 720);
+static const AVRational kFrameRate = { 100, 1 };
+static const AVRational kAspectRatio = { 1, 1 };
 
 // Holds timestamp and duration data needed for properly enqueuing a frame.
 struct TimeTuple {
   base::TimeDelta timestamp;
   base::TimeDelta duration;
 };
 
 static const TimeTuple kTestPts1 =
     { base::TimeDelta::FromMicroseconds(123),
       base::TimeDelta::FromMicroseconds(50) };
@@ skipping 78 matching lines @@
 
     // Inject mocks and prepare a demuxer stream.
     decoder_->set_host(&host_);
     decoder_->set_consume_video_frame_callback(
         base::Bind(&MockVideoRenderer::ConsumeVideoFrame,
                    base::Unretained(renderer_.get())));
     decoder_->SetVideoDecodeEngineForTest(engine_);
     demuxer_ = new StrictMock<MockDemuxerStream>();
 
     // Initialize FFmpeg fixtures.
-    memset(&stream_, 0, sizeof(stream_));
-    memset(&codec_context_, 0, sizeof(codec_context_));
-    memset(&codec_, 0, sizeof(codec_));
     memset(&yuv_frame_, 0, sizeof(yuv_frame_));
     base::TimeDelta zero;
     video_frame_ = VideoFrame::CreateFrame(VideoFrame::YV12,
                                            kVisibleRect.width(),
                                            kVisibleRect.height(),
                                            zero, zero);
-    stream_.codec = &codec_context_;
-    codec_context_.width = kVisibleRect.width();
-    codec_context_.height = kVisibleRect.height();
-    codec_context_.codec_id = CODEC_ID_H264;
-    stream_.r_frame_rate.num = 1;
-    stream_.r_frame_rate.den = 1;
     buffer_ = new DataBuffer(1);
     end_of_stream_buffer_ = new DataBuffer(0);
 
     EXPECT_CALL(stats_callback_object_, OnStatistics(_))
         .Times(AnyNumber());
+
+    config_.Initialize(kCodecVP8, kVideoFormat, kCodedSize, kVisibleRect,
+                       kFrameRate.num, kFrameRate.den,
+                       kAspectRatio.num, kAspectRatio.den,
+                       NULL, 0);
   }
 
   virtual ~FFmpegVideoDecoderTest() {
     // The presence of an event handler means we need to uninitialize.
     if (engine_->event_handler_) {
       EXPECT_CALL(*engine_, Uninitialize())
           .WillOnce(EngineUninitialize(engine_));
     }
 
     decoder_->Stop(NewExpectedClosure());
 
     // Finish up any remaining tasks.
     message_loop_.RunAllPending();
   }
 
   void InitializeDecoderSuccessfully() {
-    // Test successful initialization.
-    EXPECT_CALL(*demuxer_, GetAVStream())
-        .WillOnce(Return(&stream_));
+    EXPECT_CALL(*demuxer_, video_decoder_config())
+        .WillOnce(ReturnRef(config_));
 
     EXPECT_CALL(*engine_, Initialize(_, _, _, _))
         .WillOnce(EngineInitialize(engine_, true));
 
     decoder_->Initialize(demuxer_,
                          NewExpectedClosure(), NewStatisticsCallback());
     message_loop_.RunAllPending();
   }
 
   StatisticsCallback NewStatisticsCallback() {
     return base::Bind(&MockStatisticsCallback::OnStatistics,
                       base::Unretained(&stats_callback_object_));
   }
 
   // Fixture members.
   MockVideoDecodeEngine* engine_;  // Owned by |decoder_|.
   scoped_refptr<DecoderPrivateMock> decoder_;
   scoped_refptr<MockVideoRenderer> renderer_;
   scoped_refptr<StrictMock<MockDemuxerStream> > demuxer_;
   scoped_refptr<DataBuffer> buffer_;
   scoped_refptr<DataBuffer> end_of_stream_buffer_;
   MockStatisticsCallback stats_callback_object_;
   StrictMock<MockFilterHost> host_;
   MessageLoop message_loop_;
 
   // FFmpeg fixtures.
-  AVStream stream_;
-  AVCodecContext codec_context_;
-  AVCodec codec_;
   AVFrame yuv_frame_;
   scoped_refptr<VideoFrame> video_frame_;
 
+  VideoDecoderConfig config_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(FFmpegVideoDecoderTest);
 };
 
-TEST_F(FFmpegVideoDecoderTest, Initialize_GetAVStreamFails) {
-  // Test GetAVStream returning NULL.
-  EXPECT_CALL(*demuxer_, GetAVStream())
-      .WillOnce(ReturnNull());
-  EXPECT_CALL(host_, SetError(PIPELINE_ERROR_DECODE));
-
-  decoder_->Initialize(demuxer_,
-                       NewExpectedClosure(), NewStatisticsCallback());
-
-  message_loop_.RunAllPending();
-}
-
 TEST_F(FFmpegVideoDecoderTest, Initialize_EngineFails) {
-  // Test successful initialization.
-  EXPECT_CALL(*demuxer_, GetAVStream())
-      .WillOnce(Return(&stream_));
+  EXPECT_CALL(*demuxer_, video_decoder_config())
+      .WillOnce(ReturnRef(config_));
 
   EXPECT_CALL(*engine_, Initialize(_, _, _, _))
       .WillOnce(EngineInitialize(engine_, false));
 
   EXPECT_CALL(host_, SetError(PIPELINE_ERROR_DECODE));
 
   decoder_->Initialize(demuxer_,
                        NewExpectedClosure(), NewStatisticsCallback());
   message_loop_.RunAllPending();
 }
@@ skipping 166 matching lines @@
     EXPECT_CALL(*engine_, Seek())
         .WillOnce(EngineSeek(engine_));
     decoder_->Seek(kZero, NewExpectedStatusCB(PIPELINE_OK));
 
     EXPECT_TRUE(kZero == decoder_->pts_stream_.current_duration());
     EXPECT_EQ(FFmpegVideoDecoder::kNormal, decoder_->state_);
   }
 }
 
 }  // namespace media