Integrate browser tests with new EME player.

chrome/test/data/media/eme_player_js/player.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.
 
 // Prepares a video element for playback by setting default event handlers
 // and source attribute.
 function InitPlayer(player, video) {
   Utils.timeLog('Registering video event handlers.');
 
   // Map from event name to event listener function name.  It is common for
   // event listeners to be named onEventName.
   var eventListenerMap = {
     'needkey': 'onNeedKey',
     'webkitneedkey': 'onWebkitNeedKey',
     'webkitkeymessage': 'onWebkitKeyMessage',
     'webkitkeyadded': 'onWebkitKeyAdded',
+    'webkitkeyerror': 'onWebkitKeyError',
     'error': 'onError',
     'abort': 'onAbort'
   };
 
   // List of events that fail tests.
   var failingEvents = ['error', 'onAbort'];

[jrummell, 2014/05/29 21:45:05]

I'm confused. The first entry is event name, the second is a listener function
name. Shouldn't these be the same type? From below it appears they need to be
event names.

[shadi, 2014/05/31 00:31:37]

Done.

 
   for (eventName in eventListenerMap) {
     video.addEventListener(eventName,
                            player[eventListenerMap[eventName]] || function(){});
   }
 
   for (var i = 0; i < failingEvents.length; i++) {
     video.addEventListener(failingEvents[i], Utils.failTest);
   }
 
   if (TestConfig.useSRC) {
     Utils.timeLog('Loading media using src.');
     video.src = TestConfig.mediaFile;
   } else {
     var mediaSource = MediaSourceUtils.loadMediaSourceForTest();
     video.src = window.URL.createObjectURL(mediaSource);
   }
 }
 
 function InitEMEPlayer(player, video) {
   player.onNeedKey = function(message) {
     Utils.timeLog('Creating new media key session for contentType: ' +
                   message.contentType + ', initData: ' +
                   Utils.getHexString(message.initData));
     try {
       var mediaKeySession = message.target.mediaKeys.createSession(
           message.contentType, message.initData);
       mediaKeySession.addEventListener('message', player.onMessage);
+      mediaKeySession.addEventListener('message', function(message) {
+        video.receivedKeyMessage = true;
+        if (Utils.isHeartBeatMessage(message.message)) {
+          Utils.timeLog('MediaKeySession onMessage - heart beat', message);
+          video.receivedHeartbeat = true;
+          return;

[jrummell, 2014/05/29 21:45:05]

The return is not really necessary.

[shadi, 2014/05/31 00:31:37]

Done.

+        }
+      });
       mediaKeySession.addEventListener('error', function(error) {
-        Utils.failTest(error);
+        Utils.failTest(error, KEY_ERROR);
       });
-    } catch (e) {
-      Utils.failTest(e);
+    } catch (error) {

[ddorwin, 2014/05/30 17:42:56]

This is really an "exception". I think "e" is probably used like this commonly
enough for this to be okay, but I'm not familiar with the JS style.

This is also a little confusing with error at 60-61.

[shadi, 2014/05/31 00:31:37]

Done.

+      Utils.failTest(error);
     }
   };
 
   InitPlayer(player, video);
   try {
     Utils.timeLog('Setting video media keys: ' + TestConfig.keySystem);
     video.setMediaKeys(new MediaKeys(TestConfig.keySystem));
   } catch (e) {
     Utils.failTest(e);
   }
 }
 
 function InitPrefixedEMEPlayer(player, video) {
   player.onWebkitNeedKey = function(message) {
     Utils.timeLog(TestConfig.keySystem + ' Generate key request, initData: ' +
                   Utils.getHexString(message.initData));
-    message.target.webkitGenerateKeyRequest(
-        TestConfig.keySystem, message.initData);
+    try {
+      message.target.webkitGenerateKeyRequest(
+          TestConfig.keySystem, message.initData);
+    } catch(error) {
+      Utils.failTest(error);
+    }
   };
 
   player.onWebkitKeyAdded = function(message) {
     Utils.timeLog('onWebkitKeyAdded', message);
-    message.target.hasKeyAdded = true;
+    message.target.receivedKeyAdded = true;
   };
 
+  video.addEventListener('webkitkeyerror', function(error) {

[jrummell, 2014/05/29 21:45:05]

Curious why some events are done as play.onWebKitxxx (2 above) while the 2 new
ones are done by registering the event handler directly. Shouldn't they be done
the same way?

[shadi, 2014/05/31 00:31:37]

The disadvantage of using player.[event_name] here is that it would replace
whatever is defined in the player class (in prefixed_clearkey_player.js for
example). However, adding a video.event listener would still call the
player.event listener as well. 

For example, here 'webkitkeymessage' event listener sets receivedKeyMessage and
receivedHeartbeat flags for video in any prefixed clear player, even though
webkitAddKey gets handled in the player.onWebkitKeyMessage() function for each
of prefixed_clearkey_player and prefixed_widevine_player. 

Having said that, I agree it is confusing. I am going to stick to video event
listeners here unless there is a good need not to.

+    Utils.timeLog('onWebkitKeyError', error);
+    Utils.failTest(error, KEY_ERROR);
+  });
+
+  video.addEventListener('webkitkeymessage', function(message) {
+    Utils.timeLog('onWebkitKeyMessage', message);
+    message.target.receivedKeyMessage = true;
+    if (Utils.isHeartBeatMessage(message.message)) {
+      Utils.timeLog('onWebkitKeyMessage - heart beat', message);
+      message.target.receivedHeartbeat = true;
+      return;
+    }
+  });
+
   InitPlayer(player, video);
 }