MediaResource refactoring to support multiple streams

media/renderers/renderer_impl_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 <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 64 matching lines @@
         renderer_impl_(
             new RendererImpl(message_loop_.task_runner(),
                              std::unique_ptr<AudioRenderer>(audio_renderer_),
                              std::unique_ptr<VideoRenderer>(video_renderer_))),
         cdm_context_(new StrictMock<MockCdmContext>()),
         video_renderer_client_(nullptr),
         audio_renderer_client_(nullptr),
         initialization_status_(PIPELINE_OK) {
     // CreateAudioStream() and CreateVideoStream() overrides expectations for
     // expected non-NULL streams.
-    DemuxerStream* null_pointer = NULL;
-    EXPECT_CALL(*demuxer_, GetStream(_))
-        .WillRepeatedly(Return(null_pointer));
+    std::vector<DemuxerStream*> empty;
+    EXPECT_CALL(*demuxer_, GetStreams()).WillRepeatedly(Return(empty));
   }
 
   virtual ~RendererImplTest() { Destroy(); }
 
  protected:
   void Destroy() {
     renderer_impl_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   std::unique_ptr<StrictMock<MockDemuxerStream>> CreateStream(
       DemuxerStream::Type type) {
     std::unique_ptr<StrictMock<MockDemuxerStream>> stream(
         new StrictMock<MockDemuxerStream>(type));
-    EXPECT_CALL(*stream, SetStreamStatusChangeCB(_))
+    EXPECT_CALL(*stream, enabled()).WillRepeatedly(Return(true));
+    EXPECT_CALL(*demuxer_, SetStreamStatusChangeCB(_))
         .Times(testing::AnyNumber());
     return stream;
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
   void SetAudioRendererInitializeExpectations(PipelineStatus status) {
     EXPECT_CALL(*audio_renderer_, Initialize(audio_stream_.get(), _, _, _))
         .WillOnce(
             DoAll(SaveArg<2>(&audio_renderer_client_), RunCallback<3>(status)));
   }
@@ skipping 18 matching lines @@
     }
 
     renderer_impl_->Initialize(demuxer_.get(), &callbacks_,
                                base::Bind(&CallbackHelper::OnInitialize,
                                           base::Unretained(&callbacks_)));
     base::RunLoop().RunUntilIdle();
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
-    EXPECT_CALL(*demuxer_, GetStream(DemuxerStream::AUDIO))
-        .WillRepeatedly(Return(audio_stream_.get()));
+    std::vector<DemuxerStream*> streams;
+    streams.push_back(audio_stream_.get());
+    if (video_stream_)
+      streams.push_back(video_stream_.get());

[xhwang, 2017/02/01 18:26:04]

ditto about refactor this test, e.g. maybe just
s/CreateAudioStream/AddAudioStream

[servolk, 2017/02/01 22:29:21]

Done.

+    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;
+    if (audio_stream_)
+      streams.push_back(audio_stream_.get());
+    streams.push_back(video_stream_.get());
+    EXPECT_CALL(*demuxer_, GetStreams()).WillRepeatedly(Return(streams));
   }
 
   void CreateEncryptedVideoStream() { CreateVideoStream(true); }
 
   void CreateAudioAndVideoStream() {
     CreateAudioStream();
     CreateVideoStream();
   }
 
   void InitializeWithAudio() {
     CreateAudioStream();
     SetAudioRendererInitializeExpectations(PIPELINE_OK);
     // There is a potential race between HTMLMediaElement/WMPI shutdown and
-    // renderers being initialized which might result in DemuxerStreamProvider
-    // GetStream suddenly returning NULL (see crbug.com/668604). So we are going
-    // to check here that GetStream will be invoked exactly 3 times during
+    // renderers being initialized which might result in MediaResource
+    // GetStreams suddenly returning fewer streams than before or even returning
+    // and empty stream collection (see crbug.com/668604). So we are going to
+    // check here that GetStreams will be invoked exactly 3 times during
     // RendererImpl initialization to help catch potential issues. Currently the
-    // GetStream is invoked once directly from RendererImpl::Initialize, once
-    // indirectly from RendererImpl::Initialize via HasEncryptedStream and once
-    // from RendererImpl::InitializeAudioRenderer.
-    EXPECT_CALL(*demuxer_, GetStream(DemuxerStream::AUDIO))
-        .Times(2)
-        .WillRepeatedly(Return(audio_stream_.get()));
+    // GetStreams is invoked once from the RendererImpl::Initialize via
+    // HasEncryptedStream, once from the RendererImpl::InitializeAudioRenderer
+    // and once from the RendererImpl::InitializeVideoRenderer.
+    std::vector<DemuxerStream*> streams;
+    streams.push_back(audio_stream_.get());
+    EXPECT_CALL(*demuxer_, GetStreams())
+        .Times(3)
+        .WillRepeatedly(Return(streams));
     InitializeAndExpect(PIPELINE_OK);
   }
 
   void InitializeWithVideo() {
     CreateVideoStream();
     SetVideoRendererInitializeExpectations(PIPELINE_OK);
     // There is a potential race between HTMLMediaElement/WMPI shutdown and
-    // renderers being initialized which might result in DemuxerStreamProvider
-    // GetStream suddenly returning NULL (see crbug.com/668604). So we are going
-    // to check here that GetStream will be invoked exactly 3 times during
+    // renderers being initialized which might result in MediaResource
+    // GetStreams suddenly returning fewer streams than before or even returning
+    // and empty stream collection (see crbug.com/668604). So we are going to
+    // check here that GetStreams will be invoked exactly 3 times during
     // RendererImpl initialization to help catch potential issues. Currently the
-    // GetStream is invoked once directly from RendererImpl::Initialize, once
-    // indirectly from RendererImpl::Initialize via HasEncryptedStream and once
-    // from RendererImpl::InitializeVideoRenderer.
-    EXPECT_CALL(*demuxer_, GetStream(DemuxerStream::VIDEO))
-        .Times(2)
-        .WillRepeatedly(Return(video_stream_.get()));
+    // GetStreams is invoked once from the RendererImpl::Initialize via
+    // HasEncryptedStream, once from the RendererImpl::InitializeAudioRenderer
+    // and once from the RendererImpl::InitializeVideoRenderer.
+    std::vector<DemuxerStream*> streams;
+    streams.push_back(video_stream_.get());
+    EXPECT_CALL(*demuxer_, GetStreams())
+        .Times(3)
+        .WillRepeatedly(Return(streams));
     InitializeAndExpect(PIPELINE_OK);
   }
 
   void InitializeWithAudioAndVideo() {
     CreateAudioAndVideoStream();
     SetAudioRendererInitializeExpectations(PIPELINE_OK);
     SetVideoRendererInitializeExpectations(PIPELINE_OK);
     InitializeAndExpect(PIPELINE_OK);
   }
 
