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 36 matching lines @@
   }
 
   void InitializeVideoAndExpectStatus(const VideoDecoderConfig& config,
                                       PipelineStatus status) {
     input_video_stream_->set_video_decoder_config(config);
     demuxer_stream_->Initialize(input_video_stream_.get(),
                                 NewExpectedStatusCB(status));
     message_loop_.RunUntilIdle();
   }
 
+  void ExpectDecryptorNotification(Decryptor* decryptor, bool expected_result) {
+    EXPECT_CALL(*this, RequestDecryptorNotification(_))
+        .WillOnce(SetDecryptorIfNotNull(
+            decryptor,
+            base::Bind(&DecryptingDemuxerStreamTest::DecryptorSet,
+                       base::Unretained(this)),
+            &is_decryptor_set_));
+    EXPECT_CALL(*this, DecryptorSet(expected_result));
+  }
+
   // 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_));
+    ExpectDecryptorNotification(decryptor_.get(), true);
     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 109 matching lines @@
 
     demuxer_stream_->Reset(NewExpectedClosure());
     message_loop_.RunUntilIdle();
   }
 
   MOCK_METHOD1(RequestDecryptorNotification, void(const DecryptorReadyCB&));
 
   MOCK_METHOD2(BufferReady, void(DemuxerStream::Status,
                                  const scoped_refptr<DecoderBuffer>&));
 
+  MOCK_METHOD1(DecryptorSet, void(bool));
+
   base::MessageLoop message_loop_;
   scoped_ptr<DecryptingDemuxerStream> demuxer_stream_;
   scoped_ptr<StrictMock<MockDecryptor> > decryptor_;
   // Whether a valid Decryptor has been set in the |demuxer_stream_|.
   bool is_decryptor_set_;
   scoped_ptr<StrictMock<MockDemuxerStream> > input_audio_stream_;
   scoped_ptr<StrictMock<MockDemuxerStream> > input_video_stream_;
 
   DemuxerStream::ReadCB pending_demuxer_read_cb_;
   Decryptor::NewKeyCB key_added_cb_;
   Decryptor::DecryptCB pending_decrypt_cb_;
 
   // Constant buffers to be returned by the input demuxer streams and the
   // |decryptor_|.
   scoped_refptr<DecoderBuffer> clear_buffer_;
   scoped_refptr<DecoderBuffer> encrypted_buffer_;
   scoped_refptr<DecoderBuffer> decrypted_buffer_;
 
  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_));
+  ExpectDecryptorNotification(decryptor_.get(), true);
   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),
-                                            &is_decryptor_set_));
-
+  ExpectDecryptorNotification(NULL, false);
   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();
   EnterNormalReadingState();
 }
@@ skipping 225 matching lines @@
 }
 
 // Test destruction after reset.
 TEST_F(DecryptingDemuxerStreamTest, Destroy_AfterReset) {
   Initialize();
   EnterNormalReadingState();
   Reset();
 }
 
 }  // namespace media