media: Remove SetCdmReadyCB and CdmReadyCB (part 1).

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 <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 35 matching lines @@
     CallbackHelper() {}
     virtual ~CallbackHelper() {}
 
     MOCK_METHOD1(OnInitialize, void(PipelineStatus));
     MOCK_METHOD0(OnFlushed, void());
     MOCK_METHOD0(OnEnded, void());
     MOCK_METHOD1(OnError, void(PipelineStatus));
     MOCK_METHOD1(OnUpdateStatistics, void(const PipelineStatistics&));
     MOCK_METHOD1(OnBufferingStateChange, void(BufferingState));
     MOCK_METHOD0(OnWaitingForDecryptionKey, void());
+    MOCK_METHOD1(OnCdmAttached, void(bool));
 
    private:
     DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
   };
 
   RendererImplTest()
       : demuxer_(new StrictMock<MockDemuxer>()),
         video_renderer_(new StrictMock<MockVideoRenderer>()),
         audio_renderer_(new StrictMock<MockAudioRenderer>()),
         renderer_impl_(
             new RendererImpl(message_loop_.task_runner(),
                              scoped_ptr<AudioRenderer>(audio_renderer_),
-                             scoped_ptr<VideoRenderer>(video_renderer_))) {
+                             scoped_ptr<VideoRenderer>(video_renderer_))),
+        cdm_context_(new StrictMock<MockCdmContext>()),
+        initialization_status_(PIPELINE_ERROR_OPERATION_PENDING) {
     // SetDemuxerExpectations() adds overriding expectations for expected
     // non-NULL streams.
     DemuxerStream* null_pointer = NULL;
     EXPECT_CALL(*demuxer_, GetStream(_))
         .WillRepeatedly(Return(null_pointer));
   }
 
-  virtual ~RendererImplTest() {
+  virtual ~RendererImplTest() { Destroy(); }
+
+ protected:
+  typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
+
+  void Destroy() {
     renderer_impl_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
- protected:
-  typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
-
   scoped_ptr<StrictMock<MockDemuxerStream> > CreateStream(
       DemuxerStream::Type type) {
     scoped_ptr<StrictMock<MockDemuxerStream> > stream(
         new StrictMock<MockDemuxerStream>(type));
     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<4>(&audio_buffering_state_cb_),
                         SaveArg<5>(&audio_ended_cb_),
                         SaveArg<6>(&audio_error_cb_), RunCallback<1>(status)));
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void SetVideoRendererInitializeExpectations(PipelineStatus status) {
     EXPECT_CALL(*video_renderer_,
                 Initialize(video_stream_.get(), _, _, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<4>(&video_buffering_state_cb_),
                         SaveArg<5>(&video_ended_cb_), RunCallback<1>(status)));
   }
 
   void InitializeAndExpect(PipelineStatus start_status) {
-    EXPECT_CALL(callbacks_, OnInitialize(start_status));
+    EXPECT_CALL(callbacks_, OnInitialize(start_status))
+        .WillOnce(SaveArg<0>(&initialization_status_));
     EXPECT_CALL(callbacks_, OnWaitingForDecryptionKey()).Times(0);
 
     if (start_status == PIPELINE_OK && audio_stream_) {
       EXPECT_CALL(*audio_renderer_, GetTimeSource())
           .WillOnce(Return(&time_source_));
     } else {
       renderer_impl_->set_time_source_for_testing(&time_source_);
     }
 
     renderer_impl_->Initialize(
@@ skipping 11 matching lines @@
     base::RunLoop().RunUntilIdle();
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
     streams_.push_back(audio_stream_.get());
     EXPECT_CALL(*demuxer_, GetStream(DemuxerStream::AUDIO))
         .WillRepeatedly(Return(audio_stream_.get()));
   }
 
-  void CreateVideoStream() {
+  void CreateVideoStream(bool is_encrypted = false) {
     video_stream_ = CreateStream(DemuxerStream::VIDEO);
-    video_stream_->set_video_decoder_config(video_decoder_config_);
+    video_stream_->set_video_decoder_config(
+        is_encrypted ? TestVideoConfig::NormalEncrypted()
+                     : TestVideoConfig::Normal());
     streams_.push_back(video_stream_.get());
     EXPECT_CALL(*demuxer_, GetStream(DemuxerStream::VIDEO))
         .WillRepeatedly(Return(video_stream_.get()));
   }
 
+  void CreateEncryptedVideoStream() { CreateVideoStream(true); }
+
   void CreateAudioAndVideoStream() {
     CreateAudioStream();
     CreateVideoStream();
   }
 
   void InitializeWithAudio() {
     CreateAudioStream();
     SetAudioRendererInitializeExpectations(PIPELINE_OK);
     InitializeAndExpect(PIPELINE_OK);
   }
@@ skipping 82 matching lines @@
       return true;
 
     DCHECK_EQ(start_time_ms, GetMediaTimeMs());
     return false;
   }
 
   bool IsMediaTimeAdvancing() {
     return IsMediaTimeAdvancing(1.0);
   }
 
+  void SetCdmAndExpect(bool expected_result) {
+    EXPECT_CALL(callbacks_, OnCdmAttached(expected_result));
+    renderer_impl_->SetCdm(cdm_context_.get(),
+                           base::Bind(&CallbackHelper::OnCdmAttached,
+                                      base::Unretained(&callbacks_)));
+    base::RunLoop().RunUntilIdle();
+  }
+
   // Fixture members.
   base::MessageLoop message_loop_;
   StrictMock<CallbackHelper> callbacks_;
   base::SimpleTestTickClock test_tick_clock_;
 
   scoped_ptr<StrictMock<MockDemuxer> > demuxer_;
   StrictMock<MockVideoRenderer>* video_renderer_;
   StrictMock<MockAudioRenderer>* audio_renderer_;
   scoped_ptr<RendererImpl> renderer_impl_;
+  scoped_ptr<StrictMock<MockCdmContext>> cdm_context_;
 
   StrictMock<MockTimeSource> time_source_;
   scoped_ptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_;
   MockDemuxerStreamVector streams_;
   BufferingStateCB audio_buffering_state_cb_;
   BufferingStateCB video_buffering_state_cb_;
   base::Closure audio_ended_cb_;
   base::Closure video_ended_cb_;
   PipelineStatusCB audio_error_cb_;
   VideoDecoderConfig video_decoder_config_;
+  PipelineStatus initialization_status_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RendererImplTest);
 };
 
