media: Remove SetCdmReadyCB and CdmReadyCB (part 1).

media/renderers/renderer_impl.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 "media/renderers/renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
+#include "media/base/audio_decoder_config.h"
 #include "media/base/audio_renderer.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream_provider.h"
 #include "media/base/media_switches.h"
 #include "media/base/time_source.h"
+#include "media/base/video_decoder_config.h"
 #include "media/base/video_renderer.h"
 #include "media/base/wall_clock_time_source.h"
 
 namespace media {
 
 // See |video_underflow_threshold_|.
 static const int kDefaultVideoUnderflowThresholdMs = 3000;
 
 RendererImpl::RendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
@@ skipping 33 matching lines @@
 
 RendererImpl::~RendererImpl() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Tear down in opposite order of construction as |video_renderer_| can still
   // need |time_source_| (which can be |audio_renderer_|) to be alive.
   video_renderer_.reset();
   audio_renderer_.reset();
 
-  if (!init_cb_.is_null())
-    base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
-  else if (!flush_cb_.is_null())
+  if (!init_cb_.is_null()) {
+    FinishInitialization(PIPELINE_ERROR_ABORT);
+  } else if (!flush_cb_.is_null()) {
     base::ResetAndReturn(&flush_cb_).Run();
+  }
 }
 
 void RendererImpl::Initialize(
     DemuxerStreamProvider* demuxer_stream_provider,
     const PipelineStatusCB& init_cb,
     const StatisticsCB& statistics_cb,
     const BufferingStateCB& buffering_state_cb,
     const base::Closure& ended_cb,
     const PipelineStatusCB& error_cb,
     const base::Closure& waiting_for_decryption_key_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!buffering_state_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!error_cb.is_null());
   DCHECK(demuxer_stream_provider->GetStream(DemuxerStream::AUDIO) ||
          demuxer_stream_provider->GetStream(DemuxerStream::VIDEO));
 
   demuxer_stream_provider_ = demuxer_stream_provider;
   statistics_cb_ = statistics_cb;
   buffering_state_cb_ = buffering_state_cb;
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   init_cb_ = init_cb;
   waiting_for_decryption_key_cb_ = waiting_for_decryption_key_cb;
 
+  if (HasEncryptedStream() && !cdm_context_) {
+    state_ = STATE_INIT_PENDING_CDM;
+    return;
+  }
+
   state_ = STATE_INITIALIZING;
   InitializeAudioRenderer();
 }
 
 void RendererImpl::SetCdm(CdmContext* cdm_context,
                           const CdmAttachedCB& cdm_attached_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(cdm_context);
 
   if (cdm_context_) {
     DVLOG(1) << "Switching CDM not supported.";
     cdm_attached_cb.Run(false);
     return;
   }
 
   cdm_context_ = cdm_context;
 
-  if (cdm_ready_cb_.is_null()) {
+  if (state_ != STATE_INIT_PENDING_CDM) {
     cdm_attached_cb.Run(true);
     return;
   }
 
-  base::ResetAndReturn(&cdm_ready_cb_).Run(cdm_context, cdm_attached_cb);
+  DCHECK(!init_cb_.is_null());
+  state_ = STATE_INITIALIZING;
+  // |cdm_attached_cb| will be fired after initialization finishes.
+  pending_cdm_attached_cb_ = cdm_attached_cb;
+
+  InitializeAudioRenderer();
 }
 
 void RendererImpl::Flush(const base::Closure& flush_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(flush_cb_.is_null());
 
   if (state_ != STATE_PLAYING) {
     DCHECK_EQ(state_, STATE_ERROR);
     return;
@@ skipping 105 matching lines @@
       for (auto const &media_time : media_timestamps) {
         wall_clock_times->push_back(base::TimeTicks() + media_time);
       }
     }
     return true;
   }
 
   return time_source_->GetWallClockTimes(media_timestamps, wall_clock_times);
 }
 
-void RendererImpl::SetCdmReadyCallback(const CdmReadyCB& cdm_ready_cb) {
-  // Cancels the previous CDM request.
-  if (cdm_ready_cb.is_null()) {
-    if (!cdm_ready_cb_.is_null()) {
-      base::ResetAndReturn(&cdm_ready_cb_)
-          .Run(nullptr, base::Bind(IgnoreCdmAttached));
-    }
-    return;
-  }
+bool RendererImpl::HasEncryptedStream() {
+  DemuxerStream* audio_stream =
+      demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO);
+  if (audio_stream && audio_stream->audio_decoder_config().is_encrypted())
+    return true;
 
-  // We initialize audio and video decoders in sequence.
-  DCHECK(cdm_ready_cb_.is_null());
+  DemuxerStream* video_stream =
+      demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO);
+  if (video_stream && video_stream->video_decoder_config().is_encrypted())
+    return true;
 
-  if (cdm_context_) {
-    cdm_ready_cb.Run(cdm_context_, base::Bind(IgnoreCdmAttached));
-    return;
-  }
+  return false;
+}
 
