EME: Close existing sessions on CDM failure

media/test/data/eme_player_js/player_utils.js

 // Copyright 2014 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.
 
 // The PlayerUtils provides utility functions to binding common media events
 // to specific player functions. It also provides functions to load media source
 // base on test configurations.
 var PlayerUtils = new function() {
 }
 
@@ skipping 10 matching lines @@
     var eventListenerFunction = player[eventListenerMap[eventName]];
     if (eventListenerFunction) {
       player.video.addEventListener(eventName, function(e) {
         player[eventListenerMap[e.type]](e);
       });
     }
   }
 
   player.video.addEventListener('error', function(error) {
     // This most likely happens on pipeline failures (e.g. when the CDM
-    // crashes).
+    // crashes). Don't report a failure if the test is checking that sessions
+    // are closed on a crash.
     Utils.timeLog('onHTMLElementError', error);
-    Utils.failTest(error);
+    if (player.testConfig.keySystem == CRASH_TEST_KEYSYSTEM) {
+      // On failure the session should have been closed, so verify.
+      player.session.closed.then(
+          function(result) {
+            Utils.setResultInTitle(EME_SESSION_CLOSED_AND_ERROR);
+          },
+          function(error) { Utils.failTest(error); });
+    } else {
+      Utils.failTest(error);
+    }
   });
 };
 
 // Register the necessary event handlers needed when playing encrypted content.
 // Returns a promise that resolves to the player.
 PlayerUtils.registerEMEEventListeners = function(player) {
   player.video.addEventListener('encrypted', function(message) {
 
     function addMediaKeySessionListeners(mediaKeySession) {
       mediaKeySession.addEventListener('message', function(message) {
         player.video.receivedKeyMessage = true;
         if (Utils.isRenewalMessage(message)) {
           Utils.timeLog('MediaKeySession onMessage - renewal', message);
           player.video.receivedRenewalMessage = true;
         } else {
           if (message.messageType != 'license-request') {
             Utils.failTest('Unexpected message type "' + message.messageType +
                                '" received.',
                            EME_MESSAGE_UNEXPECTED_TYPE);
           }
         }
         player.onMessage(message);
       });
     }
 
     try {
       if (player.testConfig.sessionToLoad) {
         Utils.timeLog('Loading session: ' + player.testConfig.sessionToLoad);
-        var session =
+        player.session =
             message.target.mediaKeys.createSession('persistent-license');
-        addMediaKeySessionListeners(session);
-        session.load(player.testConfig.sessionToLoad)
+        addMediaKeySessionListeners(player.session);
+        player.session.load(player.testConfig.sessionToLoad)
             .then(
                 function(result) {
                   if (!result)
                     Utils.failTest('Session not found.', EME_SESSION_NOT_FOUND);
                 },
                 function(error) { Utils.failTest(error, EME_LOAD_FAILED); });
       } else {
         Utils.timeLog('Creating new media key session for initDataType: ' +
                       message.initDataType + ', initData: ' +
                       Utils.getHexString(new Uint8Array(message.initData)));
-        var session = message.target.mediaKeys.createSession();
-        addMediaKeySessionListeners(session);
-        session.generateRequest(message.initDataType, message.initData)
+        player.session = message.target.mediaKeys.createSession();
+        addMediaKeySessionListeners(player.session);
+        player.session.generateRequest(message.initDataType, message.initData)
             .catch(function(error) {
               // Ignore the error if a crash is expected. This ensures that
               // the decoder actually detects and reports the error.
-              if (this.testConfig.keySystem !=
-                  'org.chromium.externalclearkey.crash') {
+              if (this.testConfig.keySystem != CRASH_TEST_KEYSYSTEM) {
                 Utils.failTest(error, EME_GENERATEREQUEST_FAILED);
               }
             });
       }
     } catch (e) {
       Utils.failTest(e);
     }
   });
 
   this.registerDefaultEventListeners(player);
@@ skipping 98 matching lines @@
 
 // Return the appropriate player based on test configuration.
 PlayerUtils.createPlayer = function(video, testConfig) {
   function getPlayerType(keySystem) {
     switch (keySystem) {
       case WIDEVINE_KEYSYSTEM:
         return WidevinePlayer;
       case CLEARKEY:
       case EXTERNAL_CLEARKEY:
       case EXTERNAL_CLEARKEY_RENEWAL:
+      case CRASH_TEST_KEYSYSTEM:
         return ClearKeyPlayer;
       case FILE_IO_TEST_KEYSYSTEM:
       case OUTPUT_PROTECTION_TEST_KEYSYSTEM:
       case PLATFORM_VERIFICATION_TEST_KEYSYSTEM:
         return UnitTestPlayer;
       default:
         Utils.timeLog(keySystem + ' is not a known key system');
         return ClearKeyPlayer;
     }
   }
   var Player = getPlayerType(testConfig.keySystem);
   return new Player(video, testConfig);
 };