Load CMA backend from shared library

chromecast/media/cma/pipeline/av_pipeline_impl.cc

Index: chromecast/media/cma/pipeline/av_pipeline_impl.cc
diff --git a/chromecast/media/cma/pipeline/av_pipeline_impl.cc b/chromecast/media/cma/pipeline/av_pipeline_impl.cc
index ab0a2a75d0c319bc5db3ab5a8f56666c784a361d..010ead515ce6420cd65efa473414777bcf28945d 100644
--- a/chromecast/media/cma/pipeline/av_pipeline_impl.cc
+++ b/chromecast/media/cma/pipeline/av_pipeline_impl.cc
@@ -9,16 +9,20 @@
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
+#include "chromecast/base/time_conversions.h"
 #include "chromecast/media/base/decrypt_context.h"
 #include "chromecast/media/cdm/browser_cdm_cast.h"
-#include "chromecast/media/cma/backend/media_clock_device.h"
-#include "chromecast/media/cma/backend/media_component_device.h"
+#include "chromecast/media/cma/base/backend_client_callbacks.h"
 #include "chromecast/media/cma/base/buffering_frame_provider.h"
 #include "chromecast/media/cma/base/buffering_state.h"
 #include "chromecast/media/cma/base/cma_logging.h"
 #include "chromecast/media/cma/base/coded_frame_provider.h"
 #include "chromecast/media/cma/base/decoder_buffer_base.h"
+#include "chromecast/media/cma/base/decoder_buffer_impl.h"
 #include "chromecast/media/cma/pipeline/decrypt_util.h"
+#include "chromecast/public/media/decrypt_config.h"
+#include "chromecast/public/media/media_clock_device.h"
+#include "chromecast/public/media/media_component_device.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/buffers.h"
@@ -33,14 +37,13 @@ const int kNoCallbackId = -1;
 
 }  // namespace
 
-AvPipelineImpl::AvPipelineImpl(
-    MediaComponentDevice* media_component_device,
-    const UpdateConfigCB& update_config_cb)
+AvPipelineImpl::AvPipelineImpl(MediaComponentDevice* media_component_device,
+                               const UpdateConfigCB& update_config_cb)
     : update_config_cb_(update_config_cb),
       media_component_device_(media_component_device),
       state_(kUninitialized),
-      buffered_time_(::media::kNoTimestamp()),
-      playable_buffered_time_(::media::kNoTimestamp()),
+      buffered_time_(TimeDelta::Invalid()),
+      playable_buffered_time_(TimeDelta::Invalid()),
       enable_feeding_(false),
       pending_read_(false),
       pending_push_(false),
@@ -56,7 +59,7 @@ AvPipelineImpl::AvPipelineImpl(
 
 AvPipelineImpl::~AvPipelineImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  media_component_device_->SetClient(MediaComponentDevice::Client());
+  media_component_device_->SetClient(nullptr);
 
   if (media_keys_ && media_keys_callback_id_ != kNoCallbackId)
     media_keys_->UnregisterPlayer(media_keys_callback_id_);
@@ -93,9 +96,8 @@ bool AvPipelineImpl::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, kUninitialized);
 
-  MediaComponentDevice::Client client;
-  client.eos_cb = base::Bind(&AvPipelineImpl::OnEos, weak_this_);
-  media_component_device_->SetClient(client);
+  media_component_device_->SetClient(new MediaComponentDeviceClientImpl(
+      base::Bind(&AvPipelineImpl::OnEos, weak_this_)));
   if (!media_component_device_->SetState(MediaComponentDevice::kStateIdle))
     return false;
 