-TEST_F(RendererImplTest, DestroyBeforeInitialize) {
-  // |renderer_impl_| will be destroyed in the dtor.
+TEST_F(RendererImplTest, Destroy_BeforeInitialize) {
+  Destroy();
+}
+
+TEST_F(RendererImplTest, Destroy_PendingInitialize) {
+  CreateAudioAndVideoStream();
+
+  SetAudioRendererInitializeExpectations(PIPELINE_OK);
+  // Not returning the video initialization callback.
+  EXPECT_CALL(*video_renderer_,
+              Initialize(video_stream_.get(), _, _, _, _, _, _, _, _));
+
+  InitializeAndExpect(PIPELINE_ERROR_ABORT);
+  EXPECT_EQ(PIPELINE_ERROR_OPERATION_PENDING, initialization_status_);
+
+  Destroy();
+}
+
+TEST_F(RendererImplTest, Destroy_PendingInitializeWithoutCdm) {
+  CreateAudioStream();
+  CreateEncryptedVideoStream();
+
+  // Audio is clear and video is encrypted. Initialization will not start
+  // because no CDM is set. So neither AudioRenderer::Initialize() nor
+  // VideoRenderer::Initialize() should not be called. The InitCB will be
+  // aborted when |renderer_impl_| is destructed.
+  InitializeAndExpect(PIPELINE_ERROR_ABORT);
+  EXPECT_EQ(PIPELINE_ERROR_OPERATION_PENDING, initialization_status_);
+
+  Destroy();
+}
+
+TEST_F(RendererImplTest, Destroy_PendingInitializeAfterSetCdm) {
+  CreateAudioStream();
+  CreateEncryptedVideoStream();
+
+  // Audio is clear and video is encrypted. Initialization will not start
+  // because no CDM is set.
+  InitializeAndExpect(PIPELINE_ERROR_ABORT);
+  EXPECT_EQ(PIPELINE_ERROR_OPERATION_PENDING, initialization_status_);
+
+  SetAudioRendererInitializeExpectations(PIPELINE_OK);
+  // Not returning the video initialization callback. So initialization will
+  // be pending.
+  EXPECT_CALL(*video_renderer_,
+              Initialize(video_stream_.get(), _, _, _, _, _, _, _, _));
+
+  // SetCdm() will trigger the initialization to start. But it will not complete
+  // because the |video_renderer_| is not returning the initialization callback.
+  SetCdmAndExpect(false);
+  EXPECT_EQ(PIPELINE_ERROR_OPERATION_PENDING, initialization_status_);
+
+  Destroy();
 }
 
 TEST_F(RendererImplTest, InitializeWithAudio) {
   InitializeWithAudio();
 }
 
 TEST_F(RendererImplTest, InitializeWithVideo) {
   InitializeWithVideo();
 }
 
@@ skipping 20 matching lines @@
   InitializeAndExpect(PIPELINE_ERROR_INITIALIZATION_FAILED);
 }
 
 TEST_F(RendererImplTest, InitializeWithAudioVideo_VideoRendererFailed) {
   CreateAudioAndVideoStream();
   SetAudioRendererInitializeExpectations(PIPELINE_OK);
   SetVideoRendererInitializeExpectations(PIPELINE_ERROR_INITIALIZATION_FAILED);
   InitializeAndExpect(PIPELINE_ERROR_INITIALIZATION_FAILED);
 }
 
