Load CMA backend from shared library

chromecast/media/cma/backend/media_component_device_default.cc

Index: chromecast/media/cma/backend/media_component_device_default.cc
diff --git a/chromecast/media/cma/backend/media_component_device_default.cc b/chromecast/media/cma/backend/media_component_device_default.cc
index 3ed5f01f3956e2e5390804c48e7812f944a1e1e9..5aa7fee4171a31bd3ccaea274cf88544664a2a6d 100644
--- a/chromecast/media/cma/backend/media_component_device_default.cc
+++ b/chromecast/media/cma/backend/media_component_device_default.cc
@@ -8,7 +8,9 @@
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/thread_task_runner_handle.h"
-#include "chromecast/media/cma/base/decoder_buffer_base.h"
+#include "chromecast/public/media/decoder_buffer.h"
+#include "chromecast/public/media/media_pipeline_device_params.h"
+#include "chromecast/public/task_runner.h"
 #include "media/base/buffers.h"
 
 namespace chromecast {
@@ -19,6 +21,16 @@ namespace {
 // Maximum number of frames that can be buffered.
 const size_t kMaxFrameCount = 20;
 
+// Wraps base::Closure in the chromecast/public TaskRunner interface.
+class ClosureTask : public TaskRunner::Task {
+ public:
+  ClosureTask(const base::Closure& cb) : cb_(cb) {}
+  void Run() override { cb_.Run(); }
+
+ private:
+  base::Closure cb_;
+};
+
 }  // namespace
 
 MediaComponentDeviceDefault::DefaultDecoderBuffer::DefaultDecoderBuffer()
@@ -29,33 +41,35 @@ MediaComponentDeviceDefault::DefaultDecoderBuffer::~DefaultDecoderBuffer() {
 }
 
 MediaComponentDeviceDefault::MediaComponentDeviceDefault(
+    const MediaPipelineDeviceParams& params,
     MediaClockDevice* media_clock_device)
-    : media_clock_device_(media_clock_device),
+    : task_runner_(params.task_runner),
+      media_clock_device_(media_clock_device),
       state_(kStateUninitialized),
-      rendering_time_(::media::kNoTimestamp()),
+      rendering_time_(TimeDelta::Invalid()),
       decoded_frame_count_(0),
       decoded_byte_count_(0),
       scheduled_rendering_task_(false),
       weak_factory_(this) {
   weak_this_ = weak_factory_.GetWeakPtr();
-  DetachFromThread();
+  thread_checker_.DetachFromThread();
 }
 
 MediaComponentDeviceDefault::~MediaComponentDeviceDefault() {
 }
 
-void MediaComponentDeviceDefault::SetClient(const Client& client) {
-  DCHECK(CalledOnValidThread());
-  client_ = client;
+void MediaComponentDeviceDefault::SetClient(Client* client) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  client_.reset(client);
 }
 
 MediaComponentDevice::State MediaComponentDeviceDefault::GetState() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   return state_;
 }
 
 bool MediaComponentDeviceDefault::SetState(State new_state) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (!MediaComponentDevice::IsValidStateTransition(state_, new_state))
     return false;
   state_ = new_state;
@@ -63,21 +77,20 @@ bool MediaComponentDeviceDefault::SetState(State new_state) {
   if (state_ == kStateIdle) {
     // Back to the idle state: reset a bunch of parameters.
     is_eos_ = false;
-    rendering_time_ = ::media::kNoTimestamp();
+    rendering_time_ = TimeDelta::Invalid();
     decoded_frame_count_ = 0;
     decoded_byte_count_ = 0;
     frames_.clear();
-    pending_buffer_ = scoped_refptr<DecoderBufferBase>();
-    frame_pushed_cb_.Reset();
+    pending_buffer_ = scoped_ptr<DecoderBuffer>();
+    frame_pushed_cb_.reset();
     return true;
   }
 
   if (state_ == kStateRunning) {
     if (!scheduled_rendering_task_) {
       scheduled_rendering_task_ = true;
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(&MediaComponentDeviceDefault::RenderTask, weak_this_));
+      task_runner_->PostTask(new ClosureTask(
+          base::Bind(&MediaComponentDeviceDefault::RenderTask, weak_this_)));
     }
     return true;
   }
@@ -85,31 +98,34 @@ bool MediaComponentDeviceDefault::SetState(State new_state) {
   return true;
 }
 
