media: Pass SetCdmReadyCB in {Audio|Video}Decoder::Initialize().

(This reverts commit 0c1df0a37a815953d1af3d4eaf145af969210d5d with fix.)

This enables all audio/video decoders the ability to get access to the CDM
associated with the media element. This is useful for certain decoders to handle
encrypted streams.

For Decrypting{Audio|Video}Decoder and DecryptingDemuxerStream, the SetCdmReadyCB
is simply moved from constructor to Initialize() call. In the future this could
also help move Decrypting{Audio|Video}Decoder creation out of DecoderSelector so
that it is treated the same as all other decoders.

TBR=bbudge@chromium.org,jrummell@chromium.org,dalecurtis@chromium.org
BUG=545099

Review URL: https://codereview.chromium.org/1447533006

Cr-Commit-Position: refs/heads/master@{#359754}

39 files changed, 189 insertions, 138 deletions

diff --git a/content/common/gpu/media/video_encode_accelerator_unittest.cc b/content/common/gpu/media/video_encode_accelerator_unittest.cc
index 1775614..0f80d07 100644
--- a/content/common/gpu/media/video_encode_accelerator_unittest.cc
+++ b/content/common/gpu/media/video_encode_accelerator_unittest.cc
@@ -27,6 +27,7 @@
 #include "content/common/gpu/media/video_accelerator_unittest_helpers.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
+#include "media/base/cdm_context.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_util.h"
 #include "media/base/test_data_util.h"
@@ -670,8 +671,9 @@ void VideoFrameQualityValidator::Initialize(const gfx::Size& coded_size,
     LOG_ASSERT(0) << "Invalid profile " << profile_;
 
   decoder_->Initialize(
-      config, false, base::Bind(&VideoFrameQualityValidator::InitializeCB,
-                                base::Unretained(this)),
+      config, false, media::SetCdmReadyCB(),
+      base::Bind(&VideoFrameQualityValidator::InitializeCB,
+                 base::Unretained(this)),
       base::Bind(&VideoFrameQualityValidator::VerifyOutputFrame,
                  base::Unretained(this)));
 }
diff --git a/content/renderer/media/android/media_source_delegate.cc b/content/renderer/media/android/media_source_delegate.cc
index 9b4d312..1f45238 100644
--- a/content/renderer/media/android/media_source_delegate.cc
+++ b/content/renderer/media/android/media_source_delegate.cc
@@ -520,10 +520,9 @@ void MediaSourceDelegate::InitAudioDecryptingDemuxerStream() {
   DCHECK(!set_cdm_ready_cb_.is_null());
 
   audio_decrypting_demuxer_stream_.reset(new media::DecryptingDemuxerStream(
-      media_task_runner_, media_log_, set_cdm_ready_cb_,
-      waiting_for_decryption_key_cb_));
+      media_task_runner_, media_log_, waiting_for_decryption_key_cb_));
   audio_decrypting_demuxer_stream_->Initialize(
-      audio_stream_,
+      audio_stream_, set_cdm_ready_cb_,
       base::Bind(&MediaSourceDelegate::OnAudioDecryptingDemuxerStreamInitDone,
                  media_weak_factory_.GetWeakPtr()));
 }
@@ -534,10 +533,9 @@ void MediaSourceDelegate::InitVideoDecryptingDemuxerStream() {
   DCHECK(!set_cdm_ready_cb_.is_null());
 
   video_decrypting_demuxer_stream_.reset(new media::DecryptingDemuxerStream(
-      media_task_runner_, media_log_, set_cdm_ready_cb_,
-      waiting_for_decryption_key_cb_));
+      media_task_runner_, media_log_, waiting_for_decryption_key_cb_));
   video_decrypting_demuxer_stream_->Initialize(
-      video_stream_,
+      video_stream_, set_cdm_ready_cb_,
       base::Bind(&MediaSourceDelegate::OnVideoDecryptingDemuxerStreamInitDone,
                  media_weak_factory_.GetWeakPtr()));
 }
diff --git a/content/renderer/pepper/video_decoder_shim.cc b/content/renderer/pepper/video_decoder_shim.cc
index 3f2c5e8..ae19127 100644
--- a/content/renderer/pepper/video_decoder_shim.cc
+++ b/content/renderer/pepper/video_decoder_shim.cc
@@ -21,6 +21,7 @@
 #include "content/renderer/pepper/pepper_video_decoder_host.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
