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

media/filters/audio_decoder_selector_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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "media/filters/decoder_selector.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
+using ::testing::Eq;
+using ::testing::InvokeWithoutArgs;
 using ::testing::IsNull;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace media {
 
 class AudioDecoderSelectorTest : public ::testing::Test {
  public:
@@ skipping 14 matching lines @@
         decoder_1_(new StrictMock<MockAudioDecoder>()),
         decoder_2_(new StrictMock<MockAudioDecoder>()) {
     all_decoders_.push_back(decoder_1_);
     all_decoders_.push_back(decoder_2_);
   }
 
   ~AudioDecoderSelectorTest() {
     message_loop_.RunUntilIdle();
   }
 
+  // Used to verify that the number of calls to SetDecryptorReadyCallback()
+  // match the number of calls to DecryptorSet() and that the calls happen in
+  // pairs (e.g. DecryptorSet() called after every SetDecryptorReadyCallback()
+  // call). There may be any number of pairs (including 0).
+  class CallbackVerifier {
+   public:
+    CallbackVerifier() : ready_called_(0), set_called_(0) {}
+    ~CallbackVerifier() { Verify(); }
+    void SetDecryptorReadyCallbackCalled() { ++ready_called_; }

[ddorwin, 2014/08/04 18:59:08]

Is it okay/expected for the values to be >1 apart? i.e.:
ready_called_: 2
set_called_: 0

If so, I think lin 64 would fail. Otherwise, we can probably just
increment/decrement a single value or use a bool.

[jrummell, 2014/08/07 01:54:25]

Done.

+    void DecryptorSetCalled() {
+      ++set_called_;
+      Verify();
+    }
+    void Verify() { EXPECT_EQ(set_called_, ready_called_); }
+
+   private:
+    int ready_called_;
+    int set_called_;
+  };
+
   MOCK_METHOD1(SetDecryptorReadyCallback, void(const media::DecryptorReadyCB&));
   MOCK_METHOD2(OnDecoderSelected,
                void(AudioDecoder*, DecryptingDemuxerStream*));
+  MOCK_METHOD1(DecryptorSet, void(bool));
 
   void MockOnDecoderSelected(scoped_ptr<AudioDecoder> decoder,
                              scoped_ptr<DecryptingDemuxerStream> stream) {
     OnDecoderSelected(decoder.get(), stream.get());
     selected_decoder_ = decoder.Pass();
   }
 
   void UseClearStream() {
     AudioDecoderConfig clear_audio_config(
         kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
@@ skipping 12 matching lines @@
                                  int num_decoders) {
     SetDecryptorReadyCB set_decryptor_ready_cb;
     if (decryptor_capability != kNoDecryptor) {
       set_decryptor_ready_cb =
           base::Bind(&AudioDecoderSelectorTest::SetDecryptorReadyCallback,
                      base::Unretained(this));
     }
 
     if (decryptor_capability == kDecryptOnly ||
         decryptor_capability == kDecryptAndDecode) {
-
-      EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
-          .WillRepeatedly(RunCallback<0>(decryptor_.get()));
+      EXPECT_CALL(*this, SetDecryptorReadyCallback(_)).WillRepeatedly(DoAll(

[ddorwin, 2014/08/04 18:59:08]

This looks odd. Do we need SetDecryptorReadyCallback() if it doesn't do
anything? Can we have it call
CallbackVerifier::SetDecryptorReadyCallbackCalled() or replace it with that
function?

[jrummell, 2014/08/07 01:54:25]

The problem is that SetDecryptorReadyCallback() is called 0, 1, or 2 times,
depending on the test. Added an ACTION to simplify this.

+          InvokeWithoutArgs(&verifier_,
+                            &CallbackVerifier::SetDecryptorReadyCallbackCalled),
+          RunCallback<0>(decryptor_.get(),
+                         base::Bind(&AudioDecoderSelectorTest::DecryptorSet,
+                                    base::Unretained(this)))));
+      EXPECT_CALL(*this, DecryptorSet(Eq(true))).WillRepeatedly(
+          InvokeWithoutArgs(&verifier_, &CallbackVerifier::DecryptorSetCalled));
 
       if (decryptor_capability == kDecryptOnly) {
         EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _))
             .WillRepeatedly(RunCallback<1>(false));
       } else {
         EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _))
             .WillRepeatedly(RunCallback<1>(true));
       }
     } else if (decryptor_capability == kHoldSetDecryptor) {
       // Set and cancel DecryptorReadyCB but the callback is never fired.
@@ skipping 43 matching lines @@
 
   scoped_ptr<AudioDecoderSelector> decoder_selector_;
 
   StrictMock<MockAudioDecoder>* decoder_1_;
   StrictMock<MockAudioDecoder>* decoder_2_;
   ScopedVector<AudioDecoder> all_decoders_;
   scoped_ptr<AudioDecoder> selected_decoder_;
 
   base::MessageLoop message_loop_;
 
+  CallbackVerifier verifier_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioDecoderSelectorTest);
 };
 
 // The stream is not encrypted but we have no clear decoder. No decoder can be
 // selected.
 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 0);
 
@@ skipping 168 matching lines @@
 }
 
 TEST_F(AudioDecoderSelectorTest, Destroy_EncryptedStream_DecryptAndDecode) {
   UseEncryptedStream();
   InitializeDecoderSelector(kHoldSetDecryptor, 1);
 
   SelectDecoderAndDestroy();
 }
 
 }  // namespace media