@@ skipping 542 matching lines @@
   EXPECT_CALL(*video_renderer_, StartPlayingFrom(kStartTime));
   renderer_impl_->StartPlayingFrom(kStartTime);
 
   // Nothing else should primed on the message loop.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(RendererImplTest, StreamStatusNotificationHandling) {
   CreateAudioAndVideoStream();
 
-  DemuxerStream::StreamStatusChangeCB audio_stream_status_change_cb;
-  DemuxerStream::StreamStatusChangeCB video_stream_status_change_cb;
-  EXPECT_CALL(*audio_stream_, SetStreamStatusChangeCB(_))
-      .WillOnce(SaveArg<0>(&audio_stream_status_change_cb));
-  EXPECT_CALL(*video_stream_, SetStreamStatusChangeCB(_))
-      .WillOnce(SaveArg<0>(&video_stream_status_change_cb));
+  StreamStatusChangeCB stream_status_change_cb;
+  EXPECT_CALL(*demuxer_, SetStreamStatusChangeCB(_))
+      .WillOnce(SaveArg<0>(&stream_status_change_cb));
   SetAudioRendererInitializeExpectations(PIPELINE_OK);
   SetVideoRendererInitializeExpectations(PIPELINE_OK);
   InitializeAndExpect(PIPELINE_OK);
   Play();
 
   // Verify that DemuxerStream status changes cause the corresponding
   // audio/video renderer to be flushed and restarted.
   EXPECT_CALL(time_source_, StopTicking());
   EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(RunClosure<0>());
   EXPECT_CALL(*audio_renderer_, StartPlaying())
       .Times(1)
       .WillOnce(
           SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_ENOUGH));
-  audio_stream_status_change_cb.Run(false, base::TimeDelta());
+  stream_status_change_cb.Run(audio_stream_.get(), false, base::TimeDelta());
 
   EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunClosure<0>());
   EXPECT_CALL(*video_renderer_, StartPlayingFrom(_))
       .Times(1)
       .WillOnce(DoAll(
           SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_ENOUGH),
           PostQuitWhenIdle()));
 
