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

third_party/WebKit/LayoutTests/fast/mediarecorder/MediaRecorder-audio-video.html

 <!DOCTYPE html>
 <script src=../../resources/testharness.js></script>
 <script src=../../resources/testharnessreport.js></script>
 <script>
 
 // This test attempts to save and verify MediaStream data in the
 // ondataavailable event handler of MediaRecorder.
 
 var checkStreamTracks = function(stream, has_video, has_audio) {
     if (has_video) {
         assert_equals(stream.getVideoTracks().length, 1);
         assert_equals(stream.getVideoTracks()[0].readyState, 'live');
     } else {
         assert_equals(stream.getVideoTracks().length, 0);
     }
 
     if (has_audio) {
         assert_equals(stream.getAudioTracks().length, 1);
         assert_equals(stream.getAudioTracks()[0].readyState, 'live');
     } else {
         assert_equals(stream.getAudioTracks().length, 0);
     }
 };
 
 var makeAsyncTest = function(value, expected) {
     var recorder;
 
-    async_test(function() {
+    async_test(function(test) {
         const recorderOnDataAvailable = this.step_func(function(event) {
             if (event) {
                 assert_greater_than(event.data.size, 0,
                                     'Recorded data size should be > 0');
                 assert_equals(recorder.state, "recording");
             } else {
                 assert_equals(recorder.state, "inactive");
             }
 
             // TODO(mcasas): Let the test record for a while.
             // TODO(mcasas): Consider storing recorded data and playing it back.
 
             recorder.onstop = recorderOnStopExpected;
             recorder.stop();
         });
 
         const recorderOnStopExpected = this.step_func_done();
 
-        const recorderOnStopUnexpected = this.step_func(function() {
-            assert_unreached('Recording stopped.');
-        });
-
-        const recorderOnError = this.step_func(function() {
-            assert_unreached('Recording error.');
-        });
+        const recorderOnStopUnexpected = test.unreached_func('Recording stopped.');
+        const recorderOnError = test.unreached_func('Recording error.');
 
         const gotStream = this.step_func_done(function(stream) {
             checkStreamTracks(stream, value['video'], value['audio']);
 
-            try {
-                recorder = new MediaRecorder(stream);
-            } catch (e) {
-                assert_unreached('Exception while creating MediaRecorder: ' + e);
-            }
+            recorder = new MediaRecorder(stream);
 
             assert_equals(recorder.state, "inactive");
             recorder.ondataavailable = recorderOnDataAvailable;
             recorder.onstop = recorderOnStopUnexpected;
             recorder.onerror = recorderOnError;
             recorder.start();
 
             assert_equals(recorder.state, "recording");
         });
 
-        const onError = this.step_func(function() {
-            assert_unreached('Error creating MediaRecorder.');
-        });
-
-        try {
-            navigator.webkitGetUserMedia(value, gotStream, onError);
-        } catch(e) {
-            assert_unreached('Exception launching getUserMedia(): ' + e);
-        }
+        const onError = test.unreached_func('Error creating MediaStream.');
+        navigator.webkitGetUserMedia(value, gotStream, onError);
     });
 };
 
 generate_tests(makeAsyncTest,
                [["video-only",  {video: true,  audio: false}],
                 ["audio-only",  {video: false, audio: true}],
                 ["audio-video", {video: true,  audio: true}]]);
 
 </script>