Load CMA backend from shared library

chromecast/media/cma/pipeline/video_pipeline_impl.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/pipeline/video_pipeline_impl.h"
 
 #include "base/bind.h"
-#include "chromecast/media/cma/backend/video_pipeline_device.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/base/decoder_config_adapter.h"
 #include "chromecast/media/cma/pipeline/av_pipeline_impl.h"
+#include "chromecast/media/cma/pipeline/video_pipeline_device_client_impl.h"
+#include "chromecast/public/graphics_types.h"
 #include "chromecast/public/media/decoder_config.h"
+#include "chromecast/public/media/video_pipeline_device.h"
 #include "media/base/video_decoder_config.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 const size_t kMaxVideoFrameSize = 1024 * 1024;
 }
 
 VideoPipelineImpl::VideoPipelineImpl(VideoPipelineDevice* video_device)
@@ skipping 77 matching lines @@
 
 void VideoPipelineImpl::Initialize(
     const std::vector<::media::VideoDecoderConfig>& configs,
     scoped_ptr<CodedFrameProvider> frame_provider,
     const ::media::PipelineStatusCB& status_cb) {
   DCHECK_GT(configs.size(), 0u);
   for (const auto& config : configs) {
     CMALOG(kLogControl) << __FUNCTION__ << " "
                         << config.AsHumanReadableString();
   }
-  VideoPipelineDevice::VideoClient client;
-  client.natural_size_changed_cb =
-      base::Bind(&VideoPipelineImpl::OnNaturalSizeChanged, weak_this_);
-  video_device_->SetVideoClient(client);
+  video_device_->SetVideoClient(new VideoPipelineDeviceClientImpl(
+      base::Bind(&VideoPipelineImpl::OnNaturalSizeChanged, weak_this_)));
   if (frame_provider)
     SetCodedFrameProvider(frame_provider.Pass());
 
   if (configs.empty()) {
      status_cb.Run(::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
      return;
   }
   DCHECK(configs.size() <= 2);
   DCHECK(configs[0].IsValidConfig());
   VideoConfig video_config =
@@ skipping 26 matching lines @@
     bool success = video_device_->SetConfig(
         DecoderConfigAdapter::ToCastVideoConfig(id, video_config));
     if (!success &&
         !video_client_.av_pipeline_client.playback_error_cb.is_null()) {
       video_client_.av_pipeline_client.playback_error_cb.Run(
           ::media::PIPELINE_ERROR_DECODE);
     }
   }
 }
 
-void VideoPipelineImpl::OnNaturalSizeChanged(const gfx::Size& size) {
+void VideoPipelineImpl::OnNaturalSizeChanged(const Size& size) {
   if (av_pipeline_impl_->GetState() != AvPipelineImpl::kPlaying)
     return;
 
-  if (!video_client_.natural_size_changed_cb.is_null())
-    video_client_.natural_size_changed_cb.Run(size);
+  if (!video_client_.natural_size_changed_cb.is_null()) {
+    video_client_.natural_size_changed_cb.Run(
+        gfx::Size(size.width, size.height));
+  }
 }
 
 void VideoPipelineImpl::UpdateStatistics() {
   if (video_client_.av_pipeline_client.statistics_cb.is_null())
     return;
 
   MediaComponentDevice::Statistics device_stats;
   if (!video_device_->GetStatistics(&device_stats))
     return;
 
@@ skipping 10 matching lines @@
   delta_stats.video_frames_dropped =
       current_stats.video_frames_dropped - previous_stats_.video_frames_dropped;
 
   previous_stats_ = current_stats;
 
   video_client_.av_pipeline_client.statistics_cb.Run(delta_stats);
 }
 
 }  // namespace media
 }  // namespace chromecast