[Chromecast] Upgrade to new CMA backend API

chromecast/media/cma/test/cma_end_to_end_test.cc

 // Copyright 2015 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 "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "chromecast/base/task_runner_impl.h"
 #include "chromecast/media/cma/backend/media_pipeline_backend_default.h"
 #include "chromecast/media/cma/base/buffering_defs.h"
+#include "chromecast/media/cma/base/coded_frame_provider.h"
 #include "chromecast/media/cma/filters/cma_renderer.h"
+#include "chromecast/media/cma/pipeline/av_pipeline_client.h"
 #include "chromecast/media/cma/pipeline/media_pipeline_impl.h"
+#include "chromecast/media/cma/pipeline/video_pipeline_client.h"
+#include "chromecast/renderer/media/audio_pipeline.h"
+#include "chromecast/renderer/media/renderer_media_pipeline.h"
+#include "chromecast/renderer/media/video_pipeline.h"
 #include "gpu/command_buffer/client/gles2_interface_stub.h"
 #include "media/base/demuxer_stream_provider.h"
 #include "media/base/fake_demuxer_stream.h"
 #include "media/base/null_video_sink.h"
 #include "media/renderers/mock_gpu_video_accelerator_factories.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
+class FakeRendererMediaPipeline : public RendererMediaPipeline {
+ public:
+  FakeRendererMediaPipeline(scoped_ptr<MediaPipelineImpl> media_pipeline)
+      : media_pipeline_(media_pipeline.Pass()),
+        audio_pipeline_(new FakeAudioPipeline(media_pipeline_.get())),
+        video_pipeline_(new FakeVideoPipeline(media_pipeline_.get())) {}
+
+  ~FakeRendererMediaPipeline() override {}
+
+  // RendererMediaPipeline implementation:
+  void SetClient(const MediaPipelineClient& client) override {
+    media_pipeline_->SetClient(client);
+  }
+
+  void SetCdm(int cdm_id) override { media_pipeline_->SetCdm(cdm_id); }
+
+  AudioPipeline* GetAudioPipeline() const override {
+    return audio_pipeline_.get();
+  }
+
+  VideoPipeline* GetVideoPipeline() const override {
+    return video_pipeline_.get();
+  }
+
+  void InitializeAudio(const ::media::AudioDecoderConfig& config,
+                       scoped_ptr<CodedFrameProvider> frame_provider,
+                       const ::media::PipelineStatusCB& status_cb) override {
+    audio_pipeline_->InitializeAudio(config, frame_provider.Pass(), status_cb);
+  }
+
+  void InitializeVideo(const std::vector< ::media::VideoDecoderConfig>& configs,
+                       scoped_ptr<CodedFrameProvider> frame_provider,
+                       const ::media::PipelineStatusCB& status_cb) override {
+    video_pipeline_->InitializeVideo(configs, frame_provider.Pass(), status_cb);
+  }
+
+  void StartPlayingFrom(base::TimeDelta time) override {
+    media_pipeline_->StartPlayingFrom(time);
+  }
+
+  void Flush(const ::media::PipelineStatusCB& status_cb) override {
+    media_pipeline_->Flush(status_cb);
+  }
+
+  void Stop() override { media_pipeline_->Stop(); }
+
+  void SetPlaybackRate(double playback_rate) override {
+    media_pipeline_->SetPlaybackRate(playback_rate);
+  }
+
+ private:
+  class FakeAudioPipeline : public AudioPipeline {
+   public:
+    FakeAudioPipeline(MediaPipelineImpl* media_pipeline)
+        : media_pipeline_(media_pipeline),
+          client_set_(false),
+          initialized_(false) {
+      DCHECK(media_pipeline_);
+    }
+
+    ~FakeAudioPipeline() override {}
+
+    void InitializeAudio(const ::media::AudioDecoderConfig& config,
+                         scoped_ptr<CodedFrameProvider> frame_provider,
+                         const ::media::PipelineStatusCB& status_cb) {
+      config_ = config;
+      frame_provider_ = frame_provider.Pass();
+      status_cb_ = status_cb;
+      initialized_ = true;
+      if (client_set_) {
+        media_pipeline_->InitializeAudio(
+            config_, client_, frame_provider_.Pass(), status_cb_);
+      }
+    }
+
+    // AudioPipeline implementation:
+    void SetClient(const AvPipelineClient& client) override {
+      client_ = client;
+      client_set_ = true;
+      if (initialized_) {
+        media_pipeline_->InitializeAudio(
+            config_, client_, frame_provider_.Pass(), status_cb_);
+      }
+    }
+
+    void SetVolume(float volume) override {
+      media_pipeline_->SetVolume(volume);
+    }
+
+   private:
+    MediaPipelineImpl* media_pipeline_;
+    bool client_set_;
+    bool initialized_;
+
+    AvPipelineClient client_;
+    ::media::AudioDecoderConfig config_;
+    scoped_ptr<CodedFrameProvider> frame_provider_;
+    ::media::PipelineStatusCB status_cb_;
+
+    DISALLOW_COPY_AND_ASSIGN(FakeAudioPipeline);
+  };
+
+  class FakeVideoPipeline : public VideoPipeline {
+   public:
+    FakeVideoPipeline(MediaPipelineImpl* media_pipeline)
+        : media_pipeline_(media_pipeline),
+          client_set_(false),
+          initialized_(false) {
+      DCHECK(media_pipeline_);
+    }
+
+    ~FakeVideoPipeline() override {}
+
+    void InitializeVideo(
+        const std::vector< ::media::VideoDecoderConfig>& configs,
+        scoped_ptr<CodedFrameProvider> frame_provider,
+        const ::media::PipelineStatusCB& status_cb) {
+      configs_ = configs;
+      frame_provider_ = frame_provider.Pass();
+      status_cb_ = status_cb;
+      initialized_ = true;
+      if (client_set_) {
+        media_pipeline_->InitializeVideo(
+            configs_, client_, frame_provider_.Pass(), status_cb_);
+      }
+    }
+
+    // VideoPipeline implementation:
+    void SetClient(const VideoPipelineClient& client) override {
+      client_ = client;
+      client_set_ = true;
+      if (initialized_) {
+        media_pipeline_->InitializeVideo(
+            configs_, client_, frame_provider_.Pass(), status_cb_);
+      }
+    }
+
+   private:
+    MediaPipelineImpl* media_pipeline_;
+    bool client_set_;
+    bool initialized_;
+
+    VideoPipelineClient client_;
+    std::vector< ::media::VideoDecoderConfig> configs_;
+    scoped_ptr<CodedFrameProvider> frame_provider_;
+    ::media::PipelineStatusCB status_cb_;
+
+    DISALLOW_COPY_AND_ASSIGN(FakeVideoPipeline);
+  };
+
+  const scoped_ptr<MediaPipelineImpl> media_pipeline_;
+  scoped_ptr<FakeAudioPipeline> audio_pipeline_;
+  scoped_ptr<FakeVideoPipeline> video_pipeline_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeRendererMediaPipeline);
+};
+
 class CmaEndToEndTest : public testing::Test {
  public:
   CmaEndToEndTest() {}
 
   void SetUp() override {
     demuxer_stream_provider_.reset(
         new ::media::FakeDemuxerStreamProvider(1, 1, false));
     null_sink_.reset(new ::media::NullVideoSink(
         false, base::TimeDelta::FromSecondsD(1.0 / 60),
         base::Bind(&MockCB::OnFrameReceived, base::Unretained(&mock_)),
         message_loop_.task_runner()));
 
     scoped_ptr<MediaPipelineImpl> media_pipeline(new MediaPipelineImpl());
     task_runner_.reset(new TaskRunnerImpl());
-    MediaPipelineDeviceParams params(task_runner_.get());
     scoped_ptr<MediaPipelineBackend> backend =
-        make_scoped_ptr(new MediaPipelineBackendDefault(params));
+        make_scoped_ptr(new MediaPipelineBackendDefault());
 
     gles2_.reset(new gpu::gles2::GLES2InterfaceStub());
     mock_gpu_factories_ = new ::media::MockGpuVideoAcceleratorFactories();
 
     EXPECT_CALL(*mock_gpu_factories_.get(), GetGLES2Interface())
         .WillRepeatedly(testing::Return(gles2_.get()));
 
     media_pipeline->Initialize(kLoadTypeMediaSource, backend.Pass());
 
-    renderer_.reset(new CmaRenderer(media_pipeline.Pass(), null_sink_.get(),
-                                    mock_gpu_factories_));
+    scoped_ptr<RendererMediaPipeline> renderer_media_pipeline(
+        new FakeRendererMediaPipeline(media_pipeline.Pass()));
+
+    renderer_.reset(new CmaRenderer(
+        renderer_media_pipeline.Pass(), null_sink_.get(), mock_gpu_factories_));
   }
   void TearDown() override { message_loop_.RunUntilIdle(); }
 
   ~CmaEndToEndTest() override {}
 
  protected:
   base::MessageLoop message_loop_;
   scoped_ptr<TaskRunnerImpl> task_runner_;
   scoped_ptr<::media::FakeDemuxerStreamProvider> demuxer_stream_provider_;
   scoped_ptr<CmaRenderer> renderer_;
@@ skipping 27 matching lines @@
       base::Bind(&MockCB::OnInitialized, base::Unretained(&mock_)),
       base::Bind(&MockCB::OnStatistics, base::Unretained(&mock_)),
       base::Bind(&MockCB::OnBufferingState, base::Unretained(&mock_)),
       base::Bind(&MockCB::OnEnded, base::Unretained(&mock_)),
       base::Bind(&MockCB::OnError, base::Unretained(&mock_)),
       base::Bind(&MockCB::OnWaitingForDecryptionKey, base::Unretained(&mock_)));
 
   EXPECT_CALL(mock_, OnInitialized(::media::PIPELINE_OK));
 }
 
-
 }  // namespace media
 }  // namespace chromecast