Encrypted Media: Rename NeedKey to EncryptedMediaInitData.

media/filters/chunk_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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 27 matching lines @@
 };
 
 // WebM Block bytes that represent a VP8 key frame.
 const uint8 kVP8Keyframe[] = {
   0x010, 0x00, 0x00, 0x9d, 0x01, 0x2a, 0x00, 0x10, 0x00, 0x10, 0x00
 };
 
 // WebM Block bytes that represent a VP8 interframe.
 const uint8 kVP8Interframe[] = { 0x11, 0x00, 0x00 };
 
-static const uint8 kCuesHeader[] = {
+const uint8 kCuesHeader[] = {
   0x1C, 0x53, 0xBB, 0x6B,  // Cues ID
   0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // cues(size = 0)
 };
 
+const uint8 kEncryptedMediaInitData[] = {
+  0x68, 0xFE, 0xF9, 0xA1, 0xB3, 0x0D, 0x6B, 0x4D,
+  0xF2, 0x22, 0xB5, 0x0B, 0x4D, 0xE9, 0xE9, 0x95,
+};
+
 const int kTracksHeaderSize = sizeof(kTracksHeader);
 const int kTracksSizeOffset = 4;
 
 // The size of TrackEntry element in test file "webm_vorbis_track_entry" starts
 // at index 1 and spans 8 bytes.
 const int kAudioTrackSizeOffset = 1;
 const int kAudioTrackSizeWidth = 8;
 const int kAudioTrackEntryHeaderSize =
     kAudioTrackSizeOffset + kAudioTrackSizeWidth;
 
@@ skipping 101 matching lines @@
       : append_window_end_for_next_append_(kInfiniteDuration()) {
     init_segment_received_cb_ =
         base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                    base::Unretained(this));
     CreateNewDemuxer();
   }
 
   void CreateNewDemuxer() {
     base::Closure open_cb =
         base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this));
-    Demuxer::NeedKeyCB need_key_cb =
-        base::Bind(&ChunkDemuxerTest::DemuxerNeedKey, base::Unretained(this));
-    demuxer_.reset(new ChunkDemuxer(open_cb, need_key_cb, base::Bind(&LogFunc),
-                                    scoped_refptr<MediaLog>(new MediaLog()),
-                                    true));
+    Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb = base::Bind(
+        &ChunkDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this));
+    demuxer_.reset(new ChunkDemuxer(
+        open_cb, encrypted_media_init_data_cb, base::Bind(&LogFunc),
+        scoped_refptr<MediaLog>(new MediaLog()), true));
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInitSegment(int stream_flags,
                          bool is_audio_encrypted,
                          bool is_video_encrypted,
                          scoped_ptr<uint8[]>* buffer,
@@ skipping 958 matching lines @@
                                  timestamps[i].video_time_ms),
                              &video_read_done));
         EXPECT_TRUE(video_read_done);
       }
     }
 
     return true;
   }
 
   MOCK_METHOD0(DemuxerOpened, void());
-  // 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(NeedKeyMock, void(const std::string& type,
-                                 const uint8* init_data, int init_data_size));
-  void DemuxerNeedKey(const std::string& type,
-                      const std::vector<uint8>& init_data) {
-    const uint8* init_data_ptr = init_data.empty() ? NULL : &init_data[0];
-    NeedKeyMock(type, init_data_ptr, init_data.size());
-  }
+  MOCK_METHOD2(OnEncryptedMediaInitData,
+               void(const std::string& type,

[jrummell, 2014/12/06 01:08:06]

nit: Should this be init_data_type?

[xhwang, 2014/12/06 07:03:50]

Done.

+                    const std::vector<uint8>& init_data));
 
   MOCK_METHOD0(InitSegmentReceived, void(void));
 
   void Seek(base::TimeDelta seek_time) {
     demuxer_->StartWaitingForSeek(seek_time);
     demuxer_->Seek(seek_time, NewExpectedStatusCB(PIPELINE_OK));
     message_loop_.RunUntilIdle();
   }
 
   void MarkEndOfStream(PipelineStatus status) {
@@ skipping 40 matching lines @@
     if ((!has_audio && is_audio_encrypted) ||
         (!has_video && is_video_encrypted)) {
       continue;
     }
 
     CreateNewDemuxer();
 
     if (is_audio_encrypted || is_video_encrypted) {
       int need_key_count = (is_audio_encrypted ? 1 : 0) +
                            (is_video_encrypted ? 1 : 0);
-      EXPECT_CALL(*this, NeedKeyMock(kWebMInitDataType, NotNull(),
-                                     DecryptConfig::kDecryptionKeySize))
+      EXPECT_CALL(*this, OnEncryptedMediaInitData(
+                             kWebMInitDataType,
+                             std::vector<uint8>(
+                                 kEncryptedMediaInitData,
+                                 kEncryptedMediaInitData +
+                                     arraysize(kEncryptedMediaInitData))))
           .Times(Exactly(need_key_count));
     }
 
     int stream_flags = 0;
     if (has_audio)
       stream_flags |= HAS_AUDIO;
 
     if (has_video)
       stream_flags |= HAS_VIDEO;
 
@@ skipping 2508 matching lines @@
 TEST_F(ChunkDemuxerTest, CuesBetweenClusters) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(GenerateCluster(0, 0, 4));
   AppendData(kCuesHeader, sizeof(kCuesHeader));
   AppendCluster(GenerateCluster(46, 66, 5));
   CheckExpectedRanges(kSourceId, "{ [0,115) }");
 }
 
 }  // namespace media