@@ -110,7 +112,8 @@ bool AvPipelineImpl::StartPlayingFrom(
 
   // Media time where rendering should start
   // and switch to a state where the audio device accepts incoming buffers.
-  if (!media_component_device_->SetStartPts(time) ||
+  TimeDelta start_time = FromBaseTimeDelta(time);
+  if (!media_component_device_->SetStartPts(start_time) ||
       !media_component_device_->SetState(MediaComponentDevice::kStatePaused)) {
     return false;
   }
@@ -149,8 +152,8 @@ void AvPipelineImpl::Flush(const base::Closure& done_cb) {
 
   // Finally, remove any frames left in the frame provider.
   pending_read_ = false;
-  buffered_time_ = ::media::kNoTimestamp();
-  playable_buffered_time_ = ::media::kNoTimestamp();
+  buffered_time_ = TimeDelta::Invalid();

[gunsch, 2015/07/27 17:14:49]

To me, this re-affirms not having our own TimeDelta class. I think we'll be
better off continuing to use the ::media primitives here and uint64_t's
otherwise.

[servolk, 2015/07/27 21:25:47]

If our goal is to fully decouple CMA backend code from Chromium dependencies,
then we don't have much of a choice. Although personally, I agree, I think
having to duplicate this functionality is very unfortunate. Perhaps we could
keep dependency at least on Chromium base/? Wasn't there some effort to make
libbase more separate and easily shareable/packageable for use by third-party
devs?

[halliwell, 2015/07/28 02:19:35]

I've removed TimeDelta.  It made initial refactoring easier/more mechanical but
you're right it doesn't add much value.  And in fact most backend code seems to
work with raw integers anyway, so the code actually gets simpler after passing
integers through.

+  playable_buffered_time_ = TimeDelta::Invalid();
   non_playable_frames_.clear();
   frame_provider_->Flush(done_cb);
 }
@@ -282,15 +285,17 @@ void AvPipelineImpl::ProcessPendingBuffer() {
   }
 
   if (!pending_buffer_->end_of_stream() && buffering_state_.get()) {
-    base::TimeDelta timestamp = pending_buffer_->timestamp();
+    base::TimeDelta timestamp = ToBaseTimeDelta(pending_buffer_->timestamp());
     if (timestamp != ::media::kNoTimestamp())
       buffering_state_->SetMaxRenderingTime(timestamp);
   }
 
+  CastKeySystem key_system =
+      decrypt_context ? decrypt_context->key_system() : KEY_SYSTEM_NONE;
   MediaComponentDevice::FrameStatus status = media_component_device_->PushFrame(
-      decrypt_context,
-      pending_buffer_,
-      base::Bind(&AvPipelineImpl::OnFramePushed, weak_this_));
+      key_system, new DecoderBufferImpl(pending_buffer_),
+      new FrameStatusCBImpl(
+          base::Bind(&AvPipelineImpl::OnFramePushed, weak_this_)));
   pending_buffer_ = scoped_refptr<DecoderBufferBase>();
 
   pending_push_ = (status == MediaComponentDevice::kFramePending);
@@ -335,14 +340,13 @@ void AvPipelineImpl::OnFrameBuffered(
   if (!buffering_state_.get())
     return;
 
-  if (!buffer->end_of_stream() &&
-      (buffered_time_ == ::media::kNoTimestamp() ||
-       buffered_time_ < buffer->timestamp())) {
+  if (!buffer->end_of_stream() && (buffered_time_ == TimeDelta::Invalid() ||
+                                   buffered_time_ < buffer->timestamp())) {
     buffered_time_ = buffer->timestamp();
   }
 
   if (is_at_max_capacity)
-    buffering_state_->NotifyMaxCapacity(buffered_time_);
+    buffering_state_->NotifyMaxCapacity(ToBaseTimeDelta(buffered_time_));
 
   // No need to update the list of playable frames,
   // if we are already blocking on a frame.
@@ -360,7 +364,7 @@ void AvPipelineImpl::UpdatePlayableFrames() {
     if (non_playable_frame->end_of_stream()) {
       buffering_state_->NotifyEos();
     } else {
-      const ::media::DecryptConfig* decrypt_config =
+      const DecryptConfig* decrypt_config =
           non_playable_frame->decrypt_config();
       if (decrypt_config &&
           !(media_keys_ &&
@@ -370,10 +374,11 @@ void AvPipelineImpl::UpdatePlayableFrames() {
         break;
       }
 
-      if (playable_buffered_time_ == ::media::kNoTimestamp() ||
+      if (playable_buffered_time_ == TimeDelta::Invalid() ||
           playable_buffered_time_ < non_playable_frame->timestamp()) {
         playable_buffered_time_ = non_playable_frame->timestamp();
-        buffering_state_->SetBufferedTime(playable_buffered_time_);
+        buffering_state_->SetBufferedTime(
+            ToBaseTimeDelta(playable_buffered_time_));
       }
     }