+#include "media/base/cdm_context.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/media_util.h"
@@ -700,7 +701,7 @@ void VideoDecoderShim::DecoderImpl::Initialize(
   DCHECK_EQ(decoder_->GetMaxDecodeRequests(), 1);
 
   decoder_->Initialize(
-      config, true /* low_delay */,
+      config, true /* low_delay */, media::SetCdmReadyCB(),
       base::Bind(&VideoDecoderShim::DecoderImpl::OnInitDone,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&VideoDecoderShim::DecoderImpl::OnOutputComplete,
diff --git a/media/base/audio_decoder.h b/media/base/audio_decoder.h
index 3da8547..337d2a7 100644
--- a/media/base/audio_decoder.h
+++ b/media/base/audio_decoder.h
@@ -10,6 +10,7 @@
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "media/base/audio_decoder_config.h"
+#include "media/base/cdm_context.h"
 #include "media/base/channel_layout.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_export.h"
@@ -56,9 +57,15 @@ class MEDIA_EXPORT AudioDecoder {
 
   // Initializes an AudioDecoder with the given DemuxerStream, executing the
   // callback upon completion.
+  //
+  // |set_cdm_ready_cb| can be used to set/cancel a CdmReadyCB with which the
+  // decoder can be notified when a CDM is ready. The decoder can use the CDM to
+  // handle encrypted video stream.
+  //
   //  |init_cb| is used to return initialization status.
   //  |output_cb| is called for decoded audio buffers (see Decode()).
   virtual void Initialize(const AudioDecoderConfig& config,
+                          const SetCdmReadyCB& set_cdm_ready_cb,
                           const InitCB& init_cb,
                           const OutputCB& output_cb) = 0;
 
diff --git a/media/base/mock_filters.h b/media/base/mock_filters.h
index 5fb2a3e..c558430 100644
--- a/media/base/mock_filters.h
+++ b/media/base/mock_filters.h
@@ -86,9 +86,10 @@ class MockVideoDecoder : public VideoDecoder {
 
   // VideoDecoder implementation.
   virtual std::string GetDisplayName() const;
-  MOCK_METHOD4(Initialize,
+  MOCK_METHOD5(Initialize,
                void(const VideoDecoderConfig& config,
                     bool low_delay,
+                    const SetCdmReadyCB& set_cdm_ready_cb,
                     const InitCB& init_cb,
                     const OutputCB& output_cb));
   MOCK_METHOD2(Decode, void(const scoped_refptr<DecoderBuffer>& buffer,
@@ -107,8 +108,9 @@ class MockAudioDecoder : public AudioDecoder {
 
   // AudioDecoder implementation.
   virtual std::string GetDisplayName() const;
-  MOCK_METHOD3(Initialize,
+  MOCK_METHOD4(Initialize,
                void(const AudioDecoderConfig& config,
+                    const SetCdmReadyCB& set_cdm_ready_cb,
                     const InitCB& init_cb,
                     const OutputCB& output_cb));
   MOCK_METHOD2(Decode,
diff --git a/media/base/video_decoder.h b/media/base/video_decoder.h
index f7bae3c..074718b 100644
--- a/media/base/video_decoder.h
+++ b/media/base/video_decoder.h
@@ -9,6 +9,7 @@
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
+#include "media/base/cdm_context.h"
 #include "media/base/media_export.h"
 #include "media/base/pipeline_status.h"
 #include "ui/gfx/geometry/size.h"
@@ -63,6 +64,10 @@ class MEDIA_EXPORT VideoDecoder {
   // Initialization should fail if |low_delay| is true and the decoder cannot
   // satisfy the requirements above.
   //
+  // |set_cdm_ready_cb| can be used to set/cancel a CdmReadyCB with which the
+  // decoder can be notified when a CDM is ready. The decoder can use the CDM to
+  // handle encrypted video stream.
+  //
   // Note:
   // 1) The VideoDecoder will be reinitialized if it was initialized before.
   //    Upon reinitialization, all internal buffered frames will be dropped.
@@ -70,6 +75,7 @@ class MEDIA_EXPORT VideoDecoder {
   // 3) No VideoDecoder calls should be made before |init_cb| is executed.
   virtual void Initialize(const VideoDecoderConfig& config,
                           bool low_delay,
+                          const SetCdmReadyCB& set_cdm_ready_cb,
                           const InitCB& init_cb,
                           const OutputCB& output_cb) = 0;
 
diff --git a/media/cast/sender/h264_vt_encoder_unittest.cc b/media/cast/sender/h264_vt_encoder_unittest.cc
index e44d9f8..419cbb87 100644
--- a/media/cast/sender/h264_vt_encoder_unittest.cc
+++ b/media/cast/sender/h264_vt_encoder_unittest.cc
@@ -12,6 +12,7 @@
 #include "base/test/power_monitor_test_base.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/test/test_suite.h"
+#include "media/base/cdm_context.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media.h"
 #include "media/base/media_switches.h"
@@ -135,7 +136,8 @@ class EndToEndFrameChecker
         count_frames_checked_(0) {
     bool decoder_init_result;
     decoder_.Initialize(
-        config, false, base::Bind(&SaveDecoderInitResult, &decoder_init_result),
+        config, false, media::SetCdmReadyCB(),
+        base::Bind(&SaveDecoderInitResult, &decoder_init_result),
         base::Bind(&EndToEndFrameChecker::CompareFrameWithExpected,
                    base::Unretained(this)));
     base::MessageLoop::current()->RunUntilIdle();
diff --git a/media/filters/audio_decoder_selector_unittest.cc b/media/filters/audio_decoder_selector_unittest.cc
index b2b8a8a..2f5adaa 100644
--- a/media/filters/audio_decoder_selector_unittest.cc
+++ b/media/filters/audio_decoder_selector_unittest.cc
@@ -208,8 +208,8 @@ TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _))
-      .WillOnce(RunCallback<1>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
 
   SelectDecoder();
@@ -220,7 +220,7 @@ TEST_F(AudioDecoderSelectorTest,
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -231,10 +231,10 @@ TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _))
-      .WillOnce(RunCallback<1>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _))
-      .WillOnce(RunCallback<1>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
 
   SelectDecoder();
@@ -245,9 +245,9 @@ TEST_F(AudioDecoderSelectorTest,
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _))
-      .WillOnce(RunCallback<1>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -258,8 +258,8 @@ TEST_F(AudioDecoderSelectorTest, ClearStream_HasDecryptor) {
   UseClearStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _))
-      .WillOnce(RunCallback<1>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
 
   SelectDecoder();
@@ -269,7 +269,7 @@ TEST_F(AudioDecoderSelectorTest, Destroy_ClearStream_HasDecryptor) {
   UseClearStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -280,8 +280,8 @@ TEST_F(AudioDecoderSelectorTest, EncryptedStream_NoDecryptor_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _))
-      .WillOnce(RunCallback<1>(false));
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(false));
   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 
   SelectDecoder();
@@ -292,7 +292,7 @@ TEST_F(AudioDecoderSelectorTest,
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -303,10 +303,10 @@ TEST_F(AudioDecoderSelectorTest, EncryptedStream_NoDecryptor_MultipleDecoders) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _))
-      .WillOnce(RunCallback<1>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _))
-      .WillOnce(RunCallback<1>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
 
   SelectDecoder();
@@ -317,9 +317,9 @@ TEST_F(AudioDecoderSelectorTest,
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _))
-      .WillOnce(RunCallback<1>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -349,8 +349,8 @@ TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _))
-      .WillOnce(RunCallback<1>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull()));
 
   SelectDecoder();
@@ -361,7 +361,7 @@ TEST_F(AudioDecoderSelectorTest,
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -374,10 +374,10 @@ TEST_F(AudioDecoderSelectorTest,
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _))
-      .WillOnce(RunCallback<1>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _))
-      .WillOnce(RunCallback<1>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull()));
 
   SelectDecoder();
@@ -388,9 +388,9 @@ TEST_F(AudioDecoderSelectorTest,
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _))
-      .WillOnce(RunCallback<1>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -408,8 +408,8 @@ TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptAndDecode) {
 #else
   // A DecryptingDemuxerStream will be created. The clear decoder will be
   // initialized and returned.
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _))
-      .WillOnce(RunCallback<1>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(NotNull(), NotNull()));
 #endif
 
diff --git a/media/filters/audio_decoder_unittest.cc b/media/filters/audio_decoder_unittest.cc
index ae9f17a..0f07b4a 100644
--- a/media/filters/audio_decoder_unittest.cc
+++ b/media/filters/audio_decoder_unittest.cc
@@ -170,7 +170,7 @@ class AudioDecoderTest : public testing::TestWithParam<DecoderTestData> {
   void InitializeDecoderWithResult(const AudioDecoderConfig& config,
                                    bool success) {
     decoder_->Initialize(
-        config, NewExpectedBoolCB(success),
+        config, SetCdmReadyCB(), NewExpectedBoolCB(success),
         base::Bind(&AudioDecoderTest::OnDecoderOutput, base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
diff --git a/media/filters/decoder_selector.cc b/media/filters/decoder_selector.cc
index 0f99e79..4d06d9c 100644
--- a/media/filters/decoder_selector.cc
+++ b/media/filters/decoder_selector.cc
@@ -125,11 +125,10 @@ void DecoderSelector<StreamType>::SelectDecoder(
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::InitializeDecryptingDecoder() {
   decoder_.reset(new typename StreamTraits::DecryptingDecoderType(
-      task_runner_, media_log_, set_cdm_ready_cb_,
-      waiting_for_decryption_key_cb_));
+      task_runner_, media_log_, waiting_for_decryption_key_cb_));
 
   DecoderStreamTraits<StreamType>::InitializeDecoder(
-      decoder_.get(), input_stream_,
+      decoder_.get(), input_stream_, set_cdm_ready_cb_,
       base::Bind(&DecoderSelector<StreamType>::DecryptingDecoderInitDone,
                  weak_ptr_factory_.GetWeakPtr()),
       output_cb_);
@@ -156,12 +155,11 @@ void DecoderSelector<StreamType>::DecryptingDecoderInitDone(bool success) {
 
 template <DemuxerStream::Type StreamType>
 void DecoderSelector<StreamType>::InitializeDecryptingDemuxerStream() {
-  decrypted_stream_.reset(
-      new DecryptingDemuxerStream(task_runner_, media_log_, set_cdm_ready_cb_,
-                                  waiting_for_decryption_key_cb_));
+  decrypted_stream_.reset(new DecryptingDemuxerStream(
+      task_runner_, media_log_, waiting_for_decryption_key_cb_));
 
   decrypted_stream_->Initialize(
-      input_stream_,
+      input_stream_, set_cdm_ready_cb_,
       base::Bind(&DecoderSelector<StreamType>::DecryptingDemuxerStreamInitDone,
                  weak_ptr_factory_.GetWeakPtr()));
 }
@@ -203,7 +201,7 @@ void DecoderSelector<StreamType>::InitializeDecoder() {
   decoders_.weak_erase(decoders_.begin());
 
   DecoderStreamTraits<StreamType>::InitializeDecoder(
-      decoder_.get(), input_stream_,
+      decoder_.get(), input_stream_, set_cdm_ready_cb_,
       base::Bind(&DecoderSelector<StreamType>::DecoderInitDone,
                  weak_ptr_factory_.GetWeakPtr()),
       output_cb_);
diff --git a/media/filters/decoder_stream.cc b/media/filters/decoder_stream.cc
index 91a5b1e..772f126 100644
--- a/media/filters/decoder_stream.cc
+++ b/media/filters/decoder_stream.cc
@@ -516,8 +516,9 @@ void DecoderStream<StreamType>::ReinitializeDecoder() {
   DCHECK_EQ(pending_decode_requests_, 0);
 
   state_ = STATE_REINITIALIZING_DECODER;
+  // Decoders should not need CDMs during reinitialization.
   DecoderStreamTraits<StreamType>::InitializeDecoder(
-      decoder_.get(), stream_,
+      decoder_.get(), stream_, SetCdmReadyCB(),
       base::Bind(&DecoderStream<StreamType>::OnDecoderReinitialized,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
@@ -540,8 +541,8 @@ void DecoderStream<StreamType>::OnDecoderReinitialized(bool success) {
     // Reinitialization failed. Try to fall back to one of the remaining
     // decoders. This will consume at least one decoder so doing it more than
     // once is safe.
-    // For simplicity, don't attempt to fall back to a decryptor. Calling this
-    // with a null callback ensures that one won't be selected.
+    // For simplicity, don't attempt to fall back to a decrypting decoder.
+    // Calling this with a null callback ensures that one won't be selected.
     SelectDecoder(SetCdmReadyCB());
   } else {
     CompleteDecoderReinitialization(true);
diff --git a/media/filters/decoder_stream_traits.cc b/media/filters/decoder_stream_traits.cc
index 7583b17..c40d69f 100644
--- a/media/filters/decoder_stream_traits.cc
+++ b/media/filters/decoder_stream_traits.cc
@@ -21,10 +21,12 @@ std::string DecoderStreamTraits<DemuxerStream::AUDIO>::ToString() {
 void DecoderStreamTraits<DemuxerStream::AUDIO>::InitializeDecoder(
     DecoderType* decoder,
     DemuxerStream* stream,
+    const SetCdmReadyCB& set_cdm_ready_cb,
     const InitCB& init_cb,
     const OutputCB& output_cb) {
   DCHECK(stream->audio_decoder_config().IsValidConfig());
-  decoder->Initialize(stream->audio_decoder_config(), init_cb, output_cb);
+  decoder->Initialize(stream->audio_decoder_config(), set_cdm_ready_cb, init_cb,
+                      output_cb);
 }
 
 void DecoderStreamTraits<DemuxerStream::AUDIO>::ReportStatistics(
@@ -47,12 +49,13 @@ std::string DecoderStreamTraits<DemuxerStream::VIDEO>::ToString() {
 void DecoderStreamTraits<DemuxerStream::VIDEO>::InitializeDecoder(
     DecoderType* decoder,
     DemuxerStream* stream,
+    const SetCdmReadyCB& set_cdm_ready_cb,
     const InitCB& init_cb,
     const OutputCB& output_cb) {
   DCHECK(stream->video_decoder_config().IsValidConfig());
   decoder->Initialize(stream->video_decoder_config(),
                       stream->liveness() == DemuxerStream::LIVENESS_LIVE,
-                      init_cb, output_cb);
+                      set_cdm_ready_cb, init_cb, output_cb);
 }
 
 bool DecoderStreamTraits<DemuxerStream::VIDEO>::NeedsBitstreamConversion(
diff --git a/media/filters/decoder_stream_traits.h b/media/filters/decoder_stream_traits.h
index 8caf2df..920aefc 100644
--- a/media/filters/decoder_stream_traits.h
+++ b/media/filters/decoder_stream_traits.h
@@ -5,6 +5,7 @@
 #ifndef MEDIA_FILTERS_DECODER_STREAM_TRAITS_H_
 #define MEDIA_FILTERS_DECODER_STREAM_TRAITS_H_
 
+#include "media/base/cdm_context.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/pipeline_status.h"
 
@@ -32,6 +33,7 @@ struct DecoderStreamTraits<DemuxerStream::AUDIO> {
   static std::string ToString();
   static void InitializeDecoder(DecoderType* decoder,
                                 DemuxerStream* stream,
+                                const SetCdmReadyCB& set_cdm_ready_cb,
                                 const InitCB& init_cb,
                                 const OutputCB& output_cb);
   static bool NeedsBitstreamConversion(DecoderType* decoder) { return false; }
@@ -51,6 +53,7 @@ struct DecoderStreamTraits<DemuxerStream::VIDEO> {
   static std::string ToString();
   static void InitializeDecoder(DecoderType* decoder,
                                 DemuxerStream* stream,
+                                const SetCdmReadyCB& set_cdm_ready_cb,
                                 const InitCB& init_cb,
                                 const OutputCB& output_cb);
   static bool NeedsBitstreamConversion(DecoderType* decoder);
diff --git a/media/filters/decrypting_audio_decoder.cc b/media/filters/decrypting_audio_decoder.cc
index 1c620a7..42f1939 100644
--- a/media/filters/decrypting_audio_decoder.cc
+++ b/media/filters/decrypting_audio_decoder.cc
@@ -34,13 +34,11 @@ static inline bool IsOutOfSync(const base::TimeDelta& timestamp_1,
 DecryptingAudioDecoder::DecryptingAudioDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const scoped_refptr<MediaLog>& media_log,
-    const SetCdmReadyCB& set_cdm_ready_cb,
     const base::Closure& waiting_for_decryption_key_cb)
     : task_runner_(task_runner),
       media_log_(media_log),
       state_(kUninitialized),
       waiting_for_decryption_key_cb_(waiting_for_decryption_key_cb),
-      set_cdm_ready_cb_(set_cdm_ready_cb),
       decryptor_(NULL),
       key_added_while_decode_pending_(false),
       weak_factory_(this) {}
@@ -50,6 +48,7 @@ std::string DecryptingAudioDecoder::GetDisplayName() const {
 }
 
 void DecryptingAudioDecoder::Initialize(const AudioDecoderConfig& config,
+                                        const SetCdmReadyCB& set_cdm_ready_cb,
                                         const InitCB& init_cb,
                                         const OutputCB& output_cb) {
   DVLOG(2) << "Initialize()";
@@ -76,7 +75,9 @@ void DecryptingAudioDecoder::Initialize(const AudioDecoderConfig& config,
   config_ = config;
 
   if (state_ == kUninitialized) {
+    DCHECK(!set_cdm_ready_cb.is_null());
     state_ = kDecryptorRequested;
+    set_cdm_ready_cb_ = set_cdm_ready_cb;
     set_cdm_ready_cb_.Run(BindToCurrentLoop(
         base::Bind(&DecryptingAudioDecoder::SetCdm, weak_this_)));
     return;
diff --git a/media/filters/decrypting_audio_decoder.h b/media/filters/decrypting_audio_decoder.h
index b566fdd..43db799 100644
--- a/media/filters/decrypting_audio_decoder.h
+++ b/media/filters/decrypting_audio_decoder.h
@@ -35,13 +35,13 @@ class MEDIA_EXPORT DecryptingAudioDecoder : public AudioDecoder {
   DecryptingAudioDecoder(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       const scoped_refptr<MediaLog>& media_log,
-      const SetCdmReadyCB& set_cdm_ready_cb,
       const base::Closure& waiting_for_decryption_key_cb);
   ~DecryptingAudioDecoder() override;
 
   // AudioDecoder implementation.
   std::string GetDisplayName() const override;
   void Initialize(const AudioDecoderConfig& config,
+                  const SetCdmReadyCB& set_cdm_ready_cb,
                   const InitCB& init_cb,
                   const OutputCB& output_cb) override;
   void Decode(const scoped_refptr<DecoderBuffer>& buffer,
diff --git a/media/filters/decrypting_audio_decoder_unittest.cc b/media/filters/decrypting_audio_decoder_unittest.cc
index 016e09a4..733a6e6 100644
--- a/media/filters/decrypting_audio_decoder_unittest.cc
+++ b/media/filters/decrypting_audio_decoder_unittest.cc
@@ -64,8 +64,6 @@ class DecryptingAudioDecoderTest : public testing::Test {
       : decoder_(new DecryptingAudioDecoder(
             message_loop_.task_runner(),
             new MediaLog(),
-            base::Bind(&DecryptingAudioDecoderTest::RequestCdmNotification,
-                       base::Unretained(this)),
             base::Bind(&DecryptingAudioDecoderTest::OnWaitingForDecryptionKey,
                        base::Unretained(this)))),
         cdm_context_(new StrictMock<MockCdmContext>()),
@@ -96,9 +94,12 @@ class DecryptingAudioDecoderTest : public testing::Test {
                                                     kNoTimestamp());
     decoded_frame_list_.push_back(decoded_frame_);
 
-    decoder_->Initialize(config, NewExpectedBoolCB(success),
-                         base::Bind(&DecryptingAudioDecoderTest::FrameReady,
-                                    base::Unretained(this)));
+    decoder_->Initialize(
+        config, base::Bind(&DecryptingAudioDecoderTest::RequestCdmNotification,
+                           base::Unretained(this)),
+        NewExpectedBoolCB(success),
+        base::Bind(&DecryptingAudioDecoderTest::FrameReady,
+                   base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
@@ -145,7 +146,7 @@ class DecryptingAudioDecoderTest : public testing::Test {
         .WillOnce(RunCallback<1>(true));
     EXPECT_CALL(*decryptor_, RegisterNewKeyCB(Decryptor::kAudio, _))
               .WillOnce(SaveArg<1>(&key_added_cb_));
-    decoder_->Initialize(new_config, NewExpectedBoolCB(true),
+    decoder_->Initialize(new_config, SetCdmReadyCB(), NewExpectedBoolCB(true),
                          base::Bind(&DecryptingAudioDecoderTest::FrameReady,
                                     base::Unretained(this)));
   }
diff --git a/media/filters/decrypting_demuxer_stream.cc b/media/filters/decrypting_demuxer_stream.cc
index 2189545..883d4c1 100644
--- a/media/filters/decrypting_demuxer_stream.cc
+++ b/media/filters/decrypting_demuxer_stream.cc
@@ -28,14 +28,12 @@ static bool IsStreamValidAndEncrypted(DemuxerStream* stream) {
 DecryptingDemuxerStream::DecryptingDemuxerStream(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const scoped_refptr<MediaLog>& media_log,
-    const SetCdmReadyCB& set_cdm_ready_cb,
     const base::Closure& waiting_for_decryption_key_cb)
     : task_runner_(task_runner),
       media_log_(media_log),
       state_(kUninitialized),
       waiting_for_decryption_key_cb_(waiting_for_decryption_key_cb),
       demuxer_stream_(NULL),
-      set_cdm_ready_cb_(set_cdm_ready_cb),
       decryptor_(NULL),
       key_added_while_decrypt_pending_(false),
       weak_factory_(this) {}
@@ -45,6 +43,7 @@ std::string DecryptingDemuxerStream::GetDisplayName() const {
 }
 
 void DecryptingDemuxerStream::Initialize(DemuxerStream* stream,
+                                         const SetCdmReadyCB& set_cdm_ready_cb,
                                          const PipelineStatusCB& status_cb) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ -53,6 +52,7 @@ void DecryptingDemuxerStream::Initialize(DemuxerStream* stream,
   DCHECK(!demuxer_stream_);
   weak_this_ = weak_factory_.GetWeakPtr();
   demuxer_stream_ = stream;
+  set_cdm_ready_cb_ = set_cdm_ready_cb;
   init_cb_ = BindToCurrentLoop(status_cb);
 
   InitializeDecoderConfig();
diff --git a/media/filters/decrypting_demuxer_stream.h b/media/filters/decrypting_demuxer_stream.h
index 88f86a2..c128cf7 100644
--- a/media/filters/decrypting_demuxer_stream.h
+++ b/media/filters/decrypting_demuxer_stream.h
@@ -33,13 +33,14 @@ class MEDIA_EXPORT DecryptingDemuxerStream : public DemuxerStream {
   DecryptingDemuxerStream(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       const scoped_refptr<MediaLog>& media_log,
-      const SetCdmReadyCB& set_cdm_ready_cb,
       const base::Closure& waiting_for_decryption_key_cb);
 
   // Cancels all pending operations immediately and fires all pending callbacks.
   ~DecryptingDemuxerStream() override;
 
-  void Initialize(DemuxerStream* stream, const PipelineStatusCB& status_cb);
+  void Initialize(DemuxerStream* stream,
+                  const SetCdmReadyCB& set_cdm_ready_cb,
+                  const PipelineStatusCB& status_cb);
 
   // Cancels all pending operations and fires all pending callbacks. If in
   // kPendingDemuxerRead or kPendingDecrypt state, waits for the pending
diff --git a/media/filters/decrypting_demuxer_stream_unittest.cc b/media/filters/decrypting_demuxer_stream_unittest.cc
index 7275029..87c5d5e 100644
--- a/media/filters/decrypting_demuxer_stream_unittest.cc
+++ b/media/filters/decrypting_demuxer_stream_unittest.cc
@@ -63,8 +63,6 @@ class DecryptingDemuxerStreamTest : public testing::Test {
       : demuxer_stream_(new DecryptingDemuxerStream(
             message_loop_.task_runner(),
             new MediaLog(),
-            base::Bind(&DecryptingDemuxerStreamTest::RequestCdmNotification,
-                       base::Unretained(this)),
             base::Bind(&DecryptingDemuxerStreamTest::OnWaitingForDecryptionKey,
                        base::Unretained(this)))),
         cdm_context_(new StrictMock<MockCdmContext>()),
@@ -88,16 +86,22 @@ class DecryptingDemuxerStreamTest : public testing::Test {
   void InitializeAudioAndExpectStatus(const AudioDecoderConfig& config,
                                       PipelineStatus status) {
     input_audio_stream_->set_audio_decoder_config(config);
-    demuxer_stream_->Initialize(input_audio_stream_.get(),
-                                NewExpectedStatusCB(status));
+    demuxer_stream_->Initialize(
+        input_audio_stream_.get(),
+        base::Bind(&DecryptingDemuxerStreamTest::RequestCdmNotification,
+                   base::Unretained(this)),
+        NewExpectedStatusCB(status));
     message_loop_.RunUntilIdle();
   }
 
   void InitializeVideoAndExpectStatus(const VideoDecoderConfig& config,
                                       PipelineStatus status) {
     input_video_stream_->set_video_decoder_config(config);
-    demuxer_stream_->Initialize(input_video_stream_.get(),
-                                NewExpectedStatusCB(status));
+    demuxer_stream_->Initialize(
+        input_video_stream_.get(),
+        base::Bind(&DecryptingDemuxerStreamTest::RequestCdmNotification,
+                   base::Unretained(this)),
+        NewExpectedStatusCB(status));
     message_loop_.RunUntilIdle();
   }
 
diff --git a/media/filters/decrypting_video_decoder.cc b/media/filters/decrypting_video_decoder.cc
index ac6a244..9ec48c9 100644
--- a/media/filters/decrypting_video_decoder.cc
+++ b/media/filters/decrypting_video_decoder.cc
@@ -23,13 +23,11 @@ const char DecryptingVideoDecoder::kDecoderName[] = "DecryptingVideoDecoder";
 DecryptingVideoDecoder::DecryptingVideoDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const scoped_refptr<MediaLog>& media_log,
-    const SetCdmReadyCB& set_cdm_ready_cb,
     const base::Closure& waiting_for_decryption_key_cb)
     : task_runner_(task_runner),
       media_log_(media_log),
       state_(kUninitialized),
       waiting_for_decryption_key_cb_(waiting_for_decryption_key_cb),
-      set_cdm_ready_cb_(set_cdm_ready_cb),
       decryptor_(NULL),
       key_added_while_decode_pending_(false),
       trace_id_(0),
@@ -41,6 +39,7 @@ std::string DecryptingVideoDecoder::GetDisplayName() const {
 
 void DecryptingVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                         bool /* low_delay */,
+                                        const SetCdmReadyCB& set_cdm_ready_cb,
                                         const InitCB& init_cb,
                                         const OutputCB& output_cb) {
   DVLOG(2) << "Initialize()";
@@ -59,7 +58,9 @@ void DecryptingVideoDecoder::Initialize(const VideoDecoderConfig& config,
   config_ = config;
 
   if (state_ == kUninitialized) {
+    DCHECK(!set_cdm_ready_cb.is_null());
     state_ = kDecryptorRequested;
+    set_cdm_ready_cb_ = set_cdm_ready_cb;
     set_cdm_ready_cb_.Run(BindToCurrentLoop(
         base::Bind(&DecryptingVideoDecoder::SetCdm, weak_this_)));
     return;
diff --git a/media/filters/decrypting_video_decoder.h b/media/filters/decrypting_video_decoder.h
index 1ac97b8..0651edb 100644
--- a/media/filters/decrypting_video_decoder.h
+++ b/media/filters/decrypting_video_decoder.h
@@ -31,7 +31,6 @@ class MEDIA_EXPORT DecryptingVideoDecoder : public VideoDecoder {
   DecryptingVideoDecoder(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       const scoped_refptr<MediaLog>& media_log,
-      const SetCdmReadyCB& set_cdm_ready_cb,
       const base::Closure& waiting_for_decryption_key_cb);
   ~DecryptingVideoDecoder() override;
 
@@ -39,6 +38,7 @@ class MEDIA_EXPORT DecryptingVideoDecoder : public VideoDecoder {
   std::string GetDisplayName() const override;
   void Initialize(const VideoDecoderConfig& config,
                   bool low_delay,
+                  const SetCdmReadyCB& set_cdm_ready_cb,
                   const InitCB& init_cb,
                   const OutputCB& output_cb) override;
   void Decode(const scoped_refptr<DecoderBuffer>& buffer,
diff --git a/media/filters/decrypting_video_decoder_unittest.cc b/media/filters/decrypting_video_decoder_unittest.cc
index dba3e2e..5fcb74e 100644
--- a/media/filters/decrypting_video_decoder_unittest.cc
+++ b/media/filters/decrypting_video_decoder_unittest.cc
@@ -57,8 +57,6 @@ class DecryptingVideoDecoderTest : public testing::Test {
       : decoder_(new DecryptingVideoDecoder(
             message_loop_.task_runner(),
             new MediaLog(),
-            base::Bind(&DecryptingVideoDecoderTest::RequestCdmNotification,
-                       base::Unretained(this)),
             base::Bind(&DecryptingVideoDecoderTest::OnWaitingForDecryptionKey,
                        base::Unretained(this)))),
         cdm_context_(new StrictMock<MockCdmContext>()),
@@ -97,9 +95,13 @@ class DecryptingVideoDecoderTest : public testing::Test {
   // can succeed or fail.
   void InitializeAndExpectResult(const VideoDecoderConfig& config,
                                  bool success) {
-    decoder_->Initialize(config, false, NewExpectedBoolCB(success),
-                         base::Bind(&DecryptingVideoDecoderTest::FrameReady,
-                                    base::Unretained(this)));
+    decoder_->Initialize(
+        config, false,
+        base::Bind(&DecryptingVideoDecoderTest::RequestCdmNotification,
+                   base::Unretained(this)),
+        NewExpectedBoolCB(success),
+        base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+                   base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
@@ -428,10 +430,13 @@ TEST_F(DecryptingVideoDecoderTest, Destroy_DuringDecryptorRequested) {
   CdmReadyCB cdm_ready_cb;
   EXPECT_CALL(*this, RequestCdmNotification(_))
       .WillOnce(SaveArg<0>(&cdm_ready_cb));
-  decoder_->Initialize(TestVideoConfig::NormalEncrypted(), false,
-                       NewExpectedBoolCB(false),
-                       base::Bind(&DecryptingVideoDecoderTest::FrameReady,
-                                  base::Unretained(this)));
+  decoder_->Initialize(
+      TestVideoConfig::NormalEncrypted(), false,
+      base::Bind(&DecryptingVideoDecoderTest::RequestCdmNotification,
+                 base::Unretained(this)),
+      NewExpectedBoolCB(false),
+      base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+                 base::Unretained(this)));
   message_loop_.RunUntilIdle();
   // |cdm_ready_cb| is saved but not called here.
   EXPECT_FALSE(cdm_ready_cb.is_null());
diff --git a/media/filters/fake_video_decoder.cc b/media/filters/fake_video_decoder.cc
index 00264ea..bbd68b4 100644
--- a/media/filters/fake_video_decoder.cc
+++ b/media/filters/fake_video_decoder.cc
@@ -46,6 +46,7 @@ std::string FakeVideoDecoder::GetDisplayName() const {
 
 void FakeVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                   bool low_delay,
+                                  const SetCdmReadyCB& set_cdm_ready_cb,
                                   const InitCB& init_cb,
                                   const OutputCB& output_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
diff --git a/media/filters/fake_video_decoder.h b/media/filters/fake_video_decoder.h
index e784387..14d19569 100644
--- a/media/filters/fake_video_decoder.h
+++ b/media/filters/fake_video_decoder.h
@@ -44,6 +44,7 @@ class FakeVideoDecoder : public VideoDecoder {
   std::string GetDisplayName() const override;
   void Initialize(const VideoDecoderConfig& config,
                   bool low_delay,
+                  const SetCdmReadyCB& set_cdm_ready_cb,
                   const InitCB& init_cb,
                   const OutputCB& output_cb) override;
   void Decode(const scoped_refptr<DecoderBuffer>& buffer,
diff --git a/media/filters/fake_video_decoder_unittest.cc b/media/filters/fake_video_decoder_unittest.cc
index 610987d..533022c 100644
--- a/media/filters/fake_video_decoder_unittest.cc
+++ b/media/filters/fake_video_decoder_unittest.cc
@@ -50,7 +50,7 @@ class FakeVideoDecoderTest
   void InitializeWithConfigAndExpectResult(const VideoDecoderConfig& config,
                                            bool success) {
     decoder_->Initialize(
-        config, false, NewExpectedBoolCB(success),
+        config, false, SetCdmReadyCB(), NewExpectedBoolCB(success),
         base::Bind(&FakeVideoDecoderTest::FrameReady, base::Unretained(this)));
     message_loop_.RunUntilIdle();
     current_config_ = config;
diff --git a/media/filters/ffmpeg_audio_decoder.cc b/media/filters/ffmpeg_audio_decoder.cc
index a498c17..206f971 100644
--- a/media/filters/ffmpeg_audio_decoder.cc
+++ b/media/filters/ffmpeg_audio_decoder.cc
@@ -146,6 +146,7 @@ std::string FFmpegAudioDecoder::GetDisplayName() const {
 }
 
 void FFmpegAudioDecoder::Initialize(const AudioDecoderConfig& config,
+                                    const SetCdmReadyCB& /* set_cdm_ready_cb */,
                                     const InitCB& init_cb,
                                     const OutputCB& output_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
diff --git a/media/filters/ffmpeg_audio_decoder.h b/media/filters/ffmpeg_audio_decoder.h
index a394e7d..c3bf60c 100644
--- a/media/filters/ffmpeg_audio_decoder.h
+++ b/media/filters/ffmpeg_audio_decoder.h
@@ -38,6 +38,7 @@ class MEDIA_EXPORT FFmpegAudioDecoder : public AudioDecoder {
   // AudioDecoder implementation.
   std::string GetDisplayName() const override;
   void Initialize(const AudioDecoderConfig& config,
+                  const SetCdmReadyCB& set_cdm_ready_cb,
                   const InitCB& init_cb,
                   const OutputCB& output_cb) override;
   void Decode(const scoped_refptr<DecoderBuffer>& buffer,
diff --git a/media/filters/ffmpeg_video_decoder.cc b/media/filters/ffmpeg_video_decoder.cc
index 93e9425..5c419f5 100644
--- a/media/filters/ffmpeg_video_decoder.cc
+++ b/media/filters/ffmpeg_video_decoder.cc
@@ -165,6 +165,7 @@ std::string FFmpegVideoDecoder::GetDisplayName() const {
 
 void FFmpegVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                     bool low_delay,
+                                    const SetCdmReadyCB& /* set_cdm_ready_cb */,
                                     const InitCB& init_cb,
                                     const OutputCB& output_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
diff --git a/media/filters/ffmpeg_video_decoder.h b/media/filters/ffmpeg_video_decoder.h
index 53999aa..8477ad5 100644
--- a/media/filters/ffmpeg_video_decoder.h
+++ b/media/filters/ffmpeg_video_decoder.h
@@ -41,6 +41,7 @@ class MEDIA_EXPORT FFmpegVideoDecoder : public VideoDecoder {
   std::string GetDisplayName() const override;
   void Initialize(const VideoDecoderConfig& config,
                   bool low_delay,
+                  const SetCdmReadyCB& set_cdm_ready_cb,
                   const InitCB& init_cb,
                   const OutputCB& output_cb) override;
   void Decode(const scoped_refptr<DecoderBuffer>& buffer,
diff --git a/media/filters/ffmpeg_video_decoder_unittest.cc b/media/filters/ffmpeg_video_decoder_unittest.cc
index 44f6852..307c0f6 100644
--- a/media/filters/ffmpeg_video_decoder_unittest.cc
+++ b/media/filters/ffmpeg_video_decoder_unittest.cc
@@ -71,7 +71,8 @@ class FFmpegVideoDecoderTest : public testing::Test {
 
   void InitializeWithConfigWithResult(const VideoDecoderConfig& config,
                                       bool success) {
-    decoder_->Initialize(config, false, NewExpectedBoolCB(success),
+    decoder_->Initialize(config, false, SetCdmReadyCB(),
+                         NewExpectedBoolCB(success),
                          base::Bind(&FFmpegVideoDecoderTest::FrameReady,
                                     base::Unretained(this)));
     message_loop_.RunUntilIdle();
diff --git a/media/filters/gpu_video_decoder.cc b/media/filters/gpu_video_decoder.cc
index 90decc7..b791be7 100644
--- a/media/filters/gpu_video_decoder.cc
+++ b/media/filters/gpu_video_decoder.cc
@@ -121,8 +121,10 @@ std::string GpuVideoDecoder::GetDisplayName() const {
   return kDecoderName;
 }
 
+// TODO(xhwang): Support CDM setting using |set_cdm_ready_cb|.
 void GpuVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                  bool /* low_delay */,
+                                 const SetCdmReadyCB& /* set_cdm_ready_cb */,
                                  const InitCB& init_cb,
                                  const OutputCB& output_cb) {
   DVLOG(3) << "Initialize()";
diff --git a/media/filters/gpu_video_decoder.h b/media/filters/gpu_video_decoder.h
index ac4d0e0..271d2fb 100644
--- a/media/filters/gpu_video_decoder.h
+++ b/media/filters/gpu_video_decoder.h
@@ -47,6 +47,7 @@ class MEDIA_EXPORT GpuVideoDecoder
   std::string GetDisplayName() const override;
   void Initialize(const VideoDecoderConfig& config,
                   bool low_delay,
+                  const SetCdmReadyCB& set_cdm_ready_cb,
                   const InitCB& init_cb,
                   const OutputCB& output_cb) override;
   void Decode(const scoped_refptr<DecoderBuffer>& buffer,
diff --git a/media/filters/opus_audio_decoder.cc b/media/filters/opus_audio_decoder.cc
index 454dc29..d1e759b 100644
--- a/media/filters/opus_audio_decoder.cc
+++ b/media/filters/opus_audio_decoder.cc
@@ -132,6 +132,7 @@ std::string OpusAudioDecoder::GetDisplayName() const {
 }
 
 void OpusAudioDecoder::Initialize(const AudioDecoderConfig& config,
+                                  const SetCdmReadyCB& /* set_cdm_ready_cb */,
                                   const InitCB& init_cb,
                                   const OutputCB& output_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
diff --git a/media/filters/opus_audio_decoder.h b/media/filters/opus_audio_decoder.h
index 116fcb0..4095656 100644
--- a/media/filters/opus_audio_decoder.h
+++ b/media/filters/opus_audio_decoder.h
@@ -33,6 +33,7 @@ class MEDIA_EXPORT OpusAudioDecoder : public AudioDecoder {
   // AudioDecoder implementation.
   std::string GetDisplayName() const override;
   void Initialize(const AudioDecoderConfig& config,
+                  const SetCdmReadyCB& set_cdm_ready_cb,
                   const InitCB& init_cb,
                   const OutputCB& output_cb) override;
   void Decode(const scoped_refptr<DecoderBuffer>& buffer,
diff --git a/media/filters/video_decoder_selector_unittest.cc b/media/filters/video_decoder_selector_unittest.cc
index 087661d..2796845 100644
--- a/media/filters/video_decoder_selector_unittest.cc
+++ b/media/filters/video_decoder_selector_unittest.cc
@@ -205,8 +205,8 @@ TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
 
   SelectDecoder();
@@ -217,7 +217,7 @@ TEST_F(VideoDecoderSelectorTest,
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -228,10 +228,10 @@ TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
 
   SelectDecoder();
@@ -242,9 +242,9 @@ TEST_F(VideoDecoderSelectorTest,
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -255,8 +255,8 @@ TEST_F(VideoDecoderSelectorTest, ClearStream_HasDecryptor) {
   UseClearStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
 
   SelectDecoder();
@@ -266,7 +266,7 @@ TEST_F(VideoDecoderSelectorTest, Destroy_ClearStream_HasDecryptor) {
   UseClearStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -277,8 +277,8 @@ TEST_F(VideoDecoderSelectorTest, EncryptedStream_NoDecryptor_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(false));
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(false));
   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 
   SelectDecoder();
@@ -289,7 +289,7 @@ TEST_F(VideoDecoderSelectorTest,
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -300,10 +300,10 @@ TEST_F(VideoDecoderSelectorTest, EncryptedStream_NoDecryptor_MultipleDecoders) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
 
   SelectDecoder();
@@ -314,9 +314,9 @@ TEST_F(VideoDecoderSelectorTest,
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -348,8 +348,8 @@ TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) {
 
   // Since we use DecryptingDemuxerStream, the decoder will be initialized with
   // a clear config.
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull()));
 
   SelectDecoder();
@@ -360,7 +360,7 @@ TEST_F(VideoDecoderSelectorTest,
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -373,10 +373,10 @@ TEST_F(VideoDecoderSelectorTest,
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull()));
 
   SelectDecoder();
@@ -387,9 +387,9 @@ TEST_F(VideoDecoderSelectorTest,
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _, _));
 
   SelectDecoderAndDestroy();
 }
@@ -407,8 +407,8 @@ TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptAndDecode) {
 #else
   // A DecryptingDemuxerStream will be created. The clear decoder will be
   // initialized and returned.
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
-      .WillOnce(RunCallback<2>(true));
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(true));
   EXPECT_CALL(*this, OnDecoderSelected(NotNull(), NotNull()));
 #endif
 
diff --git a/media/filters/vpx_video_decoder.cc b/media/filters/vpx_video_decoder.cc
index fc83914..0a14d3e 100644
--- a/media/filters/vpx_video_decoder.cc
+++ b/media/filters/vpx_video_decoder.cc
@@ -278,6 +278,7 @@ std::string VpxVideoDecoder::GetDisplayName() const {
 
 void VpxVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                  bool low_delay,
+                                 const SetCdmReadyCB& /* set_cdm_ready_cb */,
                                  const InitCB& init_cb,
                                  const OutputCB& output_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
diff --git a/media/filters/vpx_video_decoder.h b/media/filters/vpx_video_decoder.h
index bbf9895..5bbc086 100644
--- a/media/filters/vpx_video_decoder.h
+++ b/media/filters/vpx_video_decoder.h
@@ -35,6 +35,7 @@ class MEDIA_EXPORT VpxVideoDecoder : public VideoDecoder {
   std::string GetDisplayName() const override;
   void Initialize(const VideoDecoderConfig& config,
                   bool low_delay,
+                  const SetCdmReadyCB& set_cdm_ready_cb,
                   const InitCB& init_cb,
                   const OutputCB& output_cb) override;
   void Decode(const scoped_refptr<DecoderBuffer>& buffer,
diff --git a/media/renderers/audio_renderer_impl_unittest.cc b/media/renderers/audio_renderer_impl_unittest.cc
index 0dd3969..d434548 100644
--- a/media/renderers/audio_renderer_impl_unittest.cc
+++ b/media/renderers/audio_renderer_impl_unittest.cc
@@ -54,7 +54,7 @@ static int kInputSamplesPerSecond = 5000;
 static int kOutputSamplesPerSecond = 10000;
 
 ACTION_P(EnterPendingDecoderInitStateAction, test) {
-  test->EnterPendingDecoderInitState(arg1);
+  test->EnterPendingDecoderInitState(arg2);
 }
 
 class AudioRendererImplTest : public ::testing::Test {
@@ -109,8 +109,8 @@ class AudioRendererImplTest : public ::testing::Test {
   }
 
   void ExpectUnsupportedAudioDecoder() {
-    EXPECT_CALL(*decoder_, Initialize(_, _, _))
-        .WillOnce(DoAll(SaveArg<2>(&output_cb_), RunCallback<1>(false)));
+    EXPECT_CALL(*decoder_, Initialize(_, _, _, _))
+        .WillOnce(DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(false)));
   }
 
   void OnStatistics(const PipelineStatistics& stats) {
@@ -136,8 +136,8 @@ class AudioRendererImplTest : public ::testing::Test {
   }
 
   void Initialize() {
-    EXPECT_CALL(*decoder_, Initialize(_, _, _))
-        .WillOnce(DoAll(SaveArg<2>(&output_cb_), RunCallback<1>(true)));
+    EXPECT_CALL(*decoder_, Initialize(_, _, _, _))
+        .WillOnce(DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(true)));
     InitializeWithStatus(PIPELINE_OK);
 
     next_timestamp_.reset(new AudioTimestampHelper(kInputSamplesPerSecond));
@@ -155,7 +155,8 @@ class AudioRendererImplTest : public ::testing::Test {
   }
 
   void InitializeAndDestroy() {
-    EXPECT_CALL(*decoder_, Initialize(_, _, _)).WillOnce(RunCallback<1>(true));
+    EXPECT_CALL(*decoder_, Initialize(_, _, _, _))
+        .WillOnce(RunCallback<2>(true));
 
     WaitableMessageLoopEvent event;
     InitializeRenderer(event.GetPipelineStatusCB());
@@ -168,7 +169,7 @@ class AudioRendererImplTest : public ::testing::Test {
   }
 
   void InitializeAndDestroyDuringDecoderInit() {
-    EXPECT_CALL(*decoder_, Initialize(_, _, _))
+    EXPECT_CALL(*decoder_, Initialize(_, _, _, _))
         .WillOnce(EnterPendingDecoderInitStateAction(this));
 
     WaitableMessageLoopEvent event;
diff --git a/media/renderers/video_renderer_impl_unittest.cc b/media/renderers/video_renderer_impl_unittest.cc
index 74d9a1e..a40a4d7 100644
--- a/media/renderers/video_renderer_impl_unittest.cc
+++ b/media/renderers/video_renderer_impl_unittest.cc
@@ -114,9 +114,9 @@ class VideoRendererImplTest
                       bool expect_to_success) {
     if (low_delay)
       demuxer_stream_.set_liveness(DemuxerStream::LIVENESS_LIVE);
-    EXPECT_CALL(*decoder_, Initialize(_, _, _, _))
+    EXPECT_CALL(*decoder_, Initialize(_, _, _, _, _))
         .WillOnce(
-            DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(expect_to_success)));
+            DoAll(SaveArg<4>(&output_cb_), RunCallback<3>(expect_to_success)));
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
     renderer_->Initialize(
         &demuxer_stream_, status_cb, SetCdmReadyCB(),