Refactor MediaResource to be multi-stream capable

media/mojo/clients/mojo_renderer_unittest.cc

 // Copyright 2016 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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 59 matching lines @@
         MojoRendererService::InitiateSurfaceRequestCB(),
         mojo::MakeRequest(&remote_renderer));
 
     mojo_renderer_.reset(
         new MojoRenderer(message_loop_.task_runner(),
                          std::unique_ptr<VideoOverlayFactory>(nullptr), nullptr,
                          std::move(remote_renderer)));
 
     // CreateAudioStream() and CreateVideoStream() overrides expectations for
     // expected non-NULL streams.
-    EXPECT_CALL(demuxer_, GetStream(_)).WillRepeatedly(Return(nullptr));
+    EXPECT_CALL(demuxer_, GetStreams()).WillRepeatedly(Return(streams_));
 
     EXPECT_CALL(*mock_renderer_, GetMediaTime())
         .WillRepeatedly(Return(base::TimeDelta()));
   }
 
   virtual ~MojoRendererTest() {}
 
   void Destroy() {
     mojo_renderer_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   // Completion callbacks.
   MOCK_METHOD1(OnInitialized, void(PipelineStatus));
   MOCK_METHOD0(OnFlushed, void());
   MOCK_METHOD1(OnCdmAttached, void(bool));
   MOCK_METHOD1(OnSurfaceRequestToken, void(const base::UnguessableToken&));
 
   std::unique_ptr<StrictMock<MockDemuxerStream>> CreateStream(
       DemuxerStream::Type type) {
     std::unique_ptr<StrictMock<MockDemuxerStream>> stream(
         new StrictMock<MockDemuxerStream>(type));
     return stream;
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
-    EXPECT_CALL(demuxer_, GetStream(DemuxerStream::AUDIO))
-        .WillRepeatedly(Return(audio_stream_.get()));
+    streams_.push_back(audio_stream_.get());
+    EXPECT_CALL(demuxer_, GetStreams()).WillRepeatedly(Return(streams_));
   }
 
   void CreateVideoStream(bool is_encrypted = false) {
     video_stream_ = CreateStream(DemuxerStream::VIDEO);
     video_stream_->set_video_decoder_config(
         is_encrypted ? TestVideoConfig::NormalEncrypted()
                      : TestVideoConfig::Normal());
-    EXPECT_CALL(demuxer_, GetStream(DemuxerStream::VIDEO))
-        .WillRepeatedly(Return(video_stream_.get()));
+    std::vector<DemuxerStream*> streams;
+    streams_.push_back(audio_stream_.get());
+    EXPECT_CALL(demuxer_, GetStreams()).WillRepeatedly(Return(streams_));
   }
 
   void InitializeAndExpect(PipelineStatus status) {
     DVLOG(1) << __func__ << ": " << status;
     EXPECT_CALL(*this, OnInitialized(status));
     mojo_renderer_->Initialize(
         &demuxer_, &renderer_client_,
         base::Bind(&MojoRendererTest::OnInitialized, base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 74 matching lines @@
 
   // Client side mocks and helpers.
   StrictMock<MockRendererClient> renderer_client_;
   StrictMock<MockCdmContext> cdm_context_;
   mojom::ContentDecryptionModulePtr remote_cdm_;
 
   // Client side mock demuxer and demuxer streams.
   StrictMock<MockDemuxer> demuxer_;
   std::unique_ptr<StrictMock<MockDemuxerStream>> audio_stream_;
   std::unique_ptr<StrictMock<MockDemuxerStream>> video_stream_;
+  std::vector<DemuxerStream*> streams_;
 
   // Service side mocks and helpers.
   StrictMock<MockRenderer>* mock_renderer_;
   MojoCdmServiceContext mojo_cdm_service_context_;
   RendererClient* remote_renderer_client_;
   DefaultCdmFactory cdm_factory_;
 
   mojo::StrongBindingPtr<mojom::Renderer> renderer_binding_;
 
  private:
@@ skipping 236 matching lines @@
   Play();
   remote_renderer_client_->OnError(PIPELINE_ERROR_DECODE);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(*mock_renderer_, SetPlaybackRate(0.0)).Times(1);
   mojo_renderer_->SetPlaybackRate(0.0);
   Flush();
 }
 
 }  // namespace media