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] }])
+                         "org.w3.clearkey", simpleConfigurationForInitDataType(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()

[ddorwin, 2016/06/24 03:05:23]

We may not actually need this anymore if we follow my suggestion. :)

[jrummell, 2016/06/28 23:04:26]

Done.

 {
-    var configuration = [{ initDataTypes : [ 'webm', 'cenc', 'keyids' ] }];
+    var configuration = [ {
+        initDataTypes : [ 'webm', 'cenc', 'keyids' ],
+        audioCapabilities: [ { contentType: 'audio/webm; codecs="vorbis"' } ]

[ddorwin, 2016/06/24 03:05:23]

We should add a note that one would need to include an entry for codecs that
cover all user agents.

Alternatively, we could add webm-opus, and mp4-aac (LC)? here and be done with
it. To allow reuse, define a helper that returns the array so we can use it
below too.

[jrummell, 2016/06/28 23:04:26]

Done.

+    } ];
     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.');
         });
 }
 
@@ skipping 25 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 a trivial MediaKeySystemConfiguration. Since Chromium only
+// supports WebM by default, use an audio codec so that at least one
+// capability is specified.
+// NOTE: Supporting user agents that don't support WebM and/or Vorbis would
+// require passing in an audio content type.
+function simpleConfiguration()
+{
+    return [ {
+        audioCapabilities: [ { contentType: 'audio/webm; codecs="vorbis"' } ]

[ddorwin, 2016/06/24 03:05:23]

Actually, that might work here too. We just need one to be supported! No need to
pass them in later.

[jrummell, 2016/06/28 23:04:26]

Done.

+    } ];
+}
+
+// Returns a MediaKeySystemConfiguration for |initDataType|. Since Chromium
+// only supports WebM by default, use an audio codec so that at least one
+// capability is specified.
+// NOTE: Supporting user agents that don't support WebM and/or Vorbis would
+// require passing in an audio content type.
+function simpleConfigurationForInitDataType(initDataType)
+{
+    return [ {
+        initDataTypes: [ initDataType ],
+        audioCapabilities: [ { contentType: 'audio/webm; codecs="vorbis"' } ]
+    } ];
+}
+
+// Returns a MediaKeySystemConfiguration for |initDataType| that specifies
+// both audio and video capabilities.
+function avConfiguration(initDataType)

[ddorwin, 2016/06/24 03:05:23]

Passing the IDT isn't strictly correct. Also, FTR, we don't need a type if we're
just trying to pick one. You could just return the configuration and note that
other types would need to be added.

[jrummell, 2016/06/28 23:04:26]

Renamed the parameter since it is really the media format.

+{
+    if (initDataType == 'webm') {
+        return [ {

[ddorwin, 2016/06/24 21:24:56]

(Especially for cases where more than one configurations could be returned) we
should consider adding the `label` member with a description. It doesn't hurt
and it might help debugging.

[jrummell, 2016/06/28 23:04:26]

Acknowledged. Doesn't look like we need to handle multiple configurations right
now.

+            initDataTypes: [ 'webm' ],
+            audioCapabilities: [ { contentType: 'audio/webm; codecs="vorbis"' } ],
+            videoCapabilities: [ { contentType: 'video/webm; codecs="vp8"' } ]
+        } ];
+    }
+
+    // NOTE: Supporting other initDataTypes not currently implemented as
+    // Chromium only tests with WebM files.
+    throw 'initDataType ' + initDataType + ' 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', simpleConfigurationForInitDataType('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');
         });
     });
 }