MediaRecorder: add and wire read {video,audio}BitsPerSecond props

third_party/WebKit/LayoutTests/fast/mediarecorder/MediaRecorder-bitrates.html

 <!DOCTYPE html>
 <script src=../../resources/testharness.js></script>
 <script src=../../resources/testharnessreport.js></script>
 <script>
+
 // This test verifies that MediaRecorder can be created or not with different
-// bitrates for video, audio and for both [1].
-// TODO(mcasas): test also the expected allocated values once [2] is closed.
+// bitrates for video, audio and for both [1]. The first bunch of tests checks
+// that an off-the-limit bitrate causes an exception thrown. The following bunch
+// of tests checks a few numerical bitrate allocations, asserting that
+// individual bit rates are honored or clamped as expected, and how the overall
+// bitsPerSecond is divided into video and audio bitrates.
 // [1] https://rawgit.com/w3c/mediacapture-record/master/MediaRecorder.html#MediaRecorderOptions
-// [2] https://github.com/w3c/mediacapture-record/issues/43
 
-
-function makeAsyncTest(options, message) {
+function makeTooLargeBitrateAsyncTest(options, message) {
     return async_test(function(test) {
         const constraints = {video: true,  audio: false};
 
         const gotStream = test.step_func(function(stream) {
             assert_throws("NotSupportedError",

[philipj_slow, 2016/02/03 03:31:04]

The spec doesn't allow for NotSupportedError to be thrown for bitrate reasons.
You could change the spec, but it seems like an interop hazard to throw
exceptions based on unspecified restrictions on bitrate, better to just clamp
the bitrate to the supported range of bitrates I'd say.

[mcasas, 2016/02/03 23:50:26]

Hmm that makes sense. I propose not throwing, ASSERT()ing
here and clamping to its maximum value. Sounds good?
(I'll remove the expect-throw layouttest).

[philipj_slow, 2016/02/04 03:03:10]

Clamping sounds good, yep.

                 function() {
                     var recorder = new MediaRecorder(stream, options);
                 },
                 "recorder rejects too large bit rates");
             test.done();
         });
 
         const onError = this.step_func(function() {
             assert_unreached('Error creating MediaStream.');
         });
 
         try {
             navigator.webkitGetUserMedia(constraints, gotStream, onError);
         }
         catch (e) {
             assert_unreached('Exception launching getUserMedia(): ' + e);
         }
     }, message);
 };
 
-makeAsyncTest({audioBitsPerSecond:4294967294}, 'Audio bitrate too large');
-makeAsyncTest({videoBitsPerSecond:4294967294}, 'Video bitrate too large');
-makeAsyncTest({bitsPerSecond:4294967294}, 'Overall bitrate too large');
+makeTooLargeBitrateAsyncTest({audioBitsPerSecond:4294967294}, 'Audio bitrate too large');
+makeTooLargeBitrateAsyncTest({videoBitsPerSecond:4294967294}, 'Video bitrate too large');
+makeTooLargeBitrateAsyncTest({bitsPerSecond:4294967294}, 'Overall bitrate too large');
+
+
+function makeExpectedBitrateAsyncTest(options, message, expectedVideoBps, expectedAudioBps) {

[philipj_slow, 2016/02/03 03:31:04]

s/message/name/ or testName (in existing test too)

[philipj_slow, 2016/02/03 03:31:05]

How about making expected a dictionary too, so that it's clearer at the call
site what's what?

[mcasas, 2016/02/03 23:50:26]

Done.

[mcasas, 2016/02/03 23:50:27]

Done.

+    return async_test(function(test) {

[philipj_slow, 2016/02/03 03:31:05]

No reason to return the test, it'll run anyway.

[mcasas, 2016/02/03 23:50:26]

Done.

+        const constraints = {video: true,  audio: true};

[philipj_slow, 2016/02/03 03:31:04]

No tests for when either audio or video are not wanted, but a bitrate for them
is still requested?

+
+        const gotStream = test.step_func(function(stream) {
+            var recorder;
+            try {
+                recorder = new MediaRecorder(stream, options);
+            } catch (e) {
+                assert_unreached('Exception while creating MediaRecorder: ' + e);

[philipj_slow, 2016/02/03 03:31:05]

Don't really need this, any exception thrown will fail the test, and the
stacktrace will point to where it happened.

[mcasas, 2016/02/03 23:50:26]

Done.

+            }
+            assert_equals(recorder.videoBitsPerSecond, expectedVideoBps);
+            assert_equals(recorder.audioBitsPerSecond, expectedAudioBps);
+
+            test.done();
+        });
+
+        const onError = this.step_func(function() {

[philipj_slow, 2016/02/03 03:31:04]

can be simplified to test.unreached_func('Error creating MediaStream.')

[mcasas, 2016/02/03 23:50:26]

Nice! Done.

+            assert_unreached('Error creating MediaStream.');
+        });
+
+        try {
+            navigator.webkitGetUserMedia(constraints, gotStream, onError);
+        }
+        catch (e) {
+            assert_unreached('Exception launching getUserMedia(): ' + e);

[philipj_slow, 2016/02/03 03:31:04]

Dito, can drop try catch

[mcasas, 2016/02/03 23:50:26]

More succint, done.

Took the chance and cleaned up/homogeneise
the other LayoutTests.

+        }
+    }, message);
+};
+
+const kTooSmallBps = 1000;
+const kTooLargeBps = 1000000000;
+
+const kOkVideoBps = 500000;
+const kMinVideoBps = 100000;
+makeExpectedBitrateAsyncTest({ videoBitsPerSecond : kOkVideoBps },
+                             'Video bitrate OK',
+                             kOkVideoBps, 0);
+makeExpectedBitrateAsyncTest({ videoBitsPerSecond : kTooSmallBps },
+                             'Video bitrate clamped to minimum',
+                             kMinVideoBps, 0);
+
+const kOkAudioBps = 10000;
+const kMinAudioBps = 6000;  // https://www.opus-codec.org/
+const kMaxAudioBps = 128000;
+makeExpectedBitrateAsyncTest({ audioBitsPerSecond : kOkAudioBps },
+                             'Audio bitrate OK',
+                             0, kOkAudioBps);
+makeExpectedBitrateAsyncTest({ audioBitsPerSecond : kTooSmallBps },
+                             'Audio bitrate clamped to minimum',
+                             0, kMinAudioBps);
+makeExpectedBitrateAsyncTest({ audioBitsPerSecond : kTooLargeBps },
+                             'Audio bitrate clamped to maximum',
+                             0, kMaxAudioBps);
+makeExpectedBitrateAsyncTest({ videoBitsPerSecond : kOkVideoBps, audioBitsPerSecond : kOkAudioBps },
+                             'Video and audio bitrates OK',
+                             kOkVideoBps, kOkAudioBps);
+
+const kOkOverallBps = 120000;
+makeExpectedBitrateAsyncTest({ bitsPerSecond : kOkOverallBps },
+                             'Overall bitrate OK (divided 90/10 video/audio)',
+                             kOkOverallBps * 0.9, kOkOverallBps * 0.1);
+makeExpectedBitrateAsyncTest({ videoBitsPerSecond : kOkVideoBps, bitsPerSecond : kOkOverallBps },
+                             'Overall bitrate OK, w/ explicit video bitrate ignored',
+                              kOkOverallBps * 0.9, kOkOverallBps * 0.1);
+makeExpectedBitrateAsyncTest({ audioBitsPerSecond : kOkAudioBps, bitsPerSecond : kOkOverallBps },
+                              'Overall bitrate OK, w/ explicit audio bitrate ignored',
+                              kOkOverallBps * 0.9, kOkOverallBps * 0.1);
+
+makeExpectedBitrateAsyncTest({ bitsPerSecond : 10E6 },
+                             'Overall bitrate leads to audio clamped to its maximum',
+                             10E6 - kMaxAudioBps, kMaxAudioBps);
+makeExpectedBitrateAsyncTest({ bitsPerSecond : (kMinVideoBps - 1E3) },
+                             'Overall bitrate leads to video clamped to its minimum',
+                             kMinVideoBps, (kMinVideoBps - 1E3) * 0.1);
+makeExpectedBitrateAsyncTest({ bitsPerSecond : kTooSmallBps },
+                             'Overall bitrate leads to both audio and video clamped to min',
+                             kMinVideoBps, kMinAudioBps);
+
 
 </script>