Separate CDM initialization from GenerateKeyRequest & remove key_system parameters.

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/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
@@ skipping 48 matching lines @@
 
 // Note: Tests using this class only exercise the DecryptingDemuxerStream path.
 // They do not exercise the Decrypting{Audio|Video}Decoder path.
 class FakeEncryptedMedia {
  public:
   // Defines the behavior of the "app" that responds to EME events.
   class AppBase {
    public:
     virtual ~AppBase() {}
 
-    virtual void KeyAdded(const std::string& key_system,
-                          const std::string& session_id) = 0;
+    virtual void KeyAdded(const std::string& session_id) = 0;
 
     // Errors are not expected unless overridden.
-    virtual void KeyError(const std::string& key_system,
-                          const std::string& session_id,
+    virtual void KeyError(const std::string& session_id,
                           MediaKeys::KeyError error_code,
                           int system_code) {
       FAIL() << "Unexpected Key Error";
     }
 
-    virtual void KeyMessage(const std::string& key_system,
-                            const std::string& session_id,
+    virtual void KeyMessage(const std::string& session_id,
                             const std::string& message,
                             const std::string& default_url) = 0;
 
-    virtual void NeedKey(const std::string& key_system,
-                         const std::string& session_id,
+    virtual void NeedKey(const std::string& session_id,
                          const std::string& type,
                          scoped_ptr<uint8[]> init_data, int init_data_length,
                          AesDecryptor* decryptor) = 0;
   };
 
   FakeEncryptedMedia(AppBase* app)
       : decryptor_(base::Bind(&FakeEncryptedMedia::KeyAdded,
                               base::Unretained(this)),
                    base::Bind(&FakeEncryptedMedia::KeyError,
                               base::Unretained(this)),
                    base::Bind(&FakeEncryptedMedia::KeyMessage,
                               base::Unretained(this)),
                    base::Bind(&FakeEncryptedMedia::NeedKey,
                               base::Unretained(this))),
         app_(app) {
   }
 
   AesDecryptor* decryptor() {
     return &decryptor_;
   }
 
   // Callbacks for firing key events. Delegate to |app_|.
-  void KeyAdded(const std::string& key_system, const std::string& session_id) {
-    app_->KeyAdded(key_system, session_id);
+  void KeyAdded(const std::string& session_id) {
+    app_->KeyAdded(session_id);
   }
 
-  void KeyError(const std::string& key_system,
-                const std::string& session_id,
+  void KeyError(const std::string& session_id,
                 MediaKeys::KeyError error_code,
                 int system_code) {
-    app_->KeyError(key_system, session_id, error_code, system_code);
+    app_->KeyError(session_id, error_code, system_code);
   }
 
-  void KeyMessage(const std::string& key_system,
-                  const std::string& session_id,
+  void KeyMessage(const std::string& session_id,
                   const std::string& message,
                   const std::string& default_url) {
-    app_->KeyMessage(key_system, session_id, message, default_url);
+    app_->KeyMessage(session_id, message, default_url);
   }
 
-  void NeedKey(const std::string& key_system,
-               const std::string& session_id,
+  void NeedKey(const std::string& session_id,
                const std::string& type,
                scoped_ptr<uint8[]> init_data, int init_data_length) {
-    app_->NeedKey(key_system, session_id, type,
-                  init_data.Pass(), init_data_length, &decryptor_);
+    app_->NeedKey(session_id, type, init_data.Pass(), init_data_length,
+                  &decryptor_);
   }
 
  private:
   AesDecryptor decryptor_;
   scoped_ptr<AppBase> app_;
 };
 
 // Provides |kSecretKey| in response to needkey.
 class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
  public:
-  virtual void KeyAdded(const std::string& key_system,
-                        const std::string& session_id) OVERRIDE {
-    EXPECT_EQ(kClearKeySystem, key_system);
+  virtual void KeyAdded(const std::string& session_id) OVERRIDE {
     EXPECT_FALSE(session_id.empty());
   }
 
-  virtual void KeyMessage(const std::string& key_system,
-                          const std::string& session_id,
+  virtual void KeyMessage(const std::string& session_id,
                           const std::string& message,
                           const std::string& default_url) OVERRIDE {
-    EXPECT_EQ(kClearKeySystem, key_system);
     EXPECT_FALSE(session_id.empty());
     EXPECT_FALSE(message.empty());
 
-    current_key_system_ = key_system;
     current_session_id_ = session_id;
   }
 
-  virtual void NeedKey(const std::string& key_system,
-                       const std::string& session_id,
+  virtual void NeedKey(const std::string& session_id,
                        const std::string& type,
                        scoped_ptr<uint8[]> init_data, int init_data_length,
                        AesDecryptor* decryptor) OVERRIDE {
-    current_key_system_ = key_system;
     current_session_id_ = session_id;
 
-    // When NeedKey is called from the demuxer, the |key_system| will be empty.
-    // In this case, we need to call GenerateKeyRequest() to initialize a
-    // session (which will call KeyMessage).
-    if (current_key_system_.empty()) {
-      EXPECT_TRUE(current_session_id_.empty());
-      EXPECT_TRUE(decryptor->GenerateKeyRequest(
-          kClearKeySystem, type, kInitData, arraysize(kInitData)));
+    if (current_session_id_.empty()) {
+      EXPECT_TRUE(decryptor->GenerateKeyRequest(type, kInitData,
+                                                arraysize(kInitData)));
     }
 
-    EXPECT_FALSE(current_key_system_.empty());
     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.get();
     int key_id_length = init_data_length;
     if (type == kMP4AudioType || type == kMP4VideoType) {
       key_id = kKeyId;
       key_id_length = arraysize(kKeyId);
     }
 
-    decryptor->AddKey(current_key_system_, kSecretKey, arraysize(kSecretKey),
+    decryptor->AddKey(kSecretKey, arraysize(kSecretKey),
                       key_id, key_id_length, current_session_id_);
   }
 
-  std::string current_key_system_;
   std::string current_session_id_;
 };
 
 // Ignores needkey and does not perform a license request
 class NoResponseApp : public FakeEncryptedMedia::AppBase {
  public:
-  virtual void KeyAdded(const std::string& key_system,
-                        const std::string& session_id) OVERRIDE {
-    EXPECT_EQ(kClearKeySystem, key_system);
+  virtual void KeyAdded(const std::string& session_id) OVERRIDE {
     EXPECT_FALSE(session_id.empty());
     FAIL() << "Unexpected KeyAdded";
   }
 
-  virtual void KeyMessage(const std::string& key_system,
-                          const std::string& session_id,
+  virtual void KeyMessage(const std::string& session_id,
                           const std::string& message,
                           const std::string& default_url) OVERRIDE {
-    EXPECT_EQ(kClearKeySystem, key_system);
     EXPECT_FALSE(session_id.empty());
     EXPECT_FALSE(message.empty());
     FAIL() << "Unexpected KeyMessage";
   }
 
-  virtual void NeedKey(const std::string& key_system,
-                       const std::string& session_id,
+  virtual void NeedKey(const std::string& session_id,
                        const std::string& type,
                        scoped_ptr<uint8[]> init_data, int init_data_length,
                        AesDecryptor* decryptor) OVERRIDE {
   }
 };
 
 // Helper class that emulates calls made on the ChunkDemuxer by the
 // Media Source API.
 class MockMediaSource {
  public:
@@ skipping 86 matching lines @@
 
     CHECK_EQ(chunk_demuxer_->AddId(kSourceId, type, codecs), ChunkDemuxer::kOk);
     AppendData(initial_append_size_);
   }
 
   void DemuxerNeedKey(const std::string& type,
                       scoped_ptr<uint8[]> init_data, int init_data_size) {
     DCHECK(init_data.get());
     DCHECK_GT(init_data_size, 0);
     CHECK(!need_key_cb_.is_null());
-    need_key_cb_.Run(
-        std::string(), std::string(), type, init_data.Pass(), init_data_size);
+    need_key_cb_.Run(std::string(), type, init_data.Pass(), init_data_size);
   }
 
   scoped_ptr<TextTrack> OnTextTrack(TextKind kind,
                                     const std::string& label,
                                     const std::string& language) {
     return scoped_ptr<TextTrack>();
   }
 
  private:
   base::FilePath file_path_;
@@ skipping 631 matching lines @@
 
 // Verify that VP8 video with inband text track can be played back.
 TEST_F(PipelineIntegrationTest, BasicPlayback_VP8_WebVTT_WebM) {
   ASSERT_TRUE(Start(GetTestDataFilePath("bear-vp8-webvtt.webm"),
                     PIPELINE_OK));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 }  // namespace media