Use 'pssh' data to determine key_id properly

media/test/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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_context.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media.h"
 #include "media/base/media_keys.h"
 #include "media/base/media_switches.h"
 #include "media/base/test_data_util.h"
 #include "media/cdm/aes_decryptor.h"
 #include "media/cdm/json_web_key.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/renderers/renderer_impl.h"
 #include "media/test/pipeline_integration_test_base.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "url/gurl.h"
 
+#if defined(USE_PROPRIETARY_CODECS)
+#include "media/cdm/cenc_utils.h"
+#endif
+
 #if defined(MOJO_RENDERER)
 #include "media/mojo/services/mojo_renderer_impl.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/application_test_base.h"
 #include "mojo/application/public/cpp/connect.h"
 
 // TODO(dalecurtis): The mojo renderer is in another process, so we have no way
 // currently to get hashes for video and audio samples.  This also means that
 // real audio plays out for each test.
 #define EXPECT_HASH_EQ(a, b)
@@ skipping 37 matching lines @@
 const char kMP3[] = "audio/mpeg";
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
 // Key used to encrypt test files.
 const uint8 kSecretKey[] = {
   0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b,
   0x68, 0xef, 0x12, 0x2a, 0xfc, 0xe4, 0xae, 0x3c
 };
 
 // The key ID for all encrypted files.
 const uint8 kKeyId[] = {

[ddorwin, 2015/06/04 19:57:17]

This is now only used for the rotation test (unless we start checking the
results of the initdata parsing). I wonder if we should move it to that test
class.

[jrummell, 2015/06/15 22:22:10]

Added check that key ID matches in non-rotating test.

   0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
   0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35
 };
 
 const int kAppendWholeFile = -1;
 
 // Constants for the Media Source config change tests.
 const int kAppendTimeSec = 1;
 const int kAppendTimeMs = kAppendTimeSec * 1000;
 const int k320WebMFileDurationMs = 2736;
@@ skipping 210 matching lines @@
   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                 const std::vector<uint8>& init_data,
                                 AesDecryptor* decryptor) override {
     // Since only 1 session is created, skip the request if the |init_data|
     // has been seen before (no need to add the same key again).
     if (init_data == prev_init_data_)
       return;
     prev_init_data_ = init_data;
 
     if (current_session_id_.empty()) {
-      if (init_data_type == EmeInitDataType::CENC) {
-        // Since the 'cenc' files are not created with proper 'pssh' boxes,
-        // simply pretend that this is a webm file and pass the expected
-        // key ID as the init_data.
-        // http://crbug.com/460308
-        decryptor->CreateSessionAndGenerateRequest(
-            MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
-            std::vector<uint8>(kKeyId, kKeyId + arraysize(kKeyId)),
-            CreateSessionPromise(RESOLVED));
-      } else {
-        decryptor->CreateSessionAndGenerateRequest(
-            MediaKeys::TEMPORARY_SESSION, init_data_type, init_data,
-            CreateSessionPromise(RESOLVED));
-      }
+      decryptor->CreateSessionAndGenerateRequest(
+          MediaKeys::TEMPORARY_SESSION, init_data_type, init_data,
+          CreateSessionPromise(RESOLVED));
       EXPECT_FALSE(current_session_id_.empty());
     }
 
-    // Clear Key really needs the key ID from |init_data|. For WebM, they are
-    // the same, but this is not the case for ISO CENC (key ID embedded in a
-    // 'pssh' box). Therefore, provide the correct key ID.
-    const uint8* key_id = vector_as_array(&init_data);
-    size_t key_id_length = init_data.size();
-    if (init_data_type == EmeInitDataType::CENC) {
-      key_id = kKeyId;
-      key_id_length = arraysize(kKeyId);
-    }
+    // Clear Key needs the key ID from |init_data|.

[ddorwin, 2015/06/04 19:57:17]

We should really wait for the message and extract the ID from there. As long as
this works, this is simpler. Perhaps note that we're taking a shortcut.

The above is the only thing special here. Getting the key ID from the init_data
would work for any system if a valid request is not required, as is the case for
Clear Key. I suggest something like "Get the key ID for the license from
|init_Data|."

[jrummell, 2015/06/15 22:22:10]

Waiting for message means we don't need to care about the format of |init_data|.
Done.

+    std::vector<uint8> key_id;
+    EXPECT_TRUE(GetKeyId(init_data_type, init_data, &key_id));
 
     // Convert key into a JSON structure and then add it.
-    std::string jwk = GenerateJWKSet(
-        kSecretKey, arraysize(kSecretKey), key_id, key_id_length);
+    std::string jwk = GenerateJWKSet(kSecretKey, arraysize(kSecretKey),
+                                     vector_as_array(&key_id), key_id.size());
     decryptor->UpdateSession(current_session_id_,
                              std::vector<uint8>(jwk.begin(), jwk.end()),
                              CreatePromise(RESOLVED));
   }
 
