Allow setContentDecryptionModule() to get called when setting is done.

media/filters/decrypting_demuxer_stream_unittest.cc

 // Copyright (c) 2012 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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 35 matching lines @@
 // times across multiple test files. Sadly we can't use static for them.
 namespace {
 
 ACTION_P(ReturnBuffer, buffer) {
   arg0.Run(buffer.get() ? DemuxerStream::kOk : DemuxerStream::kAborted, buffer);
 }
 
 // Sets the |decryptor| if the DecryptorReadyCB (arg0) is not null. Sets
 // |is_decryptor_set| to true if a non-NULL |decryptor| has been set through the
 // callback.
-ACTION_P2(SetDecryptorIfNotNull, decryptor, is_decryptor_set) {
+ACTION_P3(SetDecryptorIfNotNull, decryptor, done_cb, is_decryptor_set) {
   if (!arg0.is_null())
-    arg0.Run(decryptor);
+    arg0.Run(decryptor, done_cb);
 
   *is_decryptor_set = !arg0.is_null() && decryptor;
 }
 
 ACTION_P2(ResetAndRunCallback, callback, param) {
   base::ResetAndReturn(callback).Run(param);
 }
 
 MATCHER(IsEndOfStream, "end of stream") {
   return arg->end_of_stream();
@@ skipping 43 matching lines @@
     message_loop_.RunUntilIdle();
   }
 
   // The following functions are used to test stream-type-neutral logic in
   // DecryptingDemuxerStream. Therefore, we don't specify audio or video in the
   // function names. But for testing purpose, they all use an audio input
   // demuxer stream.
 
   void Initialize() {
     EXPECT_CALL(*this, RequestDecryptorNotification(_))
-        .WillOnce(SetDecryptorIfNotNull(decryptor_.get(), &is_decryptor_set_));
+        .WillOnce(SetDecryptorIfNotNull(decryptor_.get(),
+                                        base::Bind(&base::DoNothing),

[ddorwin, 2014/07/30 22:35:46]

ditto

+                                        &is_decryptor_set_));
     EXPECT_CALL(*decryptor_, RegisterNewKeyCB(Decryptor::kAudio, _))
         .WillOnce(SaveArg<1>(&key_added_cb_));
 
     AudioDecoderConfig input_config(
         kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
         NULL, 0, true);
     InitializeAudioAndExpectStatus(input_config, PIPELINE_OK);
 
     const AudioDecoderConfig& output_config =
         demuxer_stream_->audio_decoder_config();
@@ skipping 137 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(DecryptingDemuxerStreamTest);
 };
 
 TEST_F(DecryptingDemuxerStreamTest, Initialize_NormalAudio) {
   Initialize();
 }
 
 TEST_F(DecryptingDemuxerStreamTest, Initialize_NormalVideo) {
   EXPECT_CALL(*this, RequestDecryptorNotification(_))
-      .WillOnce(SetDecryptorIfNotNull(decryptor_.get(), &is_decryptor_set_));
+      .WillOnce(SetDecryptorIfNotNull(
+          decryptor_.get(), base::Bind(&base::DoNothing), &is_decryptor_set_));
   EXPECT_CALL(*decryptor_, RegisterNewKeyCB(Decryptor::kVideo, _))
       .WillOnce(SaveArg<1>(&key_added_cb_));
 
   VideoDecoderConfig input_config = TestVideoConfig::NormalEncrypted();
   InitializeVideoAndExpectStatus(input_config, PIPELINE_OK);
 
   const VideoDecoderConfig& output_config =
       demuxer_stream_->video_decoder_config();
   EXPECT_EQ(DemuxerStream::VIDEO, demuxer_stream_->type());
   EXPECT_FALSE(output_config.is_encrypted());
   EXPECT_EQ(input_config.codec(), output_config.codec());
   EXPECT_EQ(input_config.format(), output_config.format());
   EXPECT_EQ(input_config.profile(), output_config.profile());
   EXPECT_EQ(input_config.coded_size(), output_config.coded_size());
   EXPECT_EQ(input_config.visible_rect(), output_config.visible_rect());
   EXPECT_EQ(input_config.natural_size(), output_config.natural_size());
   ASSERT_EQ(input_config.extra_data_size(), output_config.extra_data_size());
   if (input_config.extra_data_size() > 0) {
     EXPECT_FALSE(output_config.extra_data());
     EXPECT_EQ(0, memcmp(output_config.extra_data(), input_config.extra_data(),
                         input_config.extra_data_size()));
   }
 }
 
 TEST_F(DecryptingDemuxerStreamTest, Initialize_NullDecryptor) {
   EXPECT_CALL(*this, RequestDecryptorNotification(_))
       .WillRepeatedly(SetDecryptorIfNotNull(static_cast<Decryptor*>(NULL),
+                                            base::Bind(&base::DoNothing),
                                             &is_decryptor_set_));
 
   AudioDecoderConfig input_config(kCodecVorbis, kSampleFormatPlanarF32,
                                   CHANNEL_LAYOUT_STEREO, 44100, NULL, 0, true);
   InitializeAudioAndExpectStatus(input_config, DECODER_ERROR_NOT_SUPPORTED);
 }
 
 // Test normal read case where the buffer is encrypted.
 TEST_F(DecryptingDemuxerStreamTest, Read_Normal) {
   Initialize();
@@ skipping 227 matching lines @@
 }
 
 // Test destruction after reset.
 TEST_F(DecryptingDemuxerStreamTest, Destroy_AfterReset) {
   Initialize();
   EnterNormalReadingState();
   Reset();
 }
 
 }  // namespace media