Add remove PUR session with no decrypt

This change adds a test that create and then remove a
persistent-usage-record session and verifies that the record of key
usage is present in the license-release message and are both 'null'

Bug: 1102976
Change-Id: I766a3104d84b1e477e54c65f30e62aa5645bd426
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2308173
Commit-Queue: Alex St-Onge <alstonge@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#790657}

chrome/browser/media/encrypted_media_browsertest.cc

@@ -885,6 +885,13 @@ IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, VerifyPersistentUsageRecord) {
                    media::kEnded);
 }
 
+IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, RemovePersistentUsageRecord) {
+  RunEncryptedMediaTest("eme_remove_session_test.html",
+                        "bear-320x240-v_enc-v.webm", kExternalClearKeyKeySystem,
+                        SrcType::MSE, kPersistentUsageRecord, false,
+                        PlayCount::ONCE, media::kEnded);
+}
+
 const char kExternalClearKeyDecryptOnlyKeySystem[] =
     "org.chromium.externalclearkey.decryptonly";
 

media/cdm/aes_decryptor.cc

@@ -644,14 +644,14 @@ CdmKeysInfo AesDecryptor::GenerateKeysInfoList(
   return keys_info;
 }
 
-void AesDecryptor::GetRecordOfKeyUsage(const std::string& session_id,
+bool AesDecryptor::GetRecordOfKeyUsage(const std::string& session_id,
                                        KeyIdList& key_ids,
                                        base::Time& first_decryption_time,
                                        base::Time& latest_decryption_time) {
   auto it = open_sessions_.find(session_id);
   if (it == open_sessions_.end() ||
       it->second != CdmSessionType::kPersistentUsageRecord) {
-    return;
+    return false;
   }
 
   base::AutoLock auto_lock(key_map_lock_);
@@ -663,6 +663,8 @@ void AesDecryptor::GetRecordOfKeyUsage(const std::string& session_id,
 
   first_decryption_time = first_decryption_time_;
   latest_decryption_time = latest_decryption_time_;
+
+  return true;
 }
 
 AesDecryptor::DecryptionKey::DecryptionKey(const std::string& secret)

media/cdm/aes_decryptor.h

@@ -176,9 +176,10 @@ class MEDIA_EXPORT AesDecryptor : public ContentDecryptionModule,
   CdmKeysInfo GenerateKeysInfoList(const std::string& session_id,
                                    CdmKeyInformation::KeyStatus status);
 
-  // Returns the record of key usage for persistent-usage-record session. Used
+  // Gets the record of key usage for persistent-usage-record session. Used
   // by ClearKeyPersistentSessionCdm.
-  void GetRecordOfKeyUsage(const std::string& session_id,
+  // Returns false if the session type is not Persistent-Usage-Record.
+  bool GetRecordOfKeyUsage(const std::string& session_id,
                            KeyIdList& key_ids,
                            base::Time& first_decryption_time,
                            base::Time& latest_decryption_time);

media/cdm/json_web_key.cc

@@ -33,6 +33,8 @@ const char kTypeTag[] = "type";
 const char kTemporarySession[] = "temporary";
 const char kPersistentLicenseSession[] = "persistent-license";
 const char kPersistentUsageRecordSession[] = "persistent-usage-record";
+const char kPersistentUsageRecordFirstTime[] = "firstTime";
+const char kPersistentUsageRecordLatestTime[] = "latestTime";
 
 static std::string ShortenTo64Characters(const std::string& input) {
   // Convert |input| into a string with escaped characters replacing any
@@ -69,6 +71,12 @@ static std::unique_ptr<base::DictionaryValue> CreateJSONDictionary(
   return jwk;
 }
 
+// base::DictionaryValue::Set() does not accept nullptr. A 'null' Value must
+// be used instead if we want to add a key to a JSON with a 'null' value.
+static std::unique_ptr<base::Value> GetNullValue() {
+  return std::make_unique<base::Value>(base::Value::Type::NONE);
+}
+
 std::string GenerateJWKSet(const uint8_t* key,
                            int key_length,
                            const uint8_t* key_id,
@@ -380,7 +388,13 @@ void CreateKeyIdsInitData(const KeyIdList& key_ids,
 //    "kids"
 //      An array of key IDs. Each element of the array is the base64url encoding
 //      of the octet sequence containing the key ID value.
-//
+std::vector<uint8_t> CreateLicenseReleaseMessage(const KeyIdList& key_ids) {
+  // Create the init_data.
+  auto dictionary = std::make_unique<base::DictionaryValue>();
+  AddKeyIdsToDictionary(key_ids, dictionary.get());
+  return SerializeDictionaryToVector(dictionary.get());
+}
+
 // For sessions of type "persistent-usage-record" the object shall also contain
 // the following members:
 //
@@ -399,13 +413,20 @@ std::vector<uint8_t> CreateLicenseReleaseMessage(
   auto dictionary = std::make_unique<base::DictionaryValue>();
   AddKeyIdsToDictionary(key_ids, dictionary.get());
 
-  if (!first_decrypt_time.is_null() && !latest_decrypt_time.is_null()) {
+  if (!first_decrypt_time.is_null()) {
     // Persistent-Usage-Record
     // Time need to be millisecond since 01 January, 1970 UTC
-    dictionary->SetDouble("firstTime",
+    dictionary->SetDouble(kPersistentUsageRecordFirstTime,
                           first_decrypt_time.ToJsTimeIgnoringNull());
-    dictionary->SetDouble("latestTime",
+  } else {
+    dictionary->Set(kPersistentUsageRecordFirstTime, GetNullValue());
+  }
+
+  if (!latest_decrypt_time.is_null()) {
+    dictionary->SetDouble(kPersistentUsageRecordLatestTime,
                           latest_decrypt_time.ToJsTimeIgnoringNull());
+  } else {
+    dictionary->Set(kPersistentUsageRecordLatestTime, GetNullValue());
   }
 
   return SerializeDictionaryToVector(dictionary.get());

media/cdm/json_web_key.h

@@ -95,10 +95,13 @@ MEDIA_EXPORT void CreateLicenseRequest(const KeyIdList& key_ids,
 MEDIA_EXPORT void CreateKeyIdsInitData(const KeyIdList& key_ids,
                                        std::vector<uint8_t>* key_ids_init_data);
 
+MEDIA_EXPORT std::vector<uint8_t> CreateLicenseReleaseMessage(
+    const KeyIdList& key_ids);
+
 MEDIA_EXPORT std::vector<uint8_t> CreateLicenseReleaseMessage(
     const KeyIdList& key_ids,
-    const base::Time first_decrypt_time = base::Time(),
-    const base::Time latest_decrypt_time = base::Time());
+    const base::Time first_decrypt_time,
+    const base::Time latest_decrypt_time);
 
 // Extract the first key from the license request message. Returns true if
 // |license| is a valid license request and contains at least one key,

media/cdm/library_cdm/clear_key_cdm/clear_key_persistent_session_cdm.cc

@@ -303,8 +303,9 @@ void ClearKeyPersistentSessionCdm::RemoveSession(
     // Not a persistent session, so simply pass the request on.
 
     // TODO(crbug.com/1102976) Add test for loading PUR session
-    // Query the record of key usage before calling remove as RemoveSession will
-    // delete the keys. Steps from
+    // TODO(crbug.com/1107614) Move session message for persistent-license
+    // session to ClearKeyPersistentSessionCdm Query the record of key usage
+    // before calling remove as RemoveSession will delete the keys. Steps from
     // https://w3c.github.io/encrypted-media/#remove. 4.4.1.2 Follow the steps
     // for the value of this object's session type
     //           "persistent-usage-record"
@@ -313,12 +314,12 @@ void ClearKeyPersistentSessionCdm::RemoveSession(
     KeyIdList key_ids;
     base::Time first_decryption_time;
     base::Time latest_decryption_time;
-    cdm_->GetRecordOfKeyUsage(session_id, key_ids, first_decryption_time,
-                              latest_decryption_time);
+    bool is_persistent_usage_record_session = cdm_->GetRecordOfKeyUsage(
+        session_id, key_ids, first_decryption_time, latest_decryption_time);
     cdm_->RemoveSession(session_id, std::move(promise));
 
     // Both times will be null if the session type is not PUR.
-    if (!first_decryption_time.is_null() && !latest_decryption_time.is_null()) {
+    if (is_persistent_usage_record_session) {
       std::vector<uint8_t> message = CreateLicenseReleaseMessage(
           key_ids, first_decryption_time, latest_decryption_time);
       // EME spec specifies that the message event should be fired before the

media/test/data/eme_player_js/player_utils.js

@@ -349,7 +349,7 @@ PlayerUtils.removeSession = async function(player) {
         Utils.timeLog(e.messageType);
         if (e.messageType == 'license-release' &&
             player.testConfig.sessionToLoad == 'PersistentUsageRecord') {
-          Utils.verifyUsageRecord(e.message);
+          Utils.verifyUsageRecord(e.message, /* expectNullTime= */ false);
         }
         // TODO: verify license-release message for persistent-license session
         resolve();

media/test/data/eme_player_js/utils.js

@@ -107,20 +107,26 @@ Utils.extractFirstLicenseKeyId = function(message) {
 };
 
 Utils.verifyUsageRecord =
-    function(message) {
+    function(message, expectNullTime) {
   try {
     var json = JSON.parse(convertToString(message));
-    var first_decrypt_time = new Date(json.firstTime);
-    var last_decrypt_time = new Date(json.latestTime);
-    Utils.timeLog('First decrypt time: ' + first_decrypt_time.toISOString());
-    Utils.timeLog('Last decrypt time: ' + last_decrypt_time.toISOString());
-
-    var delta = json.latestTime - json.firstTime;
-    // The video used for the tests is roughly 2.5 seconds.
-    if (delta < 2000 || delta > 3000) {
+    if (expectNullTime && (json.firstTime != null || json.latestTime != null)) {
       Utils.failTest(
-          'The usage record reported by the CDM was not in the' +
-          'expected range')
+          'Expecting null time for usage record but got firstTime=' +
+          json.firstTime + ', latestTime=' + json.latestTime);
+    } else if (!expectNullTime) {
+      var first_decrypt_time = new Date(json.firstTime);
+      var last_decrypt_time = new Date(json.latestTime);
+      Utils.timeLog('First decrypt time: ' + first_decrypt_time.toISOString());
+      Utils.timeLog('Last decrypt time: ' + last_decrypt_time.toISOString());
+
+      var delta = json.latestTime - json.firstTime;
+      // The video used for the tests is roughly 2.5 seconds.
+      if (delta < 2000 || delta > 3000) {
+        Utils.failTest(
+            'The usage record reported by the CDM was not in the ' +
+            'expected range')
+      }
     }
 
   } catch (error) {

media/test/data/eme_remove_session_test.html

@@ -44,6 +44,11 @@
       event, resolve, reject) {
     var mediaKeySession = event.target;
 
+    if (event.messageType == "license-release" &&
+        testConfig.sessionToLoad == 'PersistentUsageRecord') {
+      Utils.verifyUsageRecord(event.message, /* expectNullTime= */ true);
+    }
+
     Utils.timeLog('Calling update()');
     const jwkSet = Utils.createJWKData(keyId, key);
     mediaKeySession.update(jwkSet).then(resolve, reject);
@@ -63,7 +68,7 @@
   // This test doesn't play any media, so no concern with specifying multiple
   // codecs. This is done to provide a set of codecs that should cover all
   // user agents.
-  const config = [{
+  config = [{
     initDataTypes: ['webm'],
     audioCapabilities: [
       {contentType: 'audio/mp4; codecs="mp4a.40.2"'},
@@ -73,6 +78,10 @@
     sessionTypes: ['temporary'],
   }];
 
+  if (testConfig.sessionToLoad == "PersistentUsageRecord") {
+    config[0].sessionTypes.push('persistent-usage-record');
+  }
+
   var mediaKeySession;
   navigator.requestMediaKeySystemAccess(testConfig.keySystem, config)
       .then(function(access) {
@@ -83,7 +92,11 @@
       })
       .then(function(mediaKeys) {
         Utils.timeLog('Creating session');
-        mediaKeySession = mediaKeys.createSession();
+        if (testConfig.sessionToLoad == "PersistentUsageRecord") {
+          mediaKeySession = mediaKeys.createSession("persistent-usage-record");
+        } else {
+          mediaKeySession = mediaKeys.createSession();
+        }
 
         // Register for the 'message' event before it happens. Although the
         // event shouldn't be generated until after the generateRequest()
@@ -123,15 +136,22 @@
         Utils.verifyKeyStatuses(
             mediaKeySession.keyStatuses, [{keyId: keyId, status: 'usable'}]);
 
+        promises = [];
         // Once remove() is called, another 'keystatuseschange' event will
         // happen.
-        const waitForKeyStatusChangePromise =
-            Utils.waitForEvent(mediaKeySession, 'keystatuseschange');
+        promises.push(Utils.waitForEvent(mediaKeySession, 'keystatuseschange'));
+
+        // For persistent-usage-record session, a license-release "message"
+        // event will happen.
+        if (testConfig.sessionToLoad == "PersistentUsageRecord") {
+          promises.push(Utils.waitForEvent(
+            mediaKeySession, 'message', keySystemHelper.onMessage));
+        }
 
         Utils.timeLog('Calling remove()');
-        const removePromise = mediaKeySession.remove();
+        promises.push(mediaKeySession.remove());
 
-        return Promise.all([removePromise, waitForKeyStatusChangePromise]);
+        return Promise.all(promises);
       })
       .then(function() {
         // After remove() all keys should be 'released'.