src/media/test/data/eme_player_js/player_utils.js

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // The PlayerUtils provides utility functions to binding common media events
   6 // to specific player functions. It also provides functions to load media source
   7 // base on test configurations.
   8 var PlayerUtils = new function() {
   9 }
  10
  11 // Prepares a video element for playback by setting default event handlers
  12 // and source attribute.
  13 PlayerUtils.registerDefaultEventListeners = function(player) {
  14   Utils.timeLog('Registering video event handlers.');
  15   // Map from event name to event listener function name.  It is common for
  16   // event listeners to be named onEventName.
  17   var eventListenerMap = {
  18     'needkey': 'onNeedKey',
  19     'webkitneedkey': 'onWebkitNeedKey',
  20     'webkitkeymessage': 'onWebkitKeyMessage',
  21     'webkitkeyadded': 'onWebkitKeyAdded',
  22     'webkitkeyerror': 'onWebkitKeyError'
  23   };
  24   for (eventName in eventListenerMap) {
  25     var eventListenerFunction = player[eventListenerMap[eventName]];
  26     if (eventListenerFunction) {
  27       player.video.addEventListener(eventName, function(e) {
  28         player[eventListenerMap[e.type]](e);
  29       });
  30     }
  31   }
  32   // List of events that fail tests.
  33   var failingEvents = ['error', 'abort'];
  34   for (var i = 0; i < failingEvents.length; i++) {
  35     player.video.addEventListener(failingEvents[i], Utils.failTest);
  36   }
  37 };
  38
  39 PlayerUtils.registerEMEEventListeners = function(player) {
  40   player.video.addEventListener('needkey', function(message) {
  41
  42     function addMediaKeySessionListeners(mediaKeySession) {
  43       mediaKeySession.addEventListener('message', function(message) {
  44         player.video.receivedKeyMessage = true;
  45         if (Utils.isHeartBeatMessage(message.message)) {
  46           Utils.timeLog('MediaKeySession onMessage - heart beat', message);
  47           player.video.receivedHeartbeat = true;
  48         }
  49         player.onMessage(message);
  50       });
  51       mediaKeySession.addEventListener('error', function(error) {
  52         Utils.failTest(error, KEY_ERROR);
  53       });
  54     }
  55
  56     Utils.timeLog('Creating new media key session for contentType: ' +
  57                   message.contentType + ', initData: ' +
  58                   Utils.getHexString(message.initData));
  59     try {
  60       var session = message.target.mediaKeys.createSession(
  61           message.contentType, message.initData);
  62       if (PROMISES_SUPPORTED) {
  63         session.then(addMediaKeySessionListeners)
  64             .catch (function(error) {
  65               Utils.failTest(error, KEY_ERROR);
  66             });
  67       } else {
  68         addMediaKeySessionListeners(session);
  69       }
  70     } catch (e) {
  71       Utils.failTest(e);
  72     }
  73   });
  74   this.registerDefaultEventListeners(player);
  75   try {
  76     Utils.timeLog('Setting video media keys: ' + player.testConfig.keySystem);
  77     if (PROMISES_SUPPORTED) {
  78       MediaKeys.create(player.testConfig.keySystem).then(function(mediaKeys) {
  79         player.video.setMediaKeys(mediaKeys);
  80       }).catch(function(error) {
  81         Utils.failTest(error, NOTSUPPORTEDERROR);
  82       });
  83     } else {
  84       player.video.setMediaKeys(new MediaKeys(player.testConfig.keySystem));
  85     }
  86   } catch (e) {
  87     Utils.failTest(e);
  88   }
  89 };
  90
  91 PlayerUtils.registerPrefixedEMEEventListeners = function(player) {
  92  player.video.addEventListener('webkitneedkey', function(message) {
  93     var initData = message.initData;
  94     if (player.testConfig.sessionToLoad) {
  95       Utils.timeLog('Loading session: ' + player.testConfig.sessionToLoad);
  96       initData = Utils.convertToUint8Array(
  97           PREFIXED_API_LOAD_SESSION_HEADER + player.testConfig.sessionToLoad);
  98     }
  99     Utils.timeLog(player.testConfig.keySystem +
 100                   ' Generate key request, initData: ' +
 101                   Utils.getHexString(initData));
 102     try {
 103       message.target.webkitGenerateKeyRequest(player.testConfig.keySystem,
 104                                               initData);
 105     } catch (e) {
 106       Utils.failTest(e);
 107     }
 108   });
 109
 110   player.video.addEventListener('webkitkeyadded', function(message) {
 111     Utils.timeLog('onWebkitKeyAdded', message);
 112     message.target.receivedKeyAdded = true;
 113   });
 114
 115   player.video.addEventListener('webkitkeyerror', function(error) {
 116     Utils.timeLog('onWebkitKeyError', error);
 117     Utils.failTest(error, KEY_ERROR);
 118   });
 119
 120   player.video.addEventListener('webkitkeymessage', function(message) {
 121     Utils.timeLog('onWebkitKeyMessage', message);
 122     message.target.receivedKeyMessage = true;
 123     if (Utils.isHeartBeatMessage(message.message)) {
 124       Utils.timeLog('onWebkitKeyMessage - heart beat', message);
 125       message.target.receivedHeartbeat = true;
 126     }
 127   });
 128   this.registerDefaultEventListeners(player);
 129 };
 130
 131 PlayerUtils.setVideoSource = function(player) {
 132   if (player.testConfig.useMSE) {
 133     Utils.timeLog('Loading media using MSE.');
 134     var mediaSource =
 135         MediaSourceUtils.loadMediaSourceFromTestConfig(player.testConfig);
 136     player.video.src = window.URL.createObjectURL(mediaSource);
 137   } else {
 138     Utils.timeLog('Loading media using src.');
 139     player.video.src = player.testConfig.mediaFile;
 140   }
 141 };
 142
 143 PlayerUtils.initEMEPlayer = function(player) {
 144   this.registerEMEEventListeners(player);
 145   this.setVideoSource(player);
 146 };
 147
 148 PlayerUtils.initPrefixedEMEPlayer = function(player) {
 149   this.registerPrefixedEMEEventListeners(player);
 150   this.setVideoSource(player);
 151 };
 152
 153 // Return the appropriate player based on test configuration.
 154 PlayerUtils.createPlayer = function(video, testConfig) {
 155   // Update keySystem if using prefixed Clear Key since it is not available as a
 156   // separate key system to choose from; however it can be set in URL query.
 157   var usePrefixedEME = testConfig.usePrefixedEME;
 158   if (testConfig.keySystem == CLEARKEY && usePrefixedEME)
 159     testConfig.keySystem = PREFIXED_CLEARKEY;
 160
 161   function getPlayerType(keySystem) {
 162     switch (keySystem) {
 163       case WIDEVINE_KEYSYSTEM:
 164         if (usePrefixedEME)
 165           return PrefixedWidevinePlayer;
 166         return WidevinePlayer;
 167       case PREFIXED_CLEARKEY:
 168         return PrefixedClearKeyPlayer;
 169       case EXTERNAL_CLEARKEY:
 170       case CLEARKEY:
 171         if (usePrefixedEME)
 172           return PrefixedClearKeyPlayer;
 173         return ClearKeyPlayer;
 174       case FILE_IO_TEST_KEYSYSTEM:
 175         if (usePrefixedEME)
 176           return FileIOTestPlayer;
 177       default:
 178         Utils.timeLog(keySystem + ' is not a known key system');
 179         if (usePrefixedEME)
 180           return PrefixedClearKeyPlayer;
 181         return ClearKeyPlayer;
 182     }
 183   }
 184   var Player = getPlayerType(testConfig.keySystem);
 185   return new Player(video, testConfig);
 186 };