-  cdm_ready_cb_ = cdm_ready_cb;
+void RendererImpl::FinishInitialization(PipelineStatus status) {
+  DCHECK(!init_cb_.is_null());
+
+  if (!pending_cdm_attached_cb_.is_null())
+    base::ResetAndReturn(&pending_cdm_attached_cb_).Run(status == PIPELINE_OK);
+
+  base::ResetAndReturn(&init_cb_).Run(status);
 }
 
 void RendererImpl::InitializeAudioRenderer() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_INITIALIZING);
   DCHECK(!init_cb_.is_null());
 
   PipelineStatusCB done_cb =
       base::Bind(&RendererImpl::OnAudioRendererInitializeDone, weak_this_);
 
   if (!demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO)) {
     audio_renderer_.reset();
     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
     return;
   }
 
   // Note: After the initialization of a renderer, error events from it may
   // happen at any time and all future calls must guard against STATE_ERROR.
   audio_renderer_->Initialize(
       demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO), done_cb,
-      base::Bind(&RendererImpl::SetCdmReadyCallback, weak_this_),
-      base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
+      cdm_context_, base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
       base::Bind(&RendererImpl::OnBufferingStateChanged, weak_this_,
                  &audio_buffering_state_),
       base::Bind(&RendererImpl::OnAudioRendererEnded, weak_this_),
       base::Bind(&RendererImpl::OnError, weak_this_),
       waiting_for_decryption_key_cb_);
 }
 
 void RendererImpl::OnAudioRendererInitializeDone(PipelineStatus status) {
   DVLOG(1) << __FUNCTION__ << ": " << status;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // OnError() may be fired at any time by the renderers, even if they thought
   // they initialized successfully (due to delayed output device setup).
   if (state_ != STATE_INITIALIZING) {
     DCHECK(init_cb_.is_null());
     audio_renderer_.reset();
     return;
   }
 
   if (status != PIPELINE_OK) {
-    base::ResetAndReturn(&init_cb_).Run(status);
+    FinishInitialization(status);
     return;
   }
 
   DCHECK(!init_cb_.is_null());
   InitializeVideoRenderer();
 }
 
 void RendererImpl::InitializeVideoRenderer() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_INITIALIZING);
   DCHECK(!init_cb_.is_null());
 
   PipelineStatusCB done_cb =
       base::Bind(&RendererImpl::OnVideoRendererInitializeDone, weak_this_);
 
   if (!demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO)) {
     video_renderer_.reset();
     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
     return;
   }
 
   video_renderer_->Initialize(
       demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO), done_cb,
-      base::Bind(&RendererImpl::SetCdmReadyCallback, weak_this_),
-      base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
+      cdm_context_, base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
       base::Bind(&RendererImpl::OnBufferingStateChanged, weak_this_,
                  &video_buffering_state_),
       base::Bind(&RendererImpl::OnVideoRendererEnded, weak_this_),
       base::Bind(&RendererImpl::OnError, weak_this_),
       base::Bind(&RendererImpl::GetWallClockTimes, base::Unretained(this)),
       waiting_for_decryption_key_cb_);
 }
 
 void RendererImpl::OnVideoRendererInitializeDone(PipelineStatus status) {
   DVLOG(1) << __FUNCTION__ << ": " << status;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // OnError() may be fired at any time by the renderers, even if they thought
   // they initialized successfully (due to delayed output device setup).
   if (state_ != STATE_INITIALIZING) {
     DCHECK(init_cb_.is_null());
     audio_renderer_.reset();
     video_renderer_.reset();
     return;
   }
 
   DCHECK(!init_cb_.is_null());
 
   if (status != PIPELINE_OK) {
-    base::ResetAndReturn(&init_cb_).Run(status);
+    FinishInitialization(status);
     return;
   }
 
   if (audio_renderer_) {
     time_source_ = audio_renderer_->GetTimeSource();
   } else if (!time_source_) {
     wall_clock_time_source_.reset(new WallClockTimeSource());
     time_source_ = wall_clock_time_source_.get();
   }
 
   state_ = STATE_PLAYING;
   DCHECK(time_source_);
   DCHECK(audio_renderer_ || video_renderer_);
-  base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
+
+  FinishInitialization(PIPELINE_OK);
 }
 
 void RendererImpl::FlushAudioRenderer() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_FLUSHING);
   DCHECK(!flush_cb_.is_null());
 
   if (!audio_renderer_) {
     OnAudioRendererFlushDone();
@@ skipping 143 matching lines @@
     case STATE_PLAYING:
       DCHECK(PlaybackHasEnded() || WaitingForEnoughData())
           << "Playback should only pause due to ending or underflowing";
       break;
 
     case STATE_FLUSHING:
       // It's OK to pause playback when flushing.
       break;
 
     case STATE_UNINITIALIZED:
+    case STATE_INIT_PENDING_CDM:
     case STATE_INITIALIZING:
       NOTREACHED() << "Invalid state: " << state_;
       break;
 
     case STATE_ERROR:
       // An error state may occur at any time.
       break;
   }
 
   time_ticking_ = false;
@@ skipping 72 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 
   // An error has already been delivered.
   if (state_ == STATE_ERROR)
     return;
 
   const State old_state = state_;
   state_ = STATE_ERROR;
 
-  if (old_state == STATE_INITIALIZING) {
-    base::ResetAndReturn(&init_cb_).Run(error);
+  if (!init_cb_.is_null()) {
+    DCHECK(old_state == STATE_INITIALIZING ||
+           old_state == STATE_INIT_PENDING_CDM);
+    FinishInitialization(error);
     return;
   }
 
   // After OnError() returns, the pipeline may destroy |this|.
   base::ResetAndReturn(&error_cb_).Run(error);
 
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 }
 
 }  // namespace media