Introduce VideoConfig/AudioConfig class for CMA backend

chromecast/media/cma/backend/audio_video_pipeline_device_unittest.cc

 // Copyright 2014 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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "chromecast/media/base/decrypt_context.h"
 #include "chromecast/media/cma/backend/audio_pipeline_device.h"
 #include "chromecast/media/cma/backend/media_clock_device.h"
 #include "chromecast/media/cma/backend/media_pipeline_device.h"
 #include "chromecast/media/cma/backend/media_pipeline_device_params.h"
 #include "chromecast/media/cma/backend/video_pipeline_device.h"
 #include "chromecast/media/cma/base/decoder_buffer_adapter.h"
 #include "chromecast/media/cma/base/decoder_buffer_base.h"
+#include "chromecast/media/cma/base/decoder_config_adapter.h"
 #include "chromecast/media/cma/test/frame_segmenter_for_test.h"
 #include "chromecast/media/cma/test/media_component_device_feeder_for_test.h"
+#include "chromecast/public/media/decoder_config.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/buffers.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
@@ skipping 107 matching lines @@
 }
 
 void AudioVideoPipelineDeviceTest::LoadAudioStream(std::string filename) {
   base::FilePath file_path = GetTestDataFilePath(filename);
   DemuxResult demux_result = FFmpegDemuxForTest(file_path, true /* audio */);
   BufferList frames = demux_result.frames;
 
   AudioPipelineDevice* audio_pipeline_device =
       media_pipeline_device_->GetAudioPipelineDevice();
 
-  bool success = audio_pipeline_device->SetConfig(demux_result.audio_config);
+  bool success = audio_pipeline_device->SetConfig(
+      DecoderConfigAdapter::ToAudioConfig(demux_result.audio_config));
   ASSERT_TRUE(success);
 
   VLOG(2) << "Got " << frames.size() << " audio input frames";
 
   frames.push_back(
       scoped_refptr<DecoderBufferBase>(
           new DecoderBufferAdapter(::media::DecoderBuffer::CreateEOSBuffer())));
 
   MediaComponentDeviceFeederForTest* device_feeder =
       new MediaComponentDeviceFeederForTest(audio_pipeline_device, frames);
   device_feeder->Initialize(base::Bind(&AudioVideoPipelineDeviceTest::OnEos,
                                        base::Unretained(this),
                                        device_feeder));
   component_device_feeders_.push_back(device_feeder);
 }
 
 void AudioVideoPipelineDeviceTest::LoadVideoStream(std::string filename,
                                                    bool raw_h264) {
   BufferList frames;
-  ::media::VideoDecoderConfig video_config;
+  VideoConfig video_config;
 
   if (raw_h264) {
     base::FilePath file_path = GetTestDataFilePath(filename);
     base::MemoryMappedFile video_stream;
     ASSERT_TRUE(video_stream.Initialize(file_path))
         << "Couldn't open stream file: " << file_path.MaybeAsASCII();
     frames = H264SegmenterForTest(video_stream.data(), video_stream.length());
 
-    // Use arbitraty sizes.
-    gfx::Size coded_size(320, 240);
-    gfx::Rect visible_rect(0, 0, 320, 240);
-    gfx::Size natural_size(320, 240);
-
-    // TODO(kjoswiak): Either pull data from stream or make caller specify value
-    video_config = ::media::VideoDecoderConfig(
-        ::media::kCodecH264,
-        ::media::H264PROFILE_MAIN,
-        ::media::VideoFrame::I420,
-        coded_size,
-        visible_rect,
-        natural_size,
-        NULL, 0, false);
+    // TODO(erickung): Either pull data from stream or make caller specify value
+    video_config.codec = kCodecH264;
+    video_config.profile = kH264Main;
+    video_config.additional_config = NULL;
+    video_config.is_encrypted = false;
   } else {
     base::FilePath file_path = GetTestDataFilePath(filename);
     DemuxResult demux_result = FFmpegDemuxForTest(file_path,
                                                   /*audio*/ false);
     frames = demux_result.frames;
-    video_config = demux_result.video_config;
+    video_config =
+        DecoderConfigAdapter::ToVideoConfig(demux_result.video_config);
   }
 
   VideoPipelineDevice* video_pipeline_device =
       media_pipeline_device_->GetVideoPipelineDevice();
 
   // Set configuration.
   bool success = video_pipeline_device->SetConfig(video_config);
   ASSERT_TRUE(success);
 
   VLOG(2) << "Got " << frames.size() << " video input frames";
@@ skipping 161 matching lines @@
 TEST_F(AudioVideoPipelineDeviceTest, WebmPlayback) {
   scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   ConfigureForFile("bear-640x360.webm");
   Start();
   message_loop->Run();
 }
 
 }  // namespace media
 }  // namespace chromecast