Encrypted Media: Replace DecryptorClient with key event callbacks.

media/filters/decrypting_video_decoder_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.h"
@@ skipping 88 matching lines @@
     decoder_->Initialize(demuxer_, NewExpectedStatusCB(status),
                          base::Bind(&MockStatisticsCB::OnStatistics,
                                     base::Unretained(&statistics_cb_)));
     message_loop_.RunUntilIdle();
   }
 
   void Initialize() {
     EXPECT_CALL(*decryptor_, InitializeVideoDecoderMock(_, _))
         .Times(AtMost(1))
         .WillOnce(RunCallback<1>(true));
-    EXPECT_CALL(*decryptor_, RegisterKeyAddedCB(Decryptor::kVideo, _))
+    EXPECT_CALL(*decryptor_, RegisterNewKeyCB(Decryptor::kVideo, _))
         .WillOnce(SaveArg<1>(&key_added_cb_));
 
     config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
                        kCodedSize, kVisibleRect, kNaturalSize,
                        NULL, 0, true, true);
 
     InitializeAndExpectStatus(config_, PIPELINE_OK);
   }
 
   void ReadAndExpectFrameReadyWith(
@@ skipping 91 matching lines @@
   void Reset() {
     EXPECT_CALL(*decryptor_, ResetDecoder(Decryptor::kVideo))
         .WillRepeatedly(InvokeWithoutArgs(
             this, &DecryptingVideoDecoderTest::AbortPendingVideoDecodeCB));
 
     decoder_->Reset(NewExpectedClosure());
     message_loop_.RunUntilIdle();
   }
 
   void Stop() {
-    EXPECT_CALL(*decryptor_, RegisterKeyAddedCB(Decryptor::kVideo,
-                                                IsNullCallback()))
+    EXPECT_CALL(*decryptor_, RegisterNewKeyCB(Decryptor::kVideo,
+                                              IsNullCallback()))
         .Times(AtMost(1));
     EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kVideo))
         .WillRepeatedly(InvokeWithoutArgs(
             this, &DecryptingVideoDecoderTest::AbortAllPendingCBs));
 
     decoder_->Stop(NewExpectedClosure());
     message_loop_.RunUntilIdle();
   }
 
   MOCK_METHOD1(RequestDecryptorNotification, void(const DecryptorReadyCB&));
 
   MOCK_METHOD2(FrameReady, void(VideoDecoder::Status,
                                 const scoped_refptr<VideoFrame>&));
 
   MessageLoop message_loop_;
   scoped_refptr<DecryptingVideoDecoder> decoder_;
   scoped_ptr<StrictMock<MockDecryptor> > decryptor_;
   scoped_refptr<StrictMock<MockDemuxerStream> > demuxer_;
   MockStatisticsCB statistics_cb_;
   VideoDecoderConfig config_;
 
   DemuxerStream::ReadCB pending_demuxer_read_cb_;
   Decryptor::DecoderInitCB pending_init_cb_;
-  Decryptor::KeyAddedCB key_added_cb_;
+  Decryptor::NewKeyCB key_added_cb_;
   Decryptor::VideoDecodeCB pending_video_decode_cb_;
 
   // Constant buffer/frames to be returned by the |demuxer_| and |decryptor_|.
   scoped_refptr<DecoderBuffer> encrypted_buffer_;
   scoped_refptr<VideoFrame> decoded_video_frame_;
   scoped_refptr<VideoFrame> null_video_frame_;
   scoped_refptr<VideoFrame> end_of_stream_video_frame_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DecryptingVideoDecoderTest);
@@ skipping 340 matching lines @@
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(RunCallback<0>(DemuxerStream::kConfigChanged,
                                scoped_refptr<DecoderBuffer>()));
 
   // TODO(xhwang): Update this test when kConfigChanged is supported in
   // DecryptingVideoDecoder.
   ReadAndExpectFrameReadyWith(VideoDecoder::kDecodeError, null_video_frame_);
 }
 
 }  // namespace media