Encrypted Media: Rename NeedKey to EncryptedMediaInitData.

media/filters/pipeline_integration_test.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 "media/filters/pipeline_integration_test_base.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
@@ skipping 116 matching lines @@
                                      bool has_additional_usable_key) = 0;
 
     // Errors are not expected unless overridden.
     virtual void OnSessionError(const std::string& web_session_id,
                                 const std::string& error_name,
                                 uint32 system_code,
                                 const std::string& error_message) {
       FAIL() << "Unexpected Key Error";
     }
 
-    virtual void NeedKey(const std::string& type,
-                         const std::vector<uint8>& init_data,
-                         AesDecryptor* decryptor) = 0;
+    virtual void OnEncryptedMediaInitData(const std::string& init_data_type,
+                                          const std::vector<uint8>& init_data,
+                                          AesDecryptor* decryptor) = 0;
   };
 
   FakeEncryptedMedia(AppBase* app)
       : decryptor_(base::Bind(&FakeEncryptedMedia::OnSessionMessage,
                               base::Unretained(this)),
                    base::Bind(&FakeEncryptedMedia::OnSessionClosed,
                               base::Unretained(this)),
                    base::Bind(&FakeEncryptedMedia::OnSessionKeysChange,
                               base::Unretained(this))),
         cdm_context_(&decryptor_),
@@ skipping 18 matching lines @@
   }
 
   void OnSessionError(const std::string& web_session_id,
                       const std::string& error_name,
                       uint32 system_code,
                       const std::string& error_message) {
     app_->OnSessionError(
         web_session_id, error_name, system_code, error_message);
   }
 
