EME: Update tests so 'audioCapabilities' always provided

third_party/WebKit/LayoutTests/media/encrypted-media/encrypted-media-utils.js

 var consoleDiv = null;
 
 function consoleWrite(text)
 {
     if (!consoleDiv && document.body) {
         consoleDiv = document.createElement('div');
         document.body.appendChild(consoleDiv);
     }
     var span = document.createElement('span');
     span.appendChild(document.createTextNode(text));
     span.appendChild(document.createElement('br'));
     consoleDiv.appendChild(span);
 }
 
 // Returns a promise that is fulfilled with true if |initDataType| is supported,
 // or false if not.
 function isInitDataTypeSupported(initDataType)
 {
     return navigator.requestMediaKeySystemAccess(
-                         "org.w3.clearkey", [{ initDataTypes : [initDataType] }])
-        .then(function() { return(true); }, function() { return(false); });
-}
-
-// Returns a promise that is fulfilled with an initDataType that is supported,
-// rejected if none are supported.
-function getSupportedInitDataType()
-{
-    var configuration = [{ initDataTypes : [ 'webm', 'cenc', 'keyids' ] }];
-    return navigator.requestMediaKeySystemAccess('org.w3.clearkey', configuration)
-        .then(function(access) {
-            var initDataTypes = access.getConfiguration().initDataTypes;
-            assert_greater_than(initDataTypes.length, 0);
-            return Promise.resolve(initDataTypes[0]);
-        }, function(error) {
-            return Promise.reject('No supported initDataType.');
-        });
+                        "org.w3.clearkey", getSimpleConfigurationForInitDataType(initDataType))
+        .then(function() { return true; }, function() { return false; });
 }
 
 function getInitData(initDataType)
 {
   if (initDataType == 'webm') {
       return new Uint8Array([
           0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
           0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
       ]);
   }
@@ skipping 17 matching lines @@
       var keyId = new Uint8Array([
           0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
           0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
       ]);
       return stringToUint8Array(createKeyIDs(keyId));
   }
 
   throw 'initDataType ' + initDataType + ' not supported.';
 }
 
+// Returns an array of audioCapabilities that includes entries for a set of
+// codecs that should cover all user agents.
+function getPossibleAudioCapabilities()
+{
+    return [
+        { contentType: 'audio/mp4; codecs="mp4a.40.2"' },
+        { contentType: 'audio/webm; codecs="opus"' },
+    ];
+}
+
+// Returns a trivial MediaKeySystemConfiguration that should be accepted,
+// possibly as a subset of the specified capabilities, by all user agents.
+function getSimpleConfiguration()
+{
+    return [ {
+        initDataTypes : [ 'webm', 'cenc', 'keyids' ],
+        audioCapabilities: getPossibleAudioCapabilities()
+    } ];
+}
+
+// Returns a MediaKeySystemConfiguration for |initDataType| that should be
+// accepted, possibly as a subset of the specified capabilities, by all
+// user agents.
+function getSimpleConfigurationForInitDataType(initDataType)
+{
+    return [ {
+        initDataTypes: [ initDataType ],
+        audioCapabilities: getPossibleAudioCapabilities()
+    } ];
+}
+
+// Returns a MediaKeySystemConfiguration for |mediaFile| that specifies
+// both audio and video capabilities for the specified file..
+function getConfigurationForFile(mediaFile)
+{
+    if (mediaFile.toLowerCase().endsWith('webm')) {

[ddorwin, 2016/07/20 19:34:20]

It would be slightly better if this was .webm.

+        return [ {
+            initDataTypes: [ 'webm' ],
+            audioCapabilities: [ { contentType: 'audio/webm; codecs="opus"' } ],
+            videoCapabilities: [ { contentType: 'video/webm; codecs="vp8"' } ]
+        } ];
+    }
+
+    // NOTE: Supporting other mediaFormats is not currently implemented as
+    // Chromium only tests with WebM files.
+    throw 'mediaFile ' + mediaFile + ' not supported.';
+}
+
 function waitForEventAndRunStep(eventName, element, func, stepTest)
 {
     var eventCallback = function(event) {
         if (func)
             func(event);
     }
     if (stepTest)
         eventCallback = stepTest.step_func(eventCallback);
 
     element.addEventListener(eventName, eventCallback, true);
@@ skipping 177 matching lines @@
 // Create a MediaKeys object for Clear Key with 1 session. KeyId and key
 // required for the video are already known and provided. Returns a promise
 // that resolves to the MediaKeys object created.
 function createMediaKeys(keyId, key)
 {
     var mediaKeys;
     var mediaKeySession;
     var request = stringToUint8Array(createKeyIDs(keyId));
     var jwkSet = stringToUint8Array(createJWKSet(createJWK(keyId, key)));
 
-    return navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]).then(function(access) {
+    return navigator.requestMediaKeySystemAccess('org.w3.clearkey', getSimpleConfigurationForInitDataType('keyids')).then(function(access) {
         return access.createMediaKeys();
     }).then(function(result) {
         mediaKeys = result;
         mediaKeySession = mediaKeys.createSession();
         return mediaKeySession.generateRequest('keyids', request);
     }).then(function() {
         return mediaKeySession.update(jwkSet);
     }).then(function() {
         return Promise.resolve(mediaKeys);
     });
 }
 
 // Play the specified |content| on |video|. Returns a promise that is resolved
 // after the video plays for |duration| seconds.
 function playVideoAndWaitForTimeupdate(video, content, duration)
 {
     video.src = content;
     video.play();
     return new Promise(function(resolve) {
         video.addEventListener('timeupdate', function listener(event) {
             if (event.target.currentTime < duration)
                 return;
             video.removeEventListener('timeupdate', listener);
             resolve('success');
         });
     });
 }