Have GetKeyIds() return the key IDs from the first matching 'pssh' box

media/cdm/cenc_utils_unittest.cc

 // Copyright 2015 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/cdm/cenc_utils.h"
 
 #include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
@@ skipping 162 matching lines @@
   std::vector<uint8_t> key1_;
   std::vector<uint8_t> key2_;
   std::vector<uint8_t> key3_;
   std::vector<uint8_t> key4_;
   std::vector<uint8_t> common_system_system_id_;
 };
 
 TEST_F(CencUtilsTest, EmptyPSSH) {
   KeyIdList key_ids;
   EXPECT_TRUE(ValidatePsshInput(std::vector<uint8_t>()));
-  EXPECT_FALSE(GetKeyIdsForCommonSystemId(std::vector<uint8_t>(), &key_ids));
+  EXPECT_FALSE(
+      GetKeyIds(std::vector<uint8_t>(), CommonSystemSystemId(), &key_ids));

[sandersd (OOO until July 31), 2015/06/22 20:17:20]

Add a test using a different key system ID?

[jrummell, 2015/06/22 21:01:18]

There is one (line 295), but added a second variation.

[sandersd (OOO until July 31), 2015/06/22 22:23:29]

I would also like to see a test were a |key_system_id| that is not
CommonSystemSystemId() matches successfully, because the ability to do that was
one of the key new features in this CL.

[jrummell, 2015/06/24 00:18:47]

Added.

 }
 
 TEST_F(CencUtilsTest, PSSHVersion0) {
   std::vector<uint8_t> box = MakePSSHBox(0);
   KeyIdList key_ids;
   EXPECT_TRUE(ValidatePsshInput(box));
-  EXPECT_FALSE(GetKeyIdsForCommonSystemId(box, &key_ids));
+  EXPECT_FALSE(GetKeyIds(box, CommonSystemSystemId(), &key_ids));
 }
 
 TEST_F(CencUtilsTest, PSSHVersion1WithNoKeys) {
   std::vector<uint8_t> box = MakePSSHBox(1);
   KeyIdList key_ids;
   EXPECT_TRUE(ValidatePsshInput(box));
-  EXPECT_FALSE(GetKeyIdsForCommonSystemId(box, &key_ids));
+  EXPECT_FALSE(GetKeyIds(box, CommonSystemSystemId(), &key_ids));
 }
 
 TEST_F(CencUtilsTest, PSSHVersion1WithOneKey) {
   std::vector<uint8_t> box = MakePSSHBox(1, Key1());
   KeyIdList key_ids;
   EXPECT_TRUE(ValidatePsshInput(box));
-  EXPECT_TRUE(GetKeyIdsForCommonSystemId(box, &key_ids));
+  EXPECT_TRUE(GetKeyIds(box, CommonSystemSystemId(), &key_ids));
   EXPECT_EQ(1u, key_ids.size());
   EXPECT_EQ(key_ids[0], Key1());
 }
 
 TEST_F(CencUtilsTest, PSSHVersion1WithTwoKeys) {
   std::vector<uint8_t> box = MakePSSHBox(1, Key1(), Key2());
   KeyIdList key_ids;
   EXPECT_TRUE(ValidatePsshInput(box));
-  EXPECT_TRUE(GetKeyIdsForCommonSystemId(box, &key_ids));
+  EXPECT_TRUE(GetKeyIds(box, CommonSystemSystemId(), &key_ids));
   EXPECT_EQ(2u, key_ids.size());
   EXPECT_EQ(key_ids[0], Key1());
   EXPECT_EQ(key_ids[1], Key2());
 }
 
 TEST_F(CencUtilsTest, PSSHVersion0Plus1) {
   std::vector<uint8_t> box0 = MakePSSHBox(0);
   std::vector<uint8_t> box1 = MakePSSHBox(1, Key1());
 
   // Concatentate box1 onto end of box0.
   box0.insert(box0.end(), box1.begin(), box1.end());
+  EXPECT_TRUE(ValidatePsshInput(box0));
 
+  // No key IDs returned as only the first 'pssh' box is processed.
   KeyIdList key_ids;
-  EXPECT_TRUE(ValidatePsshInput(box0));
-  EXPECT_TRUE(GetKeyIdsForCommonSystemId(box0, &key_ids));
-  EXPECT_EQ(1u, key_ids.size());
-  EXPECT_EQ(key_ids[0], Key1());
+  EXPECT_FALSE(GetKeyIds(box0, CommonSystemSystemId(), &key_ids));
 }
 
 TEST_F(CencUtilsTest, PSSHVersion1Plus0) {
   std::vector<uint8_t> box0 = MakePSSHBox(0);
   std::vector<uint8_t> box1 = MakePSSHBox(1, Key1());
 
   // Concatentate box0 onto end of box1.
   box1.insert(box1.end(), box0.begin(), box0.end());
+  EXPECT_TRUE(ValidatePsshInput(box1));
 
   KeyIdList key_ids;
-  EXPECT_TRUE(ValidatePsshInput(box1));
-  EXPECT_TRUE(GetKeyIdsForCommonSystemId(box1, &key_ids));
+  EXPECT_TRUE(GetKeyIds(box1, CommonSystemSystemId(), &key_ids));
   EXPECT_EQ(1u, key_ids.size());
   EXPECT_EQ(key_ids[0], Key1());
 }
 
 TEST_F(CencUtilsTest, MultiplePSSHVersion1) {
   std::vector<uint8_t> box = MakePSSHBox(1, Key1(), Key2());
   std::vector<uint8_t> box1 = MakePSSHBox(1, Key3());
   std::vector<uint8_t> box2 = MakePSSHBox(1, Key4());
 
   // Concatentate box1 and box2 onto end of box.
   box.insert(box.end(), box1.begin(), box1.end());
   box.insert(box.end(), box2.begin(), box2.end());
+  EXPECT_TRUE(ValidatePsshInput(box));
 
   KeyIdList key_ids;
-  EXPECT_TRUE(ValidatePsshInput(box));
-  // TODO(jrummell): GetKeyIdsForCommonSystemId() returns the key IDs out of
-  // all matching boxes. It should only return the key IDs from the first
-  // matching box.
-  EXPECT_TRUE(GetKeyIdsForCommonSystemId(box, &key_ids));
-  EXPECT_EQ(4u, key_ids.size());
+  EXPECT_TRUE(GetKeyIds(box, CommonSystemSystemId(), &key_ids));
+  EXPECT_EQ(2u, key_ids.size());
   EXPECT_EQ(key_ids[0], Key1());
   EXPECT_EQ(key_ids[1], Key2());
-  EXPECT_EQ(key_ids[2], Key3());
-  EXPECT_EQ(key_ids[3], Key4());
 }
 
 TEST_F(CencUtilsTest, PsshBoxSmallerThanSize) {
   std::vector<uint8_t> box = MakePSSHBox(1, Key1(), Key2());
   KeyIdList key_ids;
 
   // Tries every buffer size less than the indicated 'pssh' box size.
   for (size_t i = 1; i < box.size(); ++i) {
     // Truncate the box to be less than the specified box size.
     std::vector<uint8_t> truncated(&box[0], &box[0] + i);
     EXPECT_FALSE(ValidatePsshInput(truncated)) << "Failed for length " << i;
-    EXPECT_FALSE(GetKeyIdsForCommonSystemId(truncated, &key_ids));
+    EXPECT_FALSE(GetKeyIds(truncated, CommonSystemSystemId(), &key_ids));
   }
 }
 
 TEST_F(CencUtilsTest, PsshBoxLargerThanSize) {
   std::vector<uint8_t> box = MakePSSHBox(1, Key1(), Key2());
   KeyIdList key_ids;
 
   // Add 20 additional bytes to |box|.
   size_t original_size = box.size();
   for (size_t i = 0; i < 20; ++i)
     box.push_back(i);
 
   // Tries every size greater than |original_size|.
   for (size_t i = original_size + 1; i < box.size(); ++i) {
     // Modify size of box passed to be less than current size.
     std::vector<uint8_t> truncated(&box[0], &box[0] + i);
     EXPECT_FALSE(ValidatePsshInput(truncated)) << "Failed for length " << i;
-    EXPECT_FALSE(GetKeyIdsForCommonSystemId(truncated, &key_ids));
+    EXPECT_FALSE(GetKeyIds(truncated, CommonSystemSystemId(), &key_ids));
   }
 }
 
 TEST_F(CencUtilsTest, UnrecognizedSystemID) {
   std::vector<uint8_t> box = MakePSSHBox(1, Key1(), Key2());
 
   // Modify the System ID.
   ++box[20];
 
   KeyIdList key_ids;
-  EXPECT_FALSE(GetKeyIdsForCommonSystemId(box, &key_ids));
+  EXPECT_FALSE(GetKeyIds(box, CommonSystemSystemId(), &key_ids));
 }
 
 TEST_F(CencUtilsTest, InvalidFlags) {
   std::vector<uint8_t> box = MakePSSHBox(1, Key1(), Key2());
 
   // Modify flags.
   box[10] = 3;
 
   KeyIdList key_ids;
-  EXPECT_FALSE(GetKeyIdsForCommonSystemId(box, &key_ids));
+  EXPECT_FALSE(GetKeyIds(box, CommonSystemSystemId(), &key_ids));
 }
 
 TEST_F(CencUtilsTest, LongSize) {
   const uint8_t data[] = {
       0x00, 0x00, 0x00, 0x01,                          // size = 1
       0x70, 0x73, 0x73, 0x68,                          // 'pssh'
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c,  // longsize
       0x01,                                            // version
       0x00, 0x00, 0x00,                                // flags
       0x10, 0x77, 0xEF, 0xEC, 0xC0, 0xB2, 0x4D, 0x02,  // SystemID
       0xAC, 0xE3, 0x3C, 0x1E, 0x52, 0xE2, 0xFB, 0x4B,
       0x00, 0x00, 0x00, 0x02,                          // key count
       0x7E, 0x57, 0x1D, 0x03, 0x7E, 0x57, 0x1D, 0x03,  // key1
       0x7E, 0x57, 0x1D, 0x03, 0x7E, 0x57, 0x1D, 0x03,
       0x7E, 0x57, 0x1D, 0x04, 0x7E, 0x57, 0x1D, 0x04,  // key2
       0x7E, 0x57, 0x1D, 0x04, 0x7E, 0x57, 0x1D, 0x04,
       0x00, 0x00, 0x00, 0x00  // datasize
   };
 
   KeyIdList key_ids;
   EXPECT_TRUE(
       ValidatePsshInput(std::vector<uint8_t>(data, data + arraysize(data))));
-  EXPECT_TRUE(GetKeyIdsForCommonSystemId(
-      std::vector<uint8_t>(data, data + arraysize(data)), &key_ids));
+  EXPECT_TRUE(GetKeyIds(std::vector<uint8_t>(data, data + arraysize(data)),
+                        CommonSystemSystemId(), &key_ids));
   EXPECT_EQ(2u, key_ids.size());
 }
 
 TEST_F(CencUtilsTest, SizeIsZero) {
   const uint8_t data[] = {
       0x00, 0x00, 0x00, 0x00,                          // size = 0
       0x70, 0x73, 0x73, 0x68,                          // 'pssh'
       0x01,                                            // version
       0x00, 0x00, 0x00,                                // flags
       0x10, 0x77, 0xEF, 0xEC, 0xC0, 0xB2, 0x4D, 0x02,  // SystemID
       0xAC, 0xE3, 0x3C, 0x1E, 0x52, 0xE2, 0xFB, 0x4B,
       0x00, 0x00, 0x00, 0x02,                          // key count
       0x7E, 0x57, 0x1D, 0x03, 0x7E, 0x57, 0x1D, 0x03,  // key1
       0x7E, 0x57, 0x1D, 0x03, 0x7E, 0x57, 0x1D, 0x03,
       0x7E, 0x57, 0x1D, 0x04, 0x7E, 0x57, 0x1D, 0x04,  // key2
       0x7E, 0x57, 0x1D, 0x04, 0x7E, 0x57, 0x1D, 0x04,
       0x00, 0x00, 0x00, 0x00  // datasize
   };
 
   KeyIdList key_ids;
   EXPECT_TRUE(
       ValidatePsshInput(std::vector<uint8_t>(data, data + arraysize(data))));
-  EXPECT_TRUE(GetKeyIdsForCommonSystemId(
-      std::vector<uint8_t>(data, data + arraysize(data)), &key_ids));
+  EXPECT_TRUE(GetKeyIds(std::vector<uint8_t>(data, data + arraysize(data)),
+                        CommonSystemSystemId(), &key_ids));
   EXPECT_EQ(2u, key_ids.size());
 }
 
 TEST_F(CencUtilsTest, HugeSize) {
   const uint8_t data[] = {
       0x00, 0x00, 0x00, 0x01,                          // size = 1
       0x70, 0x73, 0x73, 0x68,                          // 'pssh'
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  // longsize = big
       0x01,                                            // version
       0x00, 0x00, 0x00,                                // flags
       0x10, 0x77, 0xEF, 0xEC, 0xC0, 0xB2, 0x4D, 0x02,  // SystemID
       0xAC, 0xE3, 0x3C, 0x1E, 0x52, 0xE2, 0xFB, 0x4B,
       0x00, 0x00, 0x00, 0x02,                          // key count
       0x7E, 0x57, 0x1D, 0x03, 0x7E, 0x57, 0x1D, 0x03,  // key1
       0x7E, 0x57, 0x1D, 0x03, 0x7E, 0x57, 0x1D, 0x03,
       0x7E, 0x57, 0x1D, 0x04, 0x7E, 0x57, 0x1D, 0x04,  // key2
       0x7E, 0x57, 0x1D, 0x04, 0x7E, 0x57, 0x1D, 0x04,
       0x00, 0x00, 0x00, 0x00  // datasize
   };
 
   KeyIdList key_ids;
   // These calls fail as the box size is huge (0xffffffffffffffff) and there
   // is not enough bytes in |data|.
   EXPECT_FALSE(
       ValidatePsshInput(std::vector<uint8_t>(data, data + arraysize(data))));
-  EXPECT_FALSE(GetKeyIdsForCommonSystemId(
-      std::vector<uint8_t>(data, data + arraysize(data)), &key_ids));
+  EXPECT_FALSE(GetKeyIds(std::vector<uint8_t>(data, data + arraysize(data)),
+                         CommonSystemSystemId(), &key_ids));
 }
 
 TEST_F(CencUtilsTest, GetPsshData_Version0) {
   const uint8_t data_bytes[] = {0x01, 0x02, 0x03, 0x04};
   std::vector<uint8_t> pssh_data;
 
   std::vector<uint8_t> box = MakePSSHBox(0);
   EXPECT_TRUE(GetPsshData(box, CommonSystemSystemId(), &pssh_data));
   EXPECT_EQ(0u, pssh_data.size());
 
@@ skipping 47 matching lines @@
 
   std::vector<uint8_t> box_v1 = MakePSSHBox(1, Key1());
   std::vector<uint8_t> box_v2 = MakePSSHBox(2, Key2(), Key3());
 
   // Concatentate the boxes together (v2 first).
   std::vector<uint8_t> boxes;
   boxes.insert(boxes.end(), box_v2.begin(), box_v2.end());
   boxes.insert(boxes.end(), box_v1.begin(), box_v1.end());
   EXPECT_TRUE(GetPsshData(boxes, CommonSystemSystemId(), &pssh_data));
 
-  // GetKeyIdsForCommonSystemId() should return the single key from the v1
-  // 'pssh' box.
+  // GetKeyIds() should return the single key from the v1 'pssh' box.
   KeyIdList key_ids;
-  EXPECT_TRUE(GetKeyIdsForCommonSystemId(boxes, &key_ids));
+  EXPECT_TRUE(GetKeyIds(boxes, CommonSystemSystemId(), &key_ids));
   EXPECT_EQ(1u, key_ids.size());
   EXPECT_EQ(key_ids[0], Key1());
 }
 
 TEST_F(CencUtilsTest, GetPsshData_Version1ThenVersion2) {
   std::vector<uint8_t> pssh_data;
 
   std::vector<uint8_t> box_v1 = MakePSSHBox(1, Key3());
   std::vector<uint8_t> box_v2 = MakePSSHBox(2, Key4());
 
   // Concatentate the boxes together (v1 first).
   std::vector<uint8_t> boxes;
   boxes.insert(boxes.end(), box_v1.begin(), box_v1.end());
   boxes.insert(boxes.end(), box_v2.begin(), box_v2.end());
   EXPECT_TRUE(GetPsshData(boxes, CommonSystemSystemId(), &pssh_data));
 
-  // GetKeyIdsForCommonSystemId() should return the single key from the v1
-  // 'pssh' box.
+  // GetKeyIds() should return the single key from the v1 'pssh' box.
   KeyIdList key_ids;
-  EXPECT_TRUE(GetKeyIdsForCommonSystemId(boxes, &key_ids));
+  EXPECT_TRUE(GetKeyIds(boxes, CommonSystemSystemId(), &key_ids));
   EXPECT_EQ(1u, key_ids.size());
   EXPECT_EQ(key_ids[0], Key3());
 }
 
 TEST_F(CencUtilsTest, GetPsshData_DifferentSystemID) {
   std::vector<uint8_t> unknown_system_id(kKey1Data,
                                          kKey1Data + arraysize(kKey1Data));
   std::vector<uint8_t> pssh_data;
 
   std::vector<uint8_t> box = MakePSSHBox(1, Key1());
@@ skipping 28 matching lines @@
   std::vector<uint8_t> box2 = MakePSSHBox(0);
   std::vector<uint8_t> data2(data2_bytes, data2_bytes + arraysize(data2_bytes));
   AppendData(box2, data2);
 
   box1.insert(box1.end(), box2.begin(), box2.end());
   EXPECT_TRUE(GetPsshData(box1, CommonSystemSystemId(), &pssh_data));
   EXPECT_EQ(data1, pssh_data);
   EXPECT_NE(data2, pssh_data);
 }
 }  // namespace media