Introduce VideoConfig/AudioConfig class for CMA backend

chromecast/media/cma/backend/media_pipeline_device_fake.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 "chromecast/media/cma/backend/media_pipeline_device_fake.h"
 
 #include <list>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop_proxy.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_component_device.h"
 #include "chromecast/media/cma/backend/video_pipeline_device.h"
 #include "chromecast/media/cma/base/decoder_buffer_base.h"
-#include "media/base/audio_decoder_config.h"
+#include "chromecast/public/media/decoder_config.h"
 #include "media/base/buffers.h"
-#include "media/base/video_decoder_config.h"
 
 namespace chromecast {
 namespace media {
 
 class MediaClockDeviceFake : public MediaClockDevice {
  public:
   MediaClockDeviceFake();
   ~MediaClockDeviceFake() override;
 
   // MediaClockDevice implementation.
@@ skipping 331 matching lines @@
   void SetClient(const Client& client) override;
   State GetState() const override;
   bool SetState(State new_state) override;
   bool SetStartPts(base::TimeDelta time) override;
   FrameStatus PushFrame(
       const scoped_refptr<DecryptContext>& decrypt_context,
       const scoped_refptr<DecoderBufferBase>& buffer,
       const FrameStatusCB& completion_cb) override;
   base::TimeDelta GetRenderingTime() const override;
   base::TimeDelta GetRenderingDelay() const override;
-  bool SetConfig(const ::media::AudioDecoderConfig& config) override;
+  bool SetConfig(const AudioConfig& config) override;
   void SetStreamVolumeMultiplier(float multiplier) override;
   bool GetStatistics(Statistics* stats) const override;
 
  private:
   scoped_ptr<MediaComponentDeviceFake> fake_pipeline_;
 
-  ::media::AudioDecoderConfig config_;
+  AudioConfig config_;
+  std::vector<uint8_t> config_extra_data_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioPipelineDeviceFake);
 };
 
 AudioPipelineDeviceFake::AudioPipelineDeviceFake(
     MediaClockDeviceFake* media_clock_device)
   : fake_pipeline_(new MediaComponentDeviceFake(media_clock_device)) {
   DetachFromThread();
 }
 
 AudioPipelineDeviceFake::~AudioPipelineDeviceFake() {
 }
 
 void AudioPipelineDeviceFake::SetClient(const Client& client) {
   fake_pipeline_->SetClient(client);
 }
 
 MediaComponentDevice::State AudioPipelineDeviceFake::GetState() const {
   return fake_pipeline_->GetState();
 }
 
 bool AudioPipelineDeviceFake::SetState(State new_state) {
   bool success = fake_pipeline_->SetState(new_state);
   if (!success)
     return false;
 
   if (new_state == kStateIdle) {
-    DCHECK(config_.IsValidConfig());
+    DCHECK(IsValidConfig(config_));
   }
   if (new_state == kStateUninitialized) {
-    config_ = ::media::AudioDecoderConfig();
+    config_ = AudioConfig();
   }
   return true;
 }
 
 bool AudioPipelineDeviceFake::SetStartPts(base::TimeDelta time) {
   return fake_pipeline_->SetStartPts(time);
 }
 
 MediaComponentDevice::FrameStatus AudioPipelineDeviceFake::PushFrame(
     const scoped_refptr<DecryptContext>& decrypt_context,
     const scoped_refptr<DecoderBufferBase>& buffer,
     const FrameStatusCB& completion_cb) {
   return fake_pipeline_->PushFrame(decrypt_context, buffer, completion_cb);
 }
 
 base::TimeDelta AudioPipelineDeviceFake::GetRenderingTime() const {
   return fake_pipeline_->GetRenderingTime();
 }
 
 base::TimeDelta AudioPipelineDeviceFake::GetRenderingDelay() const {
   return fake_pipeline_->GetRenderingDelay();
 }
 
-bool AudioPipelineDeviceFake::SetConfig(
-    const ::media::AudioDecoderConfig& config) {
+bool AudioPipelineDeviceFake::SetConfig(const AudioConfig& config) {
   DCHECK(CalledOnValidThread());
-  if (!config.IsValidConfig())
+  if (!IsValidConfig(config))
     return false;
   config_ = config;
+  if (config.extra_data_size > 0)
+    config_extra_data_.assign(config.extra_data,
+                              config.extra_data + config.extra_data_size);
+  else
+    config_extra_data_.clear();
   return true;
 }
 
 void AudioPipelineDeviceFake::SetStreamVolumeMultiplier(float multiplier) {
   DCHECK(CalledOnValidThread());
 }
 
 bool AudioPipelineDeviceFake::GetStatistics(Statistics* stats) const {
   return fake_pipeline_->GetStatistics(stats);
 }
 
 
 class VideoPipelineDeviceFake : public VideoPipelineDevice {
  public:
   explicit VideoPipelineDeviceFake(MediaClockDeviceFake* media_clock_device);
   ~VideoPipelineDeviceFake() override;
 
   // VideoPipelineDevice implementation.
   void SetClient(const Client& client) override;
   State GetState() const override;
   bool SetState(State new_state) override;
   bool SetStartPts(base::TimeDelta time) override;
   FrameStatus PushFrame(
       const scoped_refptr<DecryptContext>& decrypt_context,
       const scoped_refptr<DecoderBufferBase>& buffer,
       const FrameStatusCB& completion_cb) override;
   base::TimeDelta GetRenderingTime() const override;
   base::TimeDelta GetRenderingDelay() const override;
   void SetVideoClient(const VideoClient& client) override;
-  bool SetConfig(const ::media::VideoDecoderConfig& config) override;
+  bool SetConfig(const VideoConfig& config) override;
   bool GetStatistics(Statistics* stats) const override;
 
  private:
   scoped_ptr<MediaComponentDeviceFake> fake_pipeline_;
 
-  ::media::VideoDecoderConfig config_;
+  VideoConfig config_;
+  std::vector<uint8_t> config_extra_data_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoPipelineDeviceFake);
 };
 
 VideoPipelineDeviceFake::VideoPipelineDeviceFake(
     MediaClockDeviceFake* media_clock_device)
   : fake_pipeline_(new MediaComponentDeviceFake(media_clock_device)) {
   DetachFromThread();
 }
 
 VideoPipelineDeviceFake::~VideoPipelineDeviceFake() {
 }
 
 void VideoPipelineDeviceFake::SetClient(const Client& client) {
   fake_pipeline_->SetClient(client);
 }
 
 MediaComponentDevice::State VideoPipelineDeviceFake::GetState() const {
   return fake_pipeline_->GetState();
 }
 
 bool VideoPipelineDeviceFake::SetState(State new_state) {
   bool success = fake_pipeline_->SetState(new_state);
   if (!success)
     return false;
 
   if (new_state == kStateIdle) {
-    DCHECK(config_.IsValidConfig());
+    DCHECK(IsValidConfig(config_));
   }
   if (new_state == kStateUninitialized) {
-    config_ = ::media::VideoDecoderConfig();
+    config_ = VideoConfig();
   }
   return true;
 }
 
 bool VideoPipelineDeviceFake::SetStartPts(base::TimeDelta time) {
   return fake_pipeline_->SetStartPts(time);
 }
 
 MediaComponentDevice::FrameStatus VideoPipelineDeviceFake::PushFrame(
     const scoped_refptr<DecryptContext>& decrypt_context,
     const scoped_refptr<DecoderBufferBase>& buffer,
     const FrameStatusCB& completion_cb) {
   return fake_pipeline_->PushFrame(decrypt_context, buffer, completion_cb);
 }
 
 base::TimeDelta VideoPipelineDeviceFake::GetRenderingTime() const {
   return fake_pipeline_->GetRenderingTime();
 }
 
 base::TimeDelta VideoPipelineDeviceFake::GetRenderingDelay() const {
   return fake_pipeline_->GetRenderingDelay();
 }
 
 void VideoPipelineDeviceFake::SetVideoClient(const VideoClient& client) {
 }
 
-bool VideoPipelineDeviceFake::SetConfig(
-    const ::media::VideoDecoderConfig& config) {
+bool VideoPipelineDeviceFake::SetConfig(const VideoConfig& config) {
   DCHECK(CalledOnValidThread());
-  if (!config.IsValidConfig())
+  if (!IsValidConfig(config))
     return false;
   config_ = config;
+  if (config.extra_data_size > 0)
+    config_extra_data_.assign(config.extra_data,
+                              config.extra_data + config.extra_data_size);
+  else
+    config_extra_data_.clear();
   return true;
 }
 
 bool VideoPipelineDeviceFake::GetStatistics(Statistics* stats) const {
   return fake_pipeline_->GetStatistics(stats);
 }
 
 
 MediaPipelineDeviceFake::MediaPipelineDeviceFake()
     : media_clock_device_(new MediaClockDeviceFake()),
@@ skipping 13 matching lines @@
 VideoPipelineDevice* MediaPipelineDeviceFake::GetVideoPipelineDevice() const {
   return video_pipeline_device_.get();
 }
 
 MediaClockDevice* MediaPipelineDeviceFake::GetMediaClockDevice() const {
   return media_clock_device_.get();
 }
 
 }  // namespace media
 }  // namespace chromecast