CmaRenderer is dead. Long live MojoRenderer.

chromecast/renderer/media/video_pipeline_proxy.cc

Index: chromecast/renderer/media/video_pipeline_proxy.cc
diff --git a/chromecast/renderer/media/video_pipeline_proxy.cc b/chromecast/renderer/media/video_pipeline_proxy.cc
deleted file mode 100644
index 5d384f0934ad0a37e3ba86f5219f9893041902f1..0000000000000000000000000000000000000000
--- a/chromecast/renderer/media/video_pipeline_proxy.cc
+++ /dev/null
@@ -1,300 +0,0 @@
-// 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 <utility>
-
-#include "base/bind.h"
-#include "base/callback_helpers.h"
-#include "base/macros.h"
-#include "base/memory/shared_memory.h"
-#include "base/message_loop/message_loop.h"
-#include "base/threading/thread_checker.h"
-#include "chromecast/common/media/cma_ipc_common.h"
-#include "chromecast/common/media/cma_messages.h"
-#include "chromecast/common/media/shared_memory_chunk.h"
-#include "chromecast/media/cma/base/buffering_defs.h"
-#include "chromecast/media/cma/base/cma_logging.h"
-#include "chromecast/media/cma/base/coded_frame_provider.h"
-#include "chromecast/media/cma/ipc/media_message_fifo.h"
-#include "chromecast/media/cma/ipc_streamer/av_streamer_proxy.h"
-#include "chromecast/media/cma/pipeline/video_pipeline_client.h"
-#include "chromecast/renderer/media/cma_message_filter_proxy.h"
-#include "chromecast/renderer/media/media_channel_proxy.h"
-#include "media/base/bind_to_current_loop.h"
-#include "media/base/pipeline_status.h"
-
-namespace chromecast {
-namespace media {
-
-namespace {
-
-void IgnoreResult() {
-}
-
-}  // namespace
-
-// VideoPipelineProxyInternal -
-// This class is not thread safe and should run on the same thread
-// as the media channel proxy.
-class VideoPipelineProxyInternal {
- public:
-  typedef base::Callback<void(std::unique_ptr<base::SharedMemory>)> SharedMemCB;
-
-  static void Release(std::unique_ptr<VideoPipelineProxyInternal> proxy);
-
-  explicit VideoPipelineProxyInternal(
-      scoped_refptr<MediaChannelProxy> media_channel_proxy);
-  virtual ~VideoPipelineProxyInternal();
-
-  // Notify the other side (browser process) of some activity on the video pipe.
-  // 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 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);
-
-  base::ThreadChecker thread_checker_;
-
-  scoped_refptr<MediaChannelProxy> media_channel_proxy_;
-
-  // Store the callback for a pending state transition.
-  ::media::PipelineStatusCB status_cb_;
-
-  SharedMemCB shared_mem_cb_;
-
-  DISALLOW_COPY_AND_ASSIGN(VideoPipelineProxyInternal);
-};
-
-// static
-void VideoPipelineProxyInternal::Release(
-    std::unique_ptr<VideoPipelineProxyInternal> proxy) {
-  proxy->Shutdown();
-}
-
-VideoPipelineProxyInternal::VideoPipelineProxyInternal(
-    scoped_refptr<MediaChannelProxy> media_channel_proxy)
-    : media_channel_proxy_(media_channel_proxy) {
-  DCHECK(media_channel_proxy.get());
-
-  // Creation can be done on a different thread.
-  thread_checker_.DetachFromThread();
-}
-
-VideoPipelineProxyInternal::~VideoPipelineProxyInternal() {
-}
-
-void VideoPipelineProxyInternal::Shutdown() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // Remove any callback on VideoPipelineProxyInternal.
-  media_channel_proxy_->SetVideoDelegate(
-      CmaMessageFilterProxy::VideoDelegate());
-}
-
-void VideoPipelineProxyInternal::NotifyPipeWrite() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // TODO(damienv): An alternative way would be to use a dedicated socket for
-  // this event.
-  bool success = media_channel_proxy_->Send(
-      std::unique_ptr<IPC::Message>(new CmaHostMsg_NotifyPipeWrite(
-          media_channel_proxy_->GetId(), kVideoTrackId)));
-  VLOG_IF(4, !success) << "Sending msg failed";
-}
-
-void VideoPipelineProxyInternal::SetClient(
-    const base::Closure& pipe_read_cb,
-    const VideoPipelineClient& video_client) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  CmaMessageFilterProxy::VideoDelegate delegate;
-  delegate.av_pipe_cb =
-      base::Bind(&VideoPipelineProxyInternal::OnAvPipeCreated,
-                 base::Unretained(this));
-  delegate.state_changed_cb =
-      base::Bind(&VideoPipelineProxyInternal::OnStateChanged,
-                 base::Unretained(this));
-  delegate.pipe_read_cb = pipe_read_cb;
-  delegate.client = video_client;
-  bool success = media_channel_proxy_->SetVideoDelegate(delegate);
-  CHECK(success);
-}
-
-void VideoPipelineProxyInternal::CreateAvPipe(
-    const SharedMemCB& shared_mem_cb) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(shared_mem_cb_.is_null());
-  bool success = media_channel_proxy_->Send(
-      std::unique_ptr<IPC::Message>(new CmaHostMsg_CreateAvPipe(
-          media_channel_proxy_->GetId(), kVideoTrackId, kAppVideoBufferSize)));
-  if (!success) {
-    shared_mem_cb.Run(std::unique_ptr<base::SharedMemory>());
-    return;
-  }
-  shared_mem_cb_ = shared_mem_cb;
-}
-
-void VideoPipelineProxyInternal::OnAvPipeCreated(
-    bool success,
-    base::SharedMemoryHandle shared_mem_handle,
-    base::FileDescriptor socket) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!shared_mem_cb_.is_null());
-  if (!success) {
-    shared_mem_cb_.Run(std::unique_ptr<base::SharedMemory>());
-    return;
-  }
-
-  CHECK(base::SharedMemory::IsHandleValid(shared_mem_handle));
-  shared_mem_cb_.Run(std::unique_ptr<base::SharedMemory>(
-      new base::SharedMemory(shared_mem_handle, false)));
-}
-
-void VideoPipelineProxyInternal::Initialize(
-    const std::vector<::media::VideoDecoderConfig>& configs,
-    const ::media::PipelineStatusCB& status_cb) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  bool success = media_channel_proxy_->Send(
-      std::unique_ptr<IPC::Message>(new CmaHostMsg_VideoInitialize(
-          media_channel_proxy_->GetId(), 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) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!status_cb_.is_null());
-  base::ResetAndReturn(&status_cb_).Run(status);
-}
-
-// A macro runs current member function on |io_task_runner_| thread.
-#define FORWARD_ON_IO_THREAD(param_fn, ...)                        \
-  io_task_runner_->PostTask(                                       \
-      FROM_HERE, base::Bind(&VideoPipelineProxyInternal::param_fn, \
-                            base::Unretained(proxy_.get()), ##__VA_ARGS__))
-
-VideoPipelineProxy::VideoPipelineProxy(
-    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-    scoped_refptr<MediaChannelProxy> media_channel_proxy)
-    : io_task_runner_(io_task_runner),
-      proxy_(new VideoPipelineProxyInternal(media_channel_proxy)),
-      video_streamer_(new AvStreamerProxy()),
-      weak_factory_(this) {
-  DCHECK(io_task_runner_.get());
-  weak_this_ = weak_factory_.GetWeakPtr();
-  thread_checker_.DetachFromThread();
-}
-
-VideoPipelineProxy::~VideoPipelineProxy() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  // Release the underlying object on the right thread.
-  io_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoPipelineProxyInternal::Release, base::Passed(&proxy_)));
-}
-
-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 std::vector<::media::VideoDecoderConfig>& configs,
-    std::unique_ptr<CodedFrameProvider> frame_provider,
-    const ::media::PipelineStatusCB& status_cb) {
-  CMALOG(kLogControl) << "VideoPipelineProxy::Initialize";
-  DCHECK(thread_checker_.CalledOnValidThread());
-  video_streamer_->SetCodedFrameProvider(std::move(frame_provider));
-
-  VideoPipelineProxyInternal::SharedMemCB shared_mem_cb =
-      ::media::BindToCurrentLoop(base::Bind(
-          &VideoPipelineProxy::OnAvPipeCreated, weak_this_,
-          configs, status_cb));
-  FORWARD_ON_IO_THREAD(CreateAvPipe, shared_mem_cb);
-}
-
-void VideoPipelineProxy::OnAvPipeCreated(
-    const std::vector<::media::VideoDecoderConfig>& configs,
-    const ::media::PipelineStatusCB& status_cb,
-    std::unique_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());
-
-  std::unique_ptr<MediaMemoryChunk> shared_memory_chunk(
-      new SharedMemoryChunk(std::move(shared_memory), kAppVideoBufferSize));
-  std::unique_ptr<MediaMessageFifo> video_pipe(
-      new MediaMessageFifo(std::move(shared_memory_chunk), false));
-  video_pipe->ObserveWriteActivity(
-      base::Bind(&VideoPipelineProxy::OnPipeWrite, weak_this_));
-
-  video_streamer_->SetMediaMessageFifo(std::move(video_pipe));
-
-  // Now proceed to the decoder/renderer initialization.
-  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());
-  DCHECK(video_streamer_);
-  video_streamer_->StopAndFlush(done_cb);
-}
-
-void VideoPipelineProxy::Stop() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!video_streamer_)
-    return;
-  video_streamer_->StopAndFlush(base::Bind(&IgnoreResult));
-}
-
-void VideoPipelineProxy::OnPipeWrite() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  FORWARD_ON_IO_THREAD(NotifyPipeWrite);
-}
-
-void VideoPipelineProxy::OnPipeRead() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (video_streamer_)
-    video_streamer_->OnFifoReadEvent();
-}
-
-}  // namespace media
-}  // namespace chromecast