+TEST_F(RendererImplTest, SetCdmBeforeInitialize) {
+  // CDM will be successfully attached immediately if set before RendererImpl
+  // initialization, regardless of the later initialization result.
+  SetCdmAndExpect(true);
+}
+
+TEST_F(RendererImplTest, SetCdmAfterInitialize_ClearStream) {
+  InitializeWithAudioAndVideo();
+  EXPECT_EQ(PIPELINE_OK, initialization_status_);
+
+  // CDM will be successfully attached immediately since initialization is
+  // completed.
+  SetCdmAndExpect(true);
+}
+
+TEST_F(RendererImplTest, SetCdmAfterInitialize_EncryptedStream_Success) {
+  CreateAudioStream();
+  CreateEncryptedVideoStream();
+
+  SetAudioRendererInitializeExpectations(PIPELINE_OK);
+  SetVideoRendererInitializeExpectations(PIPELINE_OK);
+  InitializeAndExpect(PIPELINE_OK);
+  // Initialization is pending until CDM is set.
+  EXPECT_EQ(PIPELINE_ERROR_OPERATION_PENDING, initialization_status_);
+
+  SetCdmAndExpect(true);
+  EXPECT_EQ(PIPELINE_OK, initialization_status_);
+}
+
+TEST_F(RendererImplTest, SetCdmAfterInitialize_EncryptedStream_Failure) {
+  CreateAudioStream();
+  CreateEncryptedVideoStream();
+
+  SetAudioRendererInitializeExpectations(PIPELINE_OK);
+  SetVideoRendererInitializeExpectations(PIPELINE_ERROR_INITIALIZATION_FAILED);
+  InitializeAndExpect(PIPELINE_ERROR_INITIALIZATION_FAILED);
+  // Initialization is pending until CDM is set.
+  EXPECT_EQ(PIPELINE_ERROR_OPERATION_PENDING, initialization_status_);
+
+  SetCdmAndExpect(false);
+  EXPECT_EQ(PIPELINE_ERROR_INITIALIZATION_FAILED, initialization_status_);
+}
+
+TEST_F(RendererImplTest, SetCdmMultipleTimes) {
+  SetCdmAndExpect(true);
+  SetCdmAndExpect(false);  // Do not support switching CDM.
+}
+
 TEST_F(RendererImplTest, StartPlayingFrom) {
   InitializeWithAudioAndVideo();
   Play();
 }
 
 TEST_F(RendererImplTest, StartPlayingFromWithPlaybackRate) {
   InitializeWithAudioAndVideo();
 
   // Play with a zero playback rate shouldn't start time.
   Play();
@@ skipping 271 matching lines @@
       .WillOnce(
           SetBufferingState(&audio_buffering_state_cb_, BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(*video_renderer_, StartPlayingFrom(kStartTime));
   renderer_impl_->StartPlayingFrom(kStartTime);
 
   // Nothing else should primed on the message loop.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace media