Load CMA backend from shared library

chromecast/media/cma/backend/audio_video_pipeline_device_unittest.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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
-#include "chromecast/media/base/decrypt_context.h"
-#include "chromecast/media/cma/backend/audio_pipeline_device.h"
-#include "chromecast/media/cma/backend/media_clock_device.h"
-#include "chromecast/media/cma/backend/media_pipeline_device.h"
-#include "chromecast/media/cma/backend/media_pipeline_device_factory.h"
-#include "chromecast/media/cma/backend/media_pipeline_device_params.h"
-#include "chromecast/media/cma/backend/video_pipeline_device.h"
+#include "chromecast/base/task_runner_impl.h"
 #include "chromecast/media/cma/base/decoder_buffer_adapter.h"
-#include "chromecast/media/cma/base/decoder_buffer_base.h"
 #include "chromecast/media/cma/base/decoder_config_adapter.h"
 #include "chromecast/media/cma/test/frame_segmenter_for_test.h"
 #include "chromecast/media/cma/test/media_component_device_feeder_for_test.h"
 #include "chromecast/public/cast_media_shlib.h"
+#include "chromecast/public/media/audio_pipeline_device.h"
+#include "chromecast/public/media/cast_decoder_buffer.h"
 #include "chromecast/public/media/decoder_config.h"
+#include "chromecast/public/media/media_clock_device.h"
+#include "chromecast/public/media/media_pipeline_backend.h"
+#include "chromecast/public/media/media_pipeline_device_params.h"
+#include "chromecast/public/media/video_pipeline_device.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/buffers.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
@@ skipping 57 matching lines @@
 
   void LoadAudioStream(std::string filename);
   void LoadVideoStream(std::string filename, bool raw_h264);
 
   void MonitorLoop();
 
   void OnPauseCompleted();
 
   void OnEos(MediaComponentDeviceFeederForTest* device_feeder);
 
-  scoped_ptr<MediaPipelineDevice> media_pipeline_device_;
+  scoped_ptr<TaskRunnerImpl> task_runner_;
+  scoped_ptr<MediaPipelineBackend> backend_;
   MediaClockDevice* media_clock_device_;
 
   // Devices to feed
   ScopedVector<MediaComponentDeviceFeederForTest>
       component_device_feeders_;
 
   // Current media time.
   base::TimeDelta pause_time_;
 
   // Pause settings
