Convert constructor/channelmerger.html to use new Audit

third_party/WebKit/LayoutTests/webaudio/constructor/new-audionodeoptions.js

 // Test that constructor for the node with name |nodeName| handles the
 // various possible values for channelCount, channelCountMode, and
 // channelInterpretation.
 
 // The |should| parameter is the test function from new |Audit|.
 function testAudioNodeOptions(should, context, nodeName, expectedNodeOptions) {
   if (expectedNodeOptions === undefined)
     expectedNodeOptions = {};
   let node;
 
   // Test that we can set channelCount and that errors are thrown for
   // invalid values
   let testChannelCount = 17;
-  if (expectedNodeOptions.ChannelCount) {
-    testChannelCount = expectedNodeOptions.ChannelCount.value;
+  if (expectedNodeOptions.channelCount) {
+    testChannelCount = expectedNodeOptions.channelCount.value;
   }
   should(
       () => {
         node = new window[nodeName](
             context, Object.assign({}, expectedNodeOptions.additionalOptions, {
               channelCount: testChannelCount
             }));
       },
       'new ' + nodeName + '(c, {channelCount: ' + testChannelCount + '}}')
       .notThrow();
   should(node.channelCount, 'node.channelCount').beEqualTo(testChannelCount);
 
-  if (expectedNodeOptions.ChannelCount &&
-      expectedNodeOptions.ChannelCount.isFixed) {
+  if (expectedNodeOptions.channelCount &&
+      expectedNodeOptions.channelCount.isFixed) {
     // The channel count is fixed.  Verify that we throw an error if
     // we try to change it. Arbitrarily set the count to be one more
     // than the expected value.
-    testChannelCount = expectedNodeOptions.ChannelCount.value + 1;
+    testChannelCount = expectedNodeOptions.channelCount.value + 1;
     should(
         () => {
           node = new window[nodeName](
               context,
               Object.assign(
                   {}, expectedNodeOptions.additionalOptions,
                   {channelCount: testChannelCount}));
         },
         'new ' + nodeName + '(c, {channelCount: ' + testChannelCount + '}}')
-        .throw(expectedNodeOptions.ChannelCount.errorType || 'TypeError');
+        .throw(expectedNodeOptions.channelCount.errorType || 'TypeError');
   } else {
     // The channel count is not fixed.  Try to set the count to invalid
     // values and make sure an error is thrown.
     let errorType = 'NotSupportedError';
 
     should(() => {
       node = new window[nodeName](
           context,
           Object.assign(
               {}, expectedNodeOptions.additionalOptions, {channelCount: 0}));
     }, 'new ' + nodeName + '(c, {channelCount: 0}}', ).throw(errorType);
 
     should(() => {
       node = new window[nodeName](
           context,
           Object.assign(
               {}, expectedNodeOptions.additionalOptions, {channelCount: 99}));
     }, 'new ' + nodeName + '(c, {channelCount: 99}}').throw(errorType);
   }
 
   // Test channelCountMode
   let testChannelCountMode = 'max';
-  if (expectedNodeOptions.ChannelCountMode) {
-    testChannelCountMode = expectedNodeOptions.ChannelCountMode.value;
+  if (expectedNodeOptions.channelCountMode) {
+    testChannelCountMode = expectedNodeOptions.channelCountMode.value;
   }
   should(
       () => {
         node = new window[nodeName](
             context, Object.assign({}, expectedNodeOptions.additionalOptions, {
               channelCountMode: testChannelCountMode
             }));
       },
       'new ' + nodeName + '(c, {channelCountMode: "' + testChannelCountMode + '"}')
       .notThrow();
   should(node.channelCountMode, 'node.channelCountMode').beEqualTo(testChannelCountMode);
 
-  if (expectedNodeOptions.ChannelCountMode &&
-      expectedNodeOptions.ChannelCountMode.isFixed) {
+  if (expectedNodeOptions.channelCountMode &&
+      expectedNodeOptions.channelCountMode.isFixed) {
     // Channel count mode is fixed.  Test setting to something else throws.
     let testChannelCountModeMap = {
       'max': 'clamped-max',
       'clamped-max': 'explicit',
       'explicit': 'max'
     };
-    testChannelCountMode = testChannelCountModeMap[expectedNodeOptions.ChannelCountMode.value];
+    testChannelCountMode = testChannelCountModeMap[expectedNodeOptions.channelCountMode.value];
     should(
         () => {
           node = new window[nodeName](
               context,
               Object.assign(
                   {}, expectedNodeOptions.additionalOptions,
                   {channelCountMode: testChannelCountMode}));
         },
         'new ' + nodeName + '(c, {channelCountMode: "' + testChannelCountMode + '"}')
-        .throw(expectedNodeOptions.ChannelCountMode.errorType);
+        .throw(expectedNodeOptions.channelCountMode.errorType);
   } else {
     // Mode is not fixed. Verify that we can set the mode to all valid
     // values, and that we throw for invalid values.
 
     should(() => {
       node = new window[nodeName](
           context, Object.assign({}, expectedNodeOptions.additionalOptions, {
             channelCountMode: 'clamped-max'
           }));
     }, 'new ' + nodeName + '(c, {channelCountMode: "clamped-max"}').notThrow();
@@ skipping 105 matching lines @@
   items.forEach((item) => {
     let attr = node[item.name];
     if (attr instanceof AudioParam) {
       should(attr.value, prefix + '.' + item.name + '.value')
           .beEqualTo(item.value);
     } else {
       should(attr, prefix + '.' + item.name).beEqualTo(item.value);
     }
   });
 }