Encrypted Media: Rename NeedKey to EncryptedMediaInitData.

media/filters/ffmpeg_demuxer_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 <algorithm>
 #include <deque>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 24 matching lines @@
 using ::testing::WithArgs;
 using ::testing::_;
 
 namespace media {
 
 MATCHER(IsEndOfStreamBuffer,
         std::string(negation ? "isn't" : "is") + " end of stream") {
   return arg->end_of_stream();
 }
 
+const uint8 kEncryptedMediaInitData[] = {
+  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+  0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+};
+
 static void EosOnReadDone(bool* got_eos_buffer,
                           DemuxerStream::Status status,
                           const scoped_refptr<DecoderBuffer>& buffer) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 
   EXPECT_EQ(status, DemuxerStream::kOk);
   if (buffer->end_of_stream()) {
     *got_eos_buffer = true;
     return;
@@ skipping 16 matching lines @@
       demuxer_->Stop();
   }
 
   void CreateDemuxer(const std::string& name) {
     CHECK(!demuxer_);
 
     EXPECT_CALL(host_, AddBufferedTimeRange(_, _)).Times(AnyNumber());
 
     CreateDataSource(name);
 
-    Demuxer::NeedKeyCB need_key_cb =
-        base::Bind(&FFmpegDemuxerTest::NeedKeyCB, base::Unretained(this));
+    Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb = base::Bind(
+        &FFmpegDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this));
 
-    demuxer_.reset(new FFmpegDemuxer(message_loop_.message_loop_proxy(),
-                                     data_source_.get(),
-                                     need_key_cb,
-                                     new MediaLog()));
+    demuxer_.reset(new FFmpegDemuxer(
+        message_loop_.message_loop_proxy(), data_source_.get(),
+        encrypted_media_init_data_cb, new MediaLog()));
   }
 
   MOCK_METHOD1(CheckPoint, void(int v));
 
   void InitializeDemuxerWithTimelineOffset(bool enable_text,
                                            base::Time timeline_offset) {
     EXPECT_CALL(host_, SetDuration(_));
     WaitableMessageLoopEvent event;
     demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), enable_text);
     demuxer_->timeline_offset_ = timeline_offset;
@@ skipping 74 matching lines @@
                                             timestamp_us,
                                             discard_front_padding,
                                             is_key_frame);
 
     return base::Bind(&FFmpegDemuxerTest::OnReadDone,
                       base::Unretained(this),
                       location,
                       read_expectation);
   }
 
-  // TODO(xhwang): This is a workaround of the issue that move-only parameters
-  // are not supported in mocked methods. Remove this when the issue is fixed
-  // (http://code.google.com/p/googletest/issues/detail?id=395) or when we use
-  // std::string instead of scoped_ptr<uint8[]> (http://crbug.com/130689).
-  MOCK_METHOD3(NeedKeyCBMock, void(const std::string& type,
-                                   const uint8* init_data, int init_data_size));
-  void NeedKeyCB(const std::string& type,
-                 const std::vector<uint8>& init_data) {
-    const uint8* init_data_ptr = init_data.empty() ? NULL : &init_data[0];
-    NeedKeyCBMock(type, init_data_ptr, init_data.size());
-  }
+  MOCK_METHOD2(OnEncryptedMediaInitData,
+               void(const std::string& init_data_type,
+                    const std::vector<uint8>& init_data));
 
   // Accessor to demuxer internals.
   void set_duration_known(bool duration_known) {
     demuxer_->duration_known_ = duration_known;
   }
 
   bool IsStreamStopped(DemuxerStream::Type type) {
     DemuxerStream* stream = demuxer_->GetStream(type);
     CHECK(stream);
     return !static_cast<FFmpegDemuxerStream*>(stream)->demuxer_;
@@ skipping 170 matching lines @@
   stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
   EXPECT_EQ(kCodecVorbis, stream->audio_decoder_config().codec());
 
   // Unknown stream should never be present.
   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_Encrypted) {
-  EXPECT_CALL(*this, NeedKeyCBMock(kWebMInitDataType, NotNull(),
-                                   DecryptConfig::kDecryptionKeySize))
+  EXPECT_CALL(*this,
+              OnEncryptedMediaInitData(
+                  kWebMInitDataType,
+                  std::vector<uint8>(kEncryptedMediaInitData,
+                                     kEncryptedMediaInitData +
+                                         arraysize(kEncryptedMediaInitData))))
       .Times(Exactly(2));
 
   CreateDemuxer("bear-320x240-av_enc-av.webm");
   InitializeDemuxer();
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Audio) {
   // We test that on a successful audio packet read.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
@@ skipping 574 matching lines @@
   InitializeDemuxer();
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
   ASSERT_EQ(VIDEO_ROTATION_270, stream->video_rotation());
 }
 
 #endif
 
 }  // namespace media