-  video_stream_status_change_cb.Run(false, base::TimeDelta());
+  stream_status_change_cb.Run(video_stream_.get(), false, base::TimeDelta());
   base::RunLoop().Run();
 }
 
 // Stream status changes are handled asynchronously by the renderer and may take
 // some time to process. This test verifies that all status changes are
 // processed correctly by the renderer even if status changes of the stream
 // happen much faster than the renderer can process them. In that case the
 // renderer may postpone processing status changes, but still must process all
 // of them eventually.
 TEST_F(RendererImplTest, PostponedStreamStatusNotificationHandling) {
   CreateAudioAndVideoStream();
 
-  DemuxerStream::StreamStatusChangeCB audio_stream_status_change_cb;
-  DemuxerStream::StreamStatusChangeCB video_stream_status_change_cb;
-  EXPECT_CALL(*audio_stream_, SetStreamStatusChangeCB(_))
-      .WillOnce(SaveArg<0>(&audio_stream_status_change_cb));
-  EXPECT_CALL(*video_stream_, SetStreamStatusChangeCB(_))
-      .WillOnce(SaveArg<0>(&video_stream_status_change_cb));
+  StreamStatusChangeCB stream_status_change_cb;
+  EXPECT_CALL(*demuxer_, SetStreamStatusChangeCB(_))
+      .WillOnce(SaveArg<0>(&stream_status_change_cb));
   SetAudioRendererInitializeExpectations(PIPELINE_OK);
   SetVideoRendererInitializeExpectations(PIPELINE_OK);
   InitializeAndExpect(PIPELINE_OK);
   Play();
 
   EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(2);
 
   EXPECT_CALL(time_source_, StopTicking()).Times(2);
   EXPECT_CALL(time_source_, StartTicking()).Times(2);
   EXPECT_CALL(*audio_renderer_, Flush(_))
       .Times(2)
       .WillRepeatedly(DoAll(
           SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_NOTHING),
           WithArg<0>(PostCallback())));
   EXPECT_CALL(*audio_renderer_, StartPlaying())
       .Times(2)
       .WillOnce(
           SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_ENOUGH))
       .WillOnce(DoAll(
           SetBufferingState(&audio_renderer_client_, BUFFERING_HAVE_ENOUGH),
           PostQuitWhenIdle()));
   // The first stream status change will be processed immediately. Each status
   // change processing involves Flush + StartPlaying when the Flush is done. The
   // Flush operation is async in this case, so the second status change will be
   // postponed by renderer until after processing the first one is finished. But
   // we must still get two pairs of Flush/StartPlaying calls eventually.
-  audio_stream_status_change_cb.Run(false, base::TimeDelta());
-  audio_stream_status_change_cb.Run(true, base::TimeDelta());
+  stream_status_change_cb.Run(audio_stream_.get(), false, base::TimeDelta());
+  stream_status_change_cb.Run(audio_stream_.get(), true, base::TimeDelta());
   base::RunLoop().Run();
 
   EXPECT_CALL(*video_renderer_, Flush(_))
       .Times(2)
       .WillRepeatedly(DoAll(
           SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_NOTHING),
           WithArg<0>(PostCallback())));
   EXPECT_CALL(*video_renderer_, StartPlayingFrom(base::TimeDelta()))
       .Times(2)
       .WillOnce(
           SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_ENOUGH))
       .WillOnce(DoAll(
           SetBufferingState(&video_renderer_client_, BUFFERING_HAVE_ENOUGH),
           PostQuitWhenIdle()));
   // The first stream status change will be processed immediately. Each status
   // change processing involves Flush + StartPlaying when the Flush is done. The
   // Flush operation is async in this case, so the second status change will be
   // postponed by renderer until after processing the first one is finished. But
   // we must still get two pairs of Flush/StartPlaying calls eventually.
-  video_stream_status_change_cb.Run(false, base::TimeDelta());
-  video_stream_status_change_cb.Run(true, base::TimeDelta());
+  stream_status_change_cb.Run(video_stream_.get(), false, base::TimeDelta());
+  stream_status_change_cb.Run(video_stream_.get(), true, base::TimeDelta());
   base::RunLoop().Run();
 }
 
 }  // namespace media