-bool MediaComponentDeviceDefault::SetStartPts(base::TimeDelta time) {
-  DCHECK(CalledOnValidThread());
+bool MediaComponentDeviceDefault::SetStartPts(TimeDelta time) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, kStateIdle);
   rendering_time_ = time;
   return true;
 }
 
 MediaComponentDevice::FrameStatus MediaComponentDeviceDefault::PushFrame(
-    const scoped_refptr<DecryptContext>& decrypt_context,
-    const scoped_refptr<DecoderBufferBase>& buffer,
-    const FrameStatusCB& completion_cb) {
-  DCHECK(CalledOnValidThread());
+    CastKeySystem cast_key_system,
+    DecoderBuffer* buffer_in,
+    FrameStatusCB* completion_cb_in) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == kStatePaused || state_ == kStateRunning);
   DCHECK(!is_eos_);
   DCHECK(!pending_buffer_.get());
-  DCHECK(buffer.get());
+  DCHECK(buffer_in);
+
+  scoped_ptr<FrameStatusCB> completion_cb(completion_cb_in);
 
+  scoped_ptr<DecoderBuffer> buffer(buffer_in);
   if (buffer->end_of_stream()) {
     is_eos_ = true;
     return kFrameSuccess;
   }
 
   if (frames_.size() > kMaxFrameCount) {
-    pending_buffer_ = buffer;
-    frame_pushed_cb_ = completion_cb;
+    pending_buffer_ = buffer.Pass();
+    frame_pushed_cb_ = completion_cb.Pass();
     return kFramePending;
   }
 
@@ -120,13 +136,9 @@ MediaComponentDevice::FrameStatus MediaComponentDeviceDefault::PushFrame(
   return kFrameSuccess;
 }
 
-base::TimeDelta MediaComponentDeviceDefault::GetRenderingTime() const {
-  return rendering_time_;
-}
-
-base::TimeDelta MediaComponentDeviceDefault::GetRenderingDelay() const {
+TimeDelta MediaComponentDeviceDefault::GetRenderingDelay() const {
   NOTIMPLEMENTED();
-  return ::media::kNoTimestamp();
+  return TimeDelta::Invalid();
 }
 
 void MediaComponentDeviceDefault::RenderTask() {
@@ -135,13 +147,13 @@ void MediaComponentDeviceDefault::RenderTask() {
   if (state_ != kStateRunning)
     return;
 
-  base::TimeDelta media_time = media_clock_device_->GetTime();
-  if (media_time == ::media::kNoTimestamp()) {
+  TimeDelta media_time = media_clock_device_->GetTime();
+  if (media_time == TimeDelta::Invalid()) {
     scheduled_rendering_task_ = true;
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&MediaComponentDeviceDefault::RenderTask, weak_this_),
-        base::TimeDelta::FromMilliseconds(50));
+    task_runner_->PostDelayedTask(
+        new ClosureTask(
+            base::Bind(&MediaComponentDeviceDefault::RenderTask, weak_this_)),
+        TimeDelta::FromMilliseconds(50));
     return;
   }
 
@@ -155,22 +167,24 @@ void MediaComponentDeviceDefault::RenderTask() {
       fake_buffer.size = pending_buffer_->data_size();
       fake_buffer.pts = pending_buffer_->timestamp();
       frames_.push_back(fake_buffer);
-      pending_buffer_ = scoped_refptr<DecoderBufferBase>();
-      base::ResetAndReturn(&frame_pushed_cb_).Run(kFrameSuccess);
+      pending_buffer_ = scoped_ptr<DecoderBuffer>();
+      frame_pushed_cb_->Run(kFrameSuccess);
+      frame_pushed_cb_.reset();
     }
   }
 
   if (frames_.empty() && is_eos_) {
-    if (!client_.eos_cb.is_null())
-      client_.eos_cb.Run();
+    if (client_) {
+      client_->OnEndOfStream();
+    }
     return;
   }
 
   scheduled_rendering_task_ = true;
-  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&MediaComponentDeviceDefault::RenderTask, weak_this_),
-      base::TimeDelta::FromMilliseconds(50));
+  task_runner_->PostDelayedTask(
+      new ClosureTask(
+          base::Bind(&MediaComponentDeviceDefault::RenderTask, weak_this_)),
+      TimeDelta::FromMilliseconds(50));
 }
 
 bool MediaComponentDeviceDefault::GetStatistics(Statistics* stats) const {