+  bool GetKeyId(EmeInitDataType init_data_type,

[ddorwin, 2015/06/04 19:57:17]

This can be a static function at the top.

[jrummell, 2015/06/15 22:22:10]

Removed.

+                const std::vector<uint8>& init_data,
+                std::vector<uint8>* key_id) {
+    // For WebM, init_data is key_id; for ISO CENC, init_data should

[ddorwin, 2015/06/04 19:57:17]

Function level comment.

nit: use pipes ('|')

[jrummell, 2015/06/15 22:22:10]

Removed.

+    // contain a 'pssh' box for the Common Encryption SystemID which
+    // will contain the key_id.

[ddorwin, 2015/06/04 19:57:18]

You might note that keyids does not need to be supported because it's not
contained in files. Perhaps include the enum with NOTREACHED() below.

[jrummell, 2015/06/15 22:22:10]

Removed.

+    DCHECK_GE(init_data.size(), arraysize(kKeyId));

[ddorwin, 2015/06/04 19:57:17]

arraysize(kKeyId) looks weird. Can we define a separate const below kKeyId that
is kKeyIdBytes?

[jrummell, 2015/06/15 22:22:10]

Removed.

+    DCHECK_EQ(key_id->size(), 0u);
+
+    switch (init_data_type) {
+      case EmeInitDataType::WEBM:
+        DCHECK_EQ(init_data.size(), arraysize(kKeyId));
+        key_id->assign(init_data.begin(), init_data.end());
+        return true;
+
+      case EmeInitDataType::CENC:
+#if defined(USE_PROPRIETARY_CODECS)
+        // |init_data| is a set of 0 or more concatenated 'pssh' boxes.
+        {
+          std::vector<std::vector<uint8_t>> keys;
+          EXPECT_TRUE(GetKeyIdsForCommonSystemId(init_data, &keys));
+          if (!keys.empty())
+            key_id->assign(keys[0].begin(), keys[0].end());
+          return !keys.empty();
+        }
+#else
+        return false;

[ddorwin, 2015/06/04 19:57:17]

Should we add this?
NOTREACHED() << "Attempted to use MP4 file without USE_PROPRIETARY_CODECS"

[jrummell, 2015/06/15 22:22:10]

Removed.

+#endif
+
+      default:
+        // Nothing else is supported.

[ddorwin, 2015/06/04 19:57:17]

NOTREACHED?

[jrummell, 2015/06/15 22:22:10]

Removed.

+        break;
+    }
+
+    return false;

[ddorwin, 2015/06/04 19:57:18]

You can move this up to 368. Or remove default so compilers can catch missing
values.

[jrummell, 2015/06/15 22:22:10]

Removed.

+  }
+
   std::string current_session_id_;
   std::vector<uint8> prev_init_data_;
 };
 
 class RotatingKeyProvidingApp : public KeyProvidingApp {
  public:
   RotatingKeyProvidingApp() : num_distint_need_key_calls_(0) {}
   ~RotatingKeyProvidingApp() override {
     // Expect that OnEncryptedMediaInitData is fired multiple times with
     // different |init_data|.
     EXPECT_GT(num_distint_need_key_calls_, 1u);
   }
 
   void OnEncryptedMediaInitData(EmeInitDataType 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_;
 
     std::vector<uint8> key_id;
     std::vector<uint8> key;
-    EXPECT_TRUE(GetKeyAndKeyId(init_data, &key, &key_id));
+    EXPECT_TRUE(GetKeyAndKeyId(init_data_type, init_data, &key, &key_id));
 
-    if (init_data_type == EmeInitDataType::CENC) {
-      // Since the 'cenc' files are not created with proper 'pssh' boxes,
-      // simply pretend that this is a webm file and pass the expected
-      // key ID as the init_data.
-      // http://crbug.com/460308
-      decryptor->CreateSessionAndGenerateRequest(
-          MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM, key_id,
-          CreateSessionPromise(RESOLVED));
-    } else {
-      decryptor->CreateSessionAndGenerateRequest(
-          MediaKeys::TEMPORARY_SESSION, init_data_type, init_data,
-          CreateSessionPromise(RESOLVED));
-    }
+    decryptor->CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
+                                               init_data_type, init_data,
+                                               CreateSessionPromise(RESOLVED));
 
     // 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),
                                      key_id.size());
     decryptor->UpdateSession(current_session_id_,
                              std::vector<uint8>(jwk.begin(), jwk.end()),
                              CreatePromise(RESOLVED));
   }
 
  private:
-  bool GetKeyAndKeyId(std::vector<uint8> init_data,
+  bool GetKeyAndKeyId(EmeInitDataType init_data_type,
+                      const std::vector<uint8>& init_data,
                       std::vector<uint8>* key,
                       std::vector<uint8>* key_id) {
-    // For WebM, init_data is key_id; for ISO CENC, init_data should contain
-    // the key_id. We assume key_id is in the end of init_data here (that is
-    // only a reasonable assumption for WebM and clear key ISO CENC).
     DCHECK_GE(init_data.size(), arraysize(kKeyId));
-    std::vector<uint8> key_id_from_init_data(
-        init_data.end() - arraysize(kKeyId), init_data.end());
+    std::vector<uint8> key_id_from_init_data;
+    EXPECT_TRUE(GetKeyId(init_data_type, init_data, &key_id_from_init_data));
 
     key->assign(kSecretKey, kSecretKey + arraysize(kSecretKey));
     key_id->assign(kKeyId, kKeyId + arraysize(kKeyId));
 
     // The Key and KeyId for this testing key provider are created by left

[ddorwin, 2015/06/04 19:57:17]

Do we still need to do this for the key ID since we can extract it successfully
now?

[jrummell, 2015/06/15 22:22:10]

Yes. The key for the rotated key ID is |kSecretKey| rotated by the same amount.
We could prebuild a table with all rotations, but it doesn't seem necessary.

     // rotating kSecretKey and kKeyId. Note that this implementation is only
     // intended for testing purpose. The actual key rotation algorithm can be
     // much more complicated.
     // Find out the rotating position from |key_id_from_init_data| and apply on
     // |key|.
     for (size_t pos = 0; pos < arraysize(kKeyId); ++pos) {
       std::rotate(key_id->begin(), key_id->begin() + pos, key_id->end());
       if (*key_id == key_id_from_init_data) {
         std::rotate(key->begin(), key->begin() + pos, key->end());
         return true;
@@ skipping 1312 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