@@ skipping 35 matching lines @@
   Initialize();
   LoadVideoStream(filename, false /* raw_h264 */);
   LoadAudioStream(filename);
 }
 
 void AudioVideoPipelineDeviceTest::LoadAudioStream(std::string filename) {
   base::FilePath file_path = GetTestDataFilePath(filename);
   DemuxResult demux_result = FFmpegDemuxForTest(file_path, true /* audio */);
   BufferList frames = demux_result.frames;
 
-  AudioPipelineDevice* audio_pipeline_device =
-      media_pipeline_device_->GetAudioPipelineDevice();
+  AudioPipelineDevice* audio_pipeline_device = backend_->GetAudio();
 
   bool success = audio_pipeline_device->SetConfig(
       DecoderConfigAdapter::ToCastAudioConfig(kPrimary,
                                               demux_result.audio_config));
   ASSERT_TRUE(success);
 
   VLOG(2) << "Got " << frames.size() << " audio input frames";
 
   frames.push_back(
       scoped_refptr<DecoderBufferBase>(
@@ skipping 26 matching lines @@
     video_config.is_encrypted = false;
   } else {
     base::FilePath file_path = GetTestDataFilePath(filename);
     DemuxResult demux_result = FFmpegDemuxForTest(file_path,
                                                   /*audio*/ false);
     frames = demux_result.frames;
     video_config = DecoderConfigAdapter::ToCastVideoConfig(
         kPrimary, demux_result.video_config);
   }
 
-  VideoPipelineDevice* video_pipeline_device =
-      media_pipeline_device_->GetVideoPipelineDevice();
+  VideoPipelineDevice* video_pipeline_device = backend_->GetVideo();
 
   // Set configuration.
   bool success = video_pipeline_device->SetConfig(video_config);
   ASSERT_TRUE(success);
 
   VLOG(2) << "Got " << frames.size() << " video input frames";
 
   frames.push_back(
       scoped_refptr<DecoderBufferBase>(new DecoderBufferAdapter(
           ::media::DecoderBuffer::CreateEOSBuffer())));
@@ skipping 17 matching lines @@
   }
 
   media_clock_device_->SetState(MediaClockDevice::kStateRunning);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&AudioVideoPipelineDeviceTest::MonitorLoop,
                             base::Unretained(this)));
 }
 
 void AudioVideoPipelineDeviceTest::MonitorLoop() {
-  base::TimeDelta media_time = media_clock_device_->GetTime();
+  base::TimeDelta media_time = base::TimeDelta::FromMicroseconds(
+      media_clock_device_->GetTimeMicroseconds());
 
   if (!pause_pattern_.empty() &&
       pause_pattern_[pause_pattern_idx_].delay >= base::TimeDelta() &&
       media_time >= pause_time_ + pause_pattern_[pause_pattern_idx_].delay) {
     // Do Pause
     media_clock_device_->SetRate(0.0);
-    pause_time_ = media_clock_device_->GetTime();
+    pause_time_ = base::TimeDelta::FromMicroseconds(
+        media_clock_device_->GetTimeMicroseconds());
 
     VLOG(2) << "Pausing at " << pause_time_.InMilliseconds() << "ms for " <<
         pause_pattern_[pause_pattern_idx_].length.InMilliseconds() << "ms";
 
     // Wait for pause finish
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&AudioVideoPipelineDeviceTest::OnPauseCompleted,
                               base::Unretained(this)),
         pause_pattern_[pause_pattern_idx_].length);
     return;
   }
 
   // Check state again in a little while
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&AudioVideoPipelineDeviceTest::MonitorLoop,
                             base::Unretained(this)),
       kMonitorLoopDelay);
 }
 
 void AudioVideoPipelineDeviceTest::OnPauseCompleted() {
   // Make sure the media time didn't move during that time.
-  base::TimeDelta media_time = media_clock_device_->GetTime();
+  base::TimeDelta media_time = base::TimeDelta::FromMicroseconds(
+      media_clock_device_->GetTimeMicroseconds());
 
   // TODO(damienv):
   // Should be:
   // EXPECT_EQ(media_time, media_time_);
   // However, some backends, when rendering the first frame while in paused
   // mode moves the time forward.
   // This behaviour is not intended.
   EXPECT_GE(media_time, pause_time_);
   EXPECT_LE(media_time, pause_time_ + base::TimeDelta::FromMilliseconds(50));
 
@@ skipping 19 matching lines @@
     }
   }
 
   // Check if all streams finished
   if (component_device_feeders_.empty())
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
 void AudioVideoPipelineDeviceTest::Initialize() {
   // Create the media device.
-  MediaPipelineDeviceParams params;
-  scoped_ptr<MediaPipelineDeviceFactory> device_factory =
-      GetMediaPipelineDeviceFactory(params);
-  media_pipeline_device_.reset(new MediaPipelineDevice(device_factory.Pass()));
-  media_clock_device_ = media_pipeline_device_->GetMediaClockDevice();
+  task_runner_.reset(new TaskRunnerImpl());
+  MediaPipelineDeviceParams params(task_runner_.get());
+  backend_.reset(CastMediaShlib::CreateMediaPipelineBackend(params));
+  media_clock_device_ = backend_->GetClock();
 
   // Clock initialization and configuration.
   bool success =
       media_clock_device_->SetState(MediaClockDevice::kStateIdle);
   ASSERT_TRUE(success);
-  success = media_clock_device_->ResetTimeline(base::TimeDelta());
+  success = media_clock_device_->ResetTimeline(0);
   ASSERT_TRUE(success);
   media_clock_device_->SetRate(1.0);
 }
 
 TEST_F(AudioVideoPipelineDeviceTest, Mp3Playback) {
   scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   ConfigureForAudioOnly("sfx.mp3");
   Start();
   message_loop->Run();
@@ skipping 38 matching lines @@
 TEST_F(AudioVideoPipelineDeviceTest, WebmPlayback) {
   scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   ConfigureForFile("bear-640x360.webm");
   Start();
   message_loop->Run();
 }
 
 }  // namespace media
 }  // namespace chromecast