media: Replace DecryptorReadyCB with CdmReadyCB.

media/filters/decoder_selector.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 "decoder_selector.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 60 matching lines @@
   if (!select_decoder_cb_.is_null())
     ReturnNullDecoder();
 
   decoder_.reset();
   decrypted_stream_.reset();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::SelectDecoder(
     DemuxerStream* stream,
-    const SetDecryptorReadyCB& set_decryptor_ready_cb,
+    const SetCdmReadyCB& set_cdm_ready_cb,
     const SelectDecoderCB& select_decoder_cb,
     const typename Decoder::OutputCB& output_cb,
     const base::Closure& waiting_for_decryption_key_cb) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(stream);
   DCHECK(select_decoder_cb_.is_null());
 
-  set_decryptor_ready_cb_ = set_decryptor_ready_cb;
+  set_cdm_ready_cb_ = set_cdm_ready_cb;
   waiting_for_decryption_key_cb_ = waiting_for_decryption_key_cb;
 
   // Make sure |select_decoder_cb| runs on a different execution stack.
   select_decoder_cb_ = BindToCurrentLoop(select_decoder_cb);
 
   if (!HasValidStreamConfig(stream)) {
     DLOG(ERROR) << "Invalid stream config.";
     ReturnNullDecoder();
     return;
   }
 
   input_stream_ = stream;
   output_cb_ = output_cb;
 
   if (!IsStreamEncrypted(input_stream_)) {
     InitializeDecoder();
     return;
   }
 
   // This could be null during fallback after decoder reinitialization failure.
   // See DecoderStream<StreamType>::OnDecoderReinitialized().
-  if (set_decryptor_ready_cb_.is_null()) {
+  if (set_cdm_ready_cb_.is_null()) {
     ReturnNullDecoder();
     return;
   }
 
 #if !defined(OS_ANDROID)
   InitializeDecryptingDecoder();
 #else
   InitializeDecryptingDemuxerStream();
 #endif
 }
 
 #if !defined(OS_ANDROID)
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::InitializeDecryptingDecoder() {
   decoder_.reset(new typename StreamTraits::DecryptingDecoderType(
-      task_runner_, media_log_, set_decryptor_ready_cb_,
+      task_runner_, media_log_, set_cdm_ready_cb_,
       waiting_for_decryption_key_cb_));
 
   DecoderStreamTraits<StreamType>::InitializeDecoder(
       decoder_.get(), input_stream_,
       base::Bind(&DecoderSelector<StreamType>::DecryptingDecoderInitDone,
                  weak_ptr_factory_.GetWeakPtr()),
       output_cb_);
 }
 
 template <DemuxerStream::Type StreamType>
@@ skipping 10 matching lines @@
   decoder_.reset();
 
   // When we get here decrypt-and-decode is not supported. Try to use
   // DecryptingDemuxerStream to do decrypt-only.
   InitializeDecryptingDemuxerStream();
 }
 #endif  // !defined(OS_ANDROID)
 
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::InitializeDecryptingDemuxerStream() {
-  decrypted_stream_.reset(new DecryptingDemuxerStream(
-      task_runner_, media_log_, set_decryptor_ready_cb_,
-      waiting_for_decryption_key_cb_));
+  decrypted_stream_.reset(
+      new DecryptingDemuxerStream(task_runner_, media_log_, set_cdm_ready_cb_,
+                                  waiting_for_decryption_key_cb_));
 
   decrypted_stream_->Initialize(
       input_stream_,
       base::Bind(&DecoderSelector<StreamType>::DecryptingDemuxerStreamInitDone,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::DecryptingDemuxerStreamInitDone(
     PipelineStatus status) {
@@ skipping 63 matching lines @@
 
 // These forward declarations tell the compiler that we will use
 // DecoderSelector with these arguments, allowing us to keep these definitions
 // in our .cc without causing linker errors. This also means if anyone tries to
 // instantiate a DecoderSelector with anything but these two specializations
 // they'll most likely get linker errors.
 template class DecoderSelector<DemuxerStream::AUDIO>;
 template class DecoderSelector<DemuxerStream::VIDEO>;
 
 }  // namespace media