-  void NeedKey(const std::string& type,
-               const std::vector<uint8>& init_data) {
-    app_->NeedKey(type, init_data, &decryptor_);
+  void OnEncryptedMediaInitData(const std::string& init_data_type,
+                                const std::vector<uint8>& init_data) {
+    app_->OnEncryptedMediaInitData(init_data_type, init_data, &decryptor_);
   }
 
  private:
   class TestCdmContext : public CdmContext {
    public:
     TestCdmContext(Decryptor* decryptor) : decryptor_(decryptor) {}
 
     Decryptor* GetDecryptor() final { return decryptor_; }
 
 #if defined(ENABLE_BROWSER_CDMS)
@@ skipping 66 matching lines @@
   void OnSessionClosed(const std::string& web_session_id) override {
     EXPECT_EQ(current_session_id_, web_session_id);
   }
 
   void OnSessionKeysChange(const std::string& web_session_id,
                            bool has_additional_usable_key) override {
     EXPECT_EQ(current_session_id_, web_session_id);
     EXPECT_EQ(has_additional_usable_key, true);
   }
 
-  void NeedKey(const std::string& type,
-               const std::vector<uint8>& init_data,
-               AesDecryptor* decryptor) override {
+  void OnEncryptedMediaInitData(const std::string& init_data_type,
+                                const std::vector<uint8>& init_data,
+                                AesDecryptor* decryptor) override {
     if (current_session_id_.empty()) {
-      decryptor->CreateSession(type,
-                               kInitData,
-                               arraysize(kInitData),
+      decryptor->CreateSession(init_data_type, kInitData, arraysize(kInitData),
                                MediaKeys::TEMPORARY_SESSION,
                                CreateSessionPromise(RESOLVED));
       EXPECT_FALSE(current_session_id_.empty());
     }
 
     // Clear Key really needs the key ID in |init_data|. For WebM, they are the
     // same, but this is not the case for ISO CENC. Therefore, provide the
     // correct key ID.
     const uint8* key_id = init_data.empty() ? NULL : &init_data[0];
     size_t key_id_length = init_data.size();
-    if (type == kCencInitDataType) {
+    if (init_data_type == kCencInitDataType) {
       key_id = kKeyId;
       key_id_length = arraysize(kKeyId);
     }
 
     // Convert key into a JSON structure and then add it.
     std::string jwk = GenerateJWKSet(
         kSecretKey, arraysize(kSecretKey), key_id, key_id_length);
     decryptor->UpdateSession(current_session_id_,
                              reinterpret_cast<const uint8*>(jwk.data()),
                              jwk.size(),
                              CreatePromise(RESOLVED));
   }
 
   std::string current_session_id_;
 };
 
 class RotatingKeyProvidingApp : public KeyProvidingApp {
  public:
   RotatingKeyProvidingApp() : num_distint_need_key_calls_(0) {}
   ~RotatingKeyProvidingApp() override {
-    // Expect that NeedKey is fired multiple times with different |init_data|.
+    // Expect that OnEncryptedMediaInitData is fired multiple times with
+    // different |init_data|.
     EXPECT_GT(num_distint_need_key_calls_, 1u);
   }
 
-  void NeedKey(const std::string& type,
-               const std::vector<uint8>& init_data,
-               AesDecryptor* decryptor) override {
+  void OnEncryptedMediaInitData(const std::string& init_data_type,
+                                const std::vector<uint8>& init_data,
+                                AesDecryptor* decryptor) override {
     // Skip the request if the |init_data| has been seen.
     if (init_data == prev_init_data_)
       return;
     prev_init_data_ = init_data;
     ++num_distint_need_key_calls_;
 
-    decryptor->CreateSession(type,
-                             vector_as_array(&init_data),
-                             init_data.size(),
-                             MediaKeys::TEMPORARY_SESSION,
+    decryptor->CreateSession(init_data_type, vector_as_array(&init_data),
+                             init_data.size(), MediaKeys::TEMPORARY_SESSION,
                              CreateSessionPromise(RESOLVED));
 
     std::vector<uint8> key_id;
     std::vector<uint8> key;
     EXPECT_TRUE(GetKeyAndKeyId(init_data, &key, &key_id));
 
     // Convert key into a JSON structure and then add it.
     std::string jwk = GenerateJWKSet(vector_as_array(&key),
                                      key.size(),
                                      vector_as_array(&key_id),
@@ skipping 53 matching lines @@
     EXPECT_FALSE(web_session_id.empty());
     FAIL() << "Unexpected Closed";
   }
 
   void OnSessionKeysChange(const std::string& web_session_id,
                            bool has_additional_usable_key) override {
     EXPECT_FALSE(web_session_id.empty());
     EXPECT_EQ(has_additional_usable_key, true);
   }
 
-  void NeedKey(const std::string& type,
-               const std::vector<uint8>& init_data,
-               AesDecryptor* decryptor) override {}
+  void OnEncryptedMediaInitData(const std::string& init_data_type,
+                                const std::vector<uint8>& init_data,
+                                AesDecryptor* decryptor) override {}
 };
 
 // Helper class that emulates calls made on the ChunkDemuxer by the
 // Media Source API.
 class MockMediaSource {
  public:
   MockMediaSource(const std::string& filename,
                   const std::string& mimetype,
                   int initial_append_size)
       : current_position_(0),
         initial_append_size_(initial_append_size),
         mimetype_(mimetype),
         chunk_demuxer_(new ChunkDemuxer(
             base::Bind(&MockMediaSource::DemuxerOpened, base::Unretained(this)),
-            base::Bind(&MockMediaSource::DemuxerNeedKey,
+            base::Bind(&MockMediaSource::OnEncryptedMediaInitData,
                        base::Unretained(this)),
             LogCB(),
             scoped_refptr<MediaLog>(new MediaLog()),
             true)),
         owned_chunk_demuxer_(chunk_demuxer_) {
     file_data_ = ReadTestDataFile(filename);
 
     if (initial_append_size_ == kAppendWholeFile)
       initial_append_size_ = file_data_->data_size();
 
     DCHECK_GT(initial_append_size_, 0);
     DCHECK_LE(initial_append_size_, file_data_->data_size());
   }
 
   virtual ~MockMediaSource() {}
 
   scoped_ptr<Demuxer> GetDemuxer() { return owned_chunk_demuxer_.Pass(); }
 
-  void set_need_key_cb(const Demuxer::NeedKeyCB& need_key_cb) {
-    need_key_cb_ = need_key_cb;
+  void set_encrypted_media_init_data_cb(
+      const Demuxer::EncryptedMediaInitDataCB& encrypted_media_init_data_cb) {
+    encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
   }
 
   void Seek(base::TimeDelta seek_time, int new_position, int seek_append_size) {
     chunk_demuxer_->StartWaitingForSeek(seek_time);
 
     chunk_demuxer_->Abort(
         kSourceId,
         base::TimeDelta(), kInfiniteDuration(), &last_timestamp_offset_);
 
     DCHECK_GE(new_position, 0);
@@ skipping 85 matching lines @@
           mimetype_.substr(codecs_param_start,
                            codecs_param_end - codecs_param_start);
       Tokenize(codecs_param, ",", &codecs);
     }
 
     CHECK_EQ(chunk_demuxer_->AddId(kSourceId, type, codecs), ChunkDemuxer::kOk);
 
     AppendData(initial_append_size_);
   }
 
-  void DemuxerNeedKey(const std::string& type,
-                      const std::vector<uint8>& init_data) {
+  void OnEncryptedMediaInitData(const std::string& init_data_type,
+                                const std::vector<uint8>& init_data) {
     DCHECK(!init_data.empty());
-    CHECK(!need_key_cb_.is_null());
-    need_key_cb_.Run(type, init_data);
+    CHECK(!encrypted_media_init_data_cb_.is_null());
+    encrypted_media_init_data_cb_.Run(init_data_type, init_data);
   }
 
   base::TimeDelta last_timestamp_offset() const {
     return last_timestamp_offset_;
   }
 
   MOCK_METHOD0(InitSegmentReceived, void(void));
 
  private:
   scoped_refptr<DecoderBuffer> file_data_;
   int current_position_;
   int initial_append_size_;
   std::string mimetype_;
   ChunkDemuxer* chunk_demuxer_;
   scoped_ptr<Demuxer> owned_chunk_demuxer_;
-  Demuxer::NeedKeyCB need_key_cb_;
+  Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
   base::TimeDelta last_timestamp_offset_;
 };
 
 class PipelineIntegrationTest
     : public testing::Test,
       public PipelineIntegrationTestBase {
  public:
   void StartPipelineWithMediaSource(MockMediaSource* source) {
     EXPECT_CALL(*source, InitSegmentReceived()).Times(AtLeast(1));
     EXPECT_CALL(*this, OnMetadata(_))
@@ skipping 50 matching lines @@
                    base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnMetadata,
                    base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnBufferingStateChanged,
                    base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnVideoFramePaint,
                    base::Unretained(this)),
         base::Closure(), base::Bind(&PipelineIntegrationTest::OnAddTextTrack,
                                     base::Unretained(this)));
 
-    source->set_need_key_cb(base::Bind(&FakeEncryptedMedia::NeedKey,
-                                       base::Unretained(encrypted_media)));
+    source->set_encrypted_media_init_data_cb(
+        base::Bind(&FakeEncryptedMedia::OnEncryptedMediaInitData,
+                   base::Unretained(encrypted_media)));
 
     message_loop_.Run();
     EXPECT_EQ(PIPELINE_OK, pipeline_status_);
   }
 
   // Verifies that seeking works properly for ChunkDemuxer when the
   // seek happens while there is a pending read on the ChunkDemuxer
   // and no data is available.
   bool TestSeekDuringRead(const std::string& filename,
                           const std::string& mimetype,
@@ skipping 71 matching lines @@
 TEST_F(PipelineIntegrationTest, F32PlaybackHashed) {
   ASSERT_EQ(PIPELINE_OK, Start("sfx_f32le.wav", kHashed));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   EXPECT_EQ(std::string(kNullVideoHash), GetVideoHash());
   EXPECT_EQ("3.03,2.86,2.99,3.31,3.57,4.06,", GetAudioHash());
 }
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackEncrypted) {
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
-  set_need_key_cb(base::Bind(&FakeEncryptedMedia::NeedKey,
-                             base::Unretained(&encrypted_media)));
+  set_encrypted_media_init_data_cb(
+      base::Bind(&FakeEncryptedMedia::OnEncryptedMediaInitData,
+                 base::Unretained(&encrypted_media)));
 
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240-av_enc-av.webm",
                                encrypted_media.GetCdmContext()));
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   Stop();
 }
 
@@ skipping 877 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media