media: Replace DecryptorReadyCB with CdmReadyCB.

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 103 matching lines @@
   DCHECK(cdm_context);
 
   if (cdm_context_) {
     DVLOG(1) << "Switching CDM not supported.";
     cdm_attached_cb.Run(false);
     return;
   }
 
   cdm_context_ = cdm_context;
 
-  if (decryptor_ready_cb_.is_null()) {
+  if (cdm_ready_cb_.is_null()) {
     cdm_attached_cb.Run(true);
     return;
   }
 
-  base::ResetAndReturn(&decryptor_ready_cb_)
-      .Run(cdm_context->GetDecryptor(), cdm_attached_cb);
+  base::ResetAndReturn(&cdm_ready_cb_).Run(cdm_context, cdm_attached_cb);
 }
 
 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::SetDecryptorReadyCallback(
-    const DecryptorReadyCB& decryptor_ready_cb) {
-  // Cancels the previous decryptor request.
-  if (decryptor_ready_cb.is_null()) {
-    if (!decryptor_ready_cb_.is_null()) {
-      base::ResetAndReturn(&decryptor_ready_cb_)
+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;
   }
 
   // We initialize audio and video decoders in sequence.
-  DCHECK(decryptor_ready_cb_.is_null());
+  DCHECK(cdm_ready_cb_.is_null());
 
   if (cdm_context_) {
-    decryptor_ready_cb.Run(cdm_context_->GetDecryptor(),
-                           base::Bind(IgnoreCdmAttached));
+    cdm_ready_cb.Run(cdm_context_, base::Bind(IgnoreCdmAttached));
     return;
   }
 
-  decryptor_ready_cb_ = decryptor_ready_cb;
+  cdm_ready_cb_ = cdm_ready_cb;
 }
 
 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::SetDecryptorReadyCallback, weak_this_),
+      base::Bind(&RendererImpl::SetCdmReadyCallback, weak_this_),
       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;
@@ skipping 26 matching lines @@
       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::SetDecryptorReadyCallback, weak_this_),
+      base::Bind(&RendererImpl::SetCdmReadyCallback, weak_this_),
       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) {
@@ skipping 288 matching lines @@
   }
 
   // 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