Implement ClearKey message format as JSON.

media/cdm/json_web_key_unittest.cc

 // Copyright 2013 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/json_web_key.h"
 
 #include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 class JSONWebKeyTest : public testing::Test {
  public:
   JSONWebKeyTest() {}
 
  protected:
   void ExtractJWKKeysAndExpect(const std::string& jwk,
                                bool expected_result,
                                size_t expected_number_of_keys) {
     DCHECK(!jwk.empty());
     KeyIdAndKeyPairs keys;
-    EXPECT_EQ(expected_result, ExtractKeysFromJWKSet(jwk, &keys));
+    MediaKeys::SessionType session_type;
+    EXPECT_EQ(expected_result,
+              ExtractKeysFromJWKSet(jwk, &keys, &session_type));
     EXPECT_EQ(expected_number_of_keys, keys.size());
   }
+
+  void ExtractSessionTypeAndExpect(const std::string& jwk,
+                                   bool expected_result,
+                                   MediaKeys::SessionType expected_type) {
+    DCHECK(!jwk.empty());
+    KeyIdAndKeyPairs keys;
+    MediaKeys::SessionType session_type;
+    EXPECT_EQ(expected_result,
+              ExtractKeysFromJWKSet(jwk, &keys, &session_type));
+    if (expected_result) {
+      // Only check if successful.
+      EXPECT_EQ(expected_type, session_type);
+    }
+  }
+
+  void CreateLicenseAndExpect(const uint8* key_id,
+                              int key_id_length,
+                              MediaKeys::SessionType session_type,
+                              std::string expected_result) {

[xhwang, 2014/07/30 05:56:08]

pass by const ref

[jrummell, 2014/07/30 18:44:16]

Done.

+    std::vector<uint8> result;
+    CreateLicenseRequest(key_id, key_id_length, session_type, result);
+    std::string s(result.begin(), result.end());
+    EXPECT_EQ(expected_result, s);
+  }
+
+  std::string HexString(const uint8* data, int length) {

[xhwang, 2014/07/30 05:56:08]

Can you use HexEncode? 

https://code.google.com/p/chromium/codesearch#chromium/src/base/strings/strin...

[jrummell, 2014/07/30 18:44:16]

No longer needed.

+    std::stringstream ss;
+    for (int i = 0; i < length; ++i, ++data) {
+      ss << std::hex << *data;
+    }
+    return ss.str();
+  }
+
+  void ExtractKeyFromLicenseAndExpect(const std::string license,

[xhwang, 2014/07/30 05:56:08]

pass by const ref

[jrummell, 2014/07/30 18:44:16]

Done.

+                                      bool expected_result,
+                                      const uint8* expected_key,
+                                      int expected_key_length) {
+    std::vector<uint8> expanded_license(license.begin(), license.end());

[xhwang, 2014/07/30 05:56:08]

what do you mean by "expanded"? If we just convert string to vector, how about
license_vector?

[jrummell, 2014/07/30 18:44:16]

Done.

+    std::vector<uint8> key;
+    EXPECT_EQ(expected_result, ExtractLicenseKey(expanded_license, key));
+    if (expected_result) {
+      EXPECT_EQ(HexString(expected_key, expected_key_length),
+                HexString(key.data(), key.size()));

[xhwang, 2014/07/30 05:56:08]

Why do you need to HexString() and then compare? Can't you just compare two
vectors?

[jrummell, 2014/07/30 18:44:16]

Didn't realize that EXPECT_EQ displays the vector contents on failure. Done.

+    }
+  }
 };
 
 TEST_F(JSONWebKeyTest, GenerateJWKSet) {
   const uint8 data1[] = { 0x01, 0x02 };
   const uint8 data2[] = { 0x01, 0x02, 0x03, 0x04 };
   const uint8 data3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
                           0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 };
 
   EXPECT_EQ("{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}]}",
             GenerateJWKSet(data1, arraysize(data1), data1, arraysize(data1)));
@@ skipping 140 matching lines @@
       "    {"
       "      \"kty\": \"oct\","
       "      \"kid\": \"JCUmJygpKissLS4vMA\","
       "      \"k\":\"MTIzNDU2Nzg5Ojs8PT4/QA\""
       "    }"
       "  ]"
       "}";
   ExtractJWKKeysAndExpect(kJwksDuplicateKids, true, 2);
 }
 
+TEST_F(JSONWebKeyTest, SessionType) {
+  ExtractSessionTypeAndExpect(
+      "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}]}",
+      true,
+      MediaKeys::TEMPORARY_SESSION);
+  ExtractSessionTypeAndExpect(
+      "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
+      "\"temporary\"}",
+      true,
+      MediaKeys::TEMPORARY_SESSION);
+  ExtractSessionTypeAndExpect(
+      "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
+      "\"persistent\"}",
+      true,
+      MediaKeys::PERSISTENT_SESSION);
+  ExtractSessionTypeAndExpect(
+      "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
+      "\"unknown\"}",
+      false,
+      MediaKeys::TEMPORARY_SESSION);
+  ExtractSessionTypeAndExpect(
+      "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":3}",
+      false,
+      MediaKeys::TEMPORARY_SESSION);
+}
+
+TEST_F(JSONWebKeyTest, CreateLicense) {
+  const uint8 data1[] = { 0x01, 0x02 };
+  const uint8 data2[] = { 0x01, 0x02, 0x03, 0x04 };
+  const uint8 data3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                          0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 };
+
+  CreateLicenseAndExpect(data1,
+                         arraysize(data1),
+                         MediaKeys::TEMPORARY_SESSION,
+                         "{\"kids\":[\"AQI\"],\"type\":\"temporary\"}");
+  CreateLicenseAndExpect(data1,
+                         arraysize(data1),
+                         MediaKeys::PERSISTENT_SESSION,
+                         "{\"kids\":[\"AQI\"],\"type\":\"persistent\"}");
+  CreateLicenseAndExpect(data2,
+                         arraysize(data2),
+                         MediaKeys::TEMPORARY_SESSION,
+                         "{\"kids\":[\"AQIDBA\"],\"type\":\"temporary\"}");
+  CreateLicenseAndExpect(
+      data3,
+      arraysize(data3),
+      MediaKeys::PERSISTENT_SESSION,
+      "{\"kids\":[\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":\"persistent\"}");
+}
+
+TEST_F(JSONWebKeyTest, ExtractLicense) {
+  const uint8 data1[] = { 0x01, 0x02 };
+  const uint8 data2[] = { 0x01, 0x02, 0x03, 0x04 };
+  const uint8 data3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                          0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 };
+
+  ExtractKeyFromLicenseAndExpect(
+      "{\"kids\":[\"AQI\"],\"type\":\"temporary\"}",
+      true,
+      data1,
+      arraysize(data1));
+  ExtractKeyFromLicenseAndExpect(
+      "{\"kids\":[\"AQIDBA\"],\"type\":\"temporary\"}",
+      true,
+      data2,
+      arraysize(data2));
+  ExtractKeyFromLicenseAndExpect(
+      "{\"kids\":[\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":\"persistent\"}",
+      true,
+      data3,
+      arraysize(data3));
+
+  // Try some incorrect JSON.
+  ExtractKeyFromLicenseAndExpect("", false, NULL, 0);
+  ExtractKeyFromLicenseAndExpect("!@#$%^&*()", false, NULL, 0);
+
+  // Valid JSON, but not a dictionary.
+  ExtractKeyFromLicenseAndExpect("6", false, NULL, 0);
+  ExtractKeyFromLicenseAndExpect("[\"AQI\"]", false, NULL, 0);
+
+  // Dictionary, but missing expected tag.
+  ExtractKeyFromLicenseAndExpect("{\"kid\":[\"AQI\"]}", false, NULL, 0);
+
+  // Correct tag, but empty list.
+  ExtractKeyFromLicenseAndExpect("{\"kids\":[]}", false, NULL, 0);
+
+  // Correct tag, but list doesn't contain a string.
+  ExtractKeyFromLicenseAndExpect("{\"kids\":[[\"AQI\"]]}", false, NULL, 0);
+
+  // Correct tag, but invalid base64 encoding.
+  ExtractKeyFromLicenseAndExpect("{\"kids\":[\"!@#$%^&*()\"]}", false, NULL, 0);
+}
+
 }  // namespace media