Chromecast: Use std::vector to pass video config in CMA

chromecast/renderer/media/video_pipeline_proxy.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/renderer/media/video_pipeline_proxy.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 38 matching lines @@
   // TODO(erickung): either send an IPC message or write a byte on the
   // SyncSocket.
   void NotifyPipeWrite();
 
   // These functions are almost a one to one correspondence with VideoPipeline
   // but this is an internal class and there is no reason to derive from
   // VideoPipeline.
   void SetClient(const base::Closure& pipe_read_cb,
                  const VideoPipelineClient& client);
   void CreateAvPipe(const SharedMemCB& shared_mem_cb);
-  void Initialize(const ::media::VideoDecoderConfig& config,
+  void Initialize(const std::vector<::media::VideoDecoderConfig>& configs,
                   const ::media::PipelineStatusCB& status_cb);
 
  private:
   void Shutdown();
 
   // Callbacks for CmaMessageFilterHost::VideoDelegate.
   void OnAvPipeCreated(bool status,
                        base::SharedMemoryHandle shared_mem_handle,
                        base::FileDescriptor socket);
   void OnStateChanged(::media::PipelineStatus status);
@@ skipping 89 matching lines @@
     shared_mem_cb_.Run(scoped_ptr<base::SharedMemory>());
     return;
   }
 
   CHECK(base::SharedMemory::IsHandleValid(shared_mem_handle));
   shared_mem_cb_.Run(scoped_ptr<base::SharedMemory>(
       new base::SharedMemory(shared_mem_handle, false)));
 }
 
 void VideoPipelineProxyInternal::Initialize(
-    const ::media::VideoDecoderConfig& arg1,
+    const std::vector<::media::VideoDecoderConfig>& configs,
     const ::media::PipelineStatusCB& status_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   bool success = media_channel_proxy_->Send(scoped_ptr<IPC::Message>(
       new CmaHostMsg_VideoInitialize(media_channel_proxy_->GetId(),
-                                     kVideoTrackId, arg1)));
+                                     kVideoTrackId, configs)));
   if (!success) {
     status_cb.Run( ::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
   DCHECK(status_cb_.is_null());
   status_cb_ = status_cb;
 }
 
 void VideoPipelineProxyInternal::OnStateChanged(
     ::media::PipelineStatus status) {
@@ skipping 31 matching lines @@
 void VideoPipelineProxy::SetClient(
     const VideoPipelineClient& video_client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::Closure pipe_read_cb =
       ::media::BindToCurrentLoop(
           base::Bind(&VideoPipelineProxy::OnPipeRead, weak_this_));
   FORWARD_ON_IO_THREAD(SetClient, pipe_read_cb, video_client);
 }
 
 void VideoPipelineProxy::Initialize(
-    const ::media::VideoDecoderConfig& config,
+    const std::vector<::media::VideoDecoderConfig>& configs,
     scoped_ptr<CodedFrameProvider> frame_provider,
     const ::media::PipelineStatusCB& status_cb) {
   CMALOG(kLogControl) << "VideoPipelineProxy::Initialize";
   DCHECK(thread_checker_.CalledOnValidThread());
   video_streamer_->SetCodedFrameProvider(frame_provider.Pass());
 
   VideoPipelineProxyInternal::SharedMemCB shared_mem_cb =
       ::media::BindToCurrentLoop(base::Bind(
           &VideoPipelineProxy::OnAvPipeCreated, weak_this_,
-          config, status_cb));
+          configs, status_cb));
   FORWARD_ON_IO_THREAD(CreateAvPipe, shared_mem_cb);
 }
 
 void VideoPipelineProxy::OnAvPipeCreated(
-    const ::media::VideoDecoderConfig& config,
+    const std::vector<::media::VideoDecoderConfig>& configs,
     const ::media::PipelineStatusCB& status_cb,
     scoped_ptr<base::SharedMemory> shared_memory) {
   CMALOG(kLogControl) << "VideoPipelineProxy::OnAvPipeCreated";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!shared_memory ||
       !shared_memory->Map(kAppVideoBufferSize)) {
     status_cb.Run(::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
   CHECK(shared_memory->memory());
 
   scoped_ptr<MediaMemoryChunk> shared_memory_chunk(
       new SharedMemoryChunk(shared_memory.Pass(), kAppVideoBufferSize));
   scoped_ptr<MediaMessageFifo> video_pipe(
       new MediaMessageFifo(shared_memory_chunk.Pass(), false));
   video_pipe->ObserveWriteActivity(
       base::Bind(&VideoPipelineProxy::OnPipeWrite, weak_this_));
 
   video_streamer_->SetMediaMessageFifo(video_pipe.Pass());
 
   // Now proceed to the decoder/renderer initialization.
-  FORWARD_ON_IO_THREAD(Initialize, config, status_cb);
+  FORWARD_ON_IO_THREAD(Initialize, configs, status_cb);
 }
 
 void VideoPipelineProxy::StartFeeding() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(video_streamer_);
   video_streamer_->Start();
 }
 
 void VideoPipelineProxy::Flush(const base::Closure& done_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 14 matching lines @@
 }
 
 void VideoPipelineProxy::OnPipeRead() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (video_streamer_)
     video_streamer_->OnFifoReadEvent();
 }
 
 }  // namespace media
 }  // namespace chromecast