Fix some JS style nits.

chrome/test/data/webui/test_api.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview Library providing basic test framework functionality.
  */
 
 /**
  * Namespace for |Test|.
@@ skipping 117 matching lines @@
     isAsync: false,
 
     /**
      * True when the test is expected to fail for testing the test framework.
      * @type {boolean}
      */
     testShouldFail: false,
 
     /**
      * Extra libraries to add before loading this test file.
-     * @type {Array.<string>}
+     * @type {Array<string>}
      */
     extraLibraries: [],
 
     /**
      * Extra libraries to add before loading this test file.
      * This list is in the form of Closure library style object
      * names.  To support this, a closure deps.js file must
      * be specified when generating the test C++ source.
      * The specified libraries will be included with their transitive
      * dependencies according to the deps file.
-     * @type {Array.<string>}
+     * @type {Array<string>}
      */
     closureModuleDeps: [],
 
     /**
      * Whether to run the accessibility checks.
      * @type {boolean}
      */
     runAccessibilityChecks: true,
 
     /**
@@ skipping 43 matching lines @@
      * failures. If true, any accessibility issues will cause the test to fail.
      * If false, accessibility issues will cause a console.warn.
      * Off by default to begin with; as we add the ability to suppress false
      * positives, we will transition this to true.
      * @type {boolean}
      */
     accessibilityIssuesAreErrors: false,
 
     /**
      * Holds any accessibility results found during the accessibility audit.
-     * @type {Array.<Object>}
+     * @type {Array<Object>}
      */
     a11yResults_: [],
 
     /**
      * Gets the list of accessibility errors found during the accessibility
      * audit. Only for use in testing.
-     * @return {Array.<Object>}
+     * @return {Array<Object>}
      */
     getAccessibilityResults: function() {
       return this.a11yResults_;
     },
 
     /**
      * Run accessibility checks after this test completes.
      */
     enableAccessibilityChecks: function() {
       this.runAccessibilityChecks = true;
@@ skipping 45 matching lines @@
       });
 
       this.mockApis = makeMockFunctions(apiMockNames);
       registerMockApis(this.mockApis);
       return this.mockApis;
     },
 
     /**
       * Create a container of mocked standalone functions to handle
       * |functionNames|, assign it to |this.mockLocalFunctions| and return it.
-      * @param {!Array.<string>} functionNames
+      * @param {!Array<string>} functionNames
       * @return {Mock} Mock handler class.
       * @see makeMockFunctions
       */
     makeMockLocalFunctions: function(functionNames) {
       this.mockLocalFunctions = makeMockFunctions(functionNames);
       return this.mockLocalFunctions;
     },
 
     /**
      * Override this method to perform initialization during preload (such as
@@ skipping 345 matching lines @@
   }
 
   /**
    * Empty function for use in making mocks.
    * @const
    */
   function emptyFunction() {}
 
   /**
    * Make a mock from the supplied |methodNames| array.
-   * @param {Array.<string>} methodNames Array of names of methods to mock.
+   * @param {Array<string>} methodNames Array of names of methods to mock.
    * @return {Function} Constructor with prototype filled in with methods
    *     matching |methodNames|.
    */
   function makeMockClass(methodNames) {
     function MockConstructor() {}
     for(var i = 0; i < methodNames.length; i++)
       MockConstructor.prototype[methodNames[i]] = emptyFunction;
     return MockConstructor;
   }
 
@@ skipping 71 matching lines @@
    * interesting caller is one more level up the stack.
    */
   function CallHelper() {
     this.__proto__ = CallHelper.prototype;
   }
 
   CallHelper.prototype = {
     /**
      * Holds the mapping of (callerCallerString, callerName) -> count of times
      * called.
-     * @type {Object.<string, Object.<string, number>>}
+     * @type {Object<string, Object<string, number>>}
      */
     counts_: {},
 
     /**
      * This information about the caller is needed from most of the following
      * routines.
      * @param {Function} caller the caller of the assert* routine.
      * @return {{callerName: string, callercallerString: string}} stackInfo
      * @private
      */
@@ skipping 69 matching lines @@
 
   /**
    * true when testDone has been called.
    * @type {boolean}
    */
   var testIsDone = false;
 
   /**
    * Holds the errors, if any, caught by expects so that the test case can
    * fail. Cleared when results are reported from runTest() or testDone().
-   * @type {Array.<Error>}
+   * @type {Array<Error>}
    */
   var errors = [];
 
   /**
    * URL to dummy WebUI page for testing framework.
    * @type {string}
    */
   var DUMMY_URL = 'chrome://DummyURL';
 
   /**
    * Resets test state by clearing |errors| and |testIsDone| flags.
    */
   function resetTestState() {
     errors.splice(0, errors.length);
     testIsDone = false;
   }
 
   /**
    * Notifies the running browser test of the test results. Clears |errors|.
-   * @param {Array.<boolean, string>=} result When passed, this is used for the
+   * @param {Array<boolean, string>=} result When passed, this is used for the
    *     testResult message.
    */
   function testDone(result) {
     if (!testIsDone) {
       testIsDone = true;
       if (currentTestCase) {
         var ok = true;
         ok = createExpect(currentTestCase.runAccessibilityAudit.bind(
             currentTestCase)).call(null) && ok;
         ok = createExpect(currentTestCase.tearDown.bind(
@@ skipping 16 matching lines @@
       }
       errors.splice(0, errors.length);
     } else {
       console.warn('testIsDone already');
     }
   }
 
   /**
    * Converts each Error in |errors| to a suitable message, adding them to
    * |message|, and returns the message string.
-   * @param {Array.<Error>} errors Array of errors to add to |message|.
+   * @param {Array<Error>} errors Array of errors to add to |message|.
    * @param {string?} message When supplied, error messages are appended to it.
    * @return {string} |message| + messages of all |errors|.
    */
   function errorsToMessage(errors, message) {
     for (var i = 0; i < errors.length; ++i) {
       var errorMessage = errors[i].stack || errors[i].message;
       if (message)
         message += '\n';
 
       message += 'Failed: ' + currentTestFunction + '(' +
           currentTestArguments.map(JSON.stringify) +
           ')\n' + errorMessage;
     }
     return message;
   }
 
   /**
    * Returns [success, message] & clears |errors|.
    * @param {boolean} errorsOk When true, errors are ok.
-   * @return {Array.<boolean, string>}
+   * @return {Array<boolean, string>}
    */
   function testResult(errorsOk) {
     var result = [true, ''];
     if (errors.length)
       result = [!!errorsOk, errorsToMessage(errors)];
 
     return result;
   }
 
   // Asserts.
@@ skipping 152 matching lines @@
     // (warnings ok)
     // TODO(aboxhall): some kind of info logging for warnings only??
     return (a11yResults.length == 0);
   }
 
   /**
    * Concatenates the accessibility error messages for each result in
    * |a11yResults| and
    * |a11yWarnings| in to an accessibility report, appends it to the given
    * |message| and returns the resulting message string.
-   * @param {Array.<string>} a11yResults The list of accessibility results
+   * @param {Array<string>} a11yResults The list of accessibility results
    * @return {string} |message| + accessibility report.
    */
   function accessibilityAuditReport(a11yResults, message) {
     message = message ? message + '\n\n' : '\n';
     message += 'Accessibility issues found on ' + window.location.href + '\n';
     message += axs.Audit.createReport(a11yResults);
     return message;
   }
 
   /**
@@ skipping 80 matching lines @@
    * This is the guts of WebUIBrowserTest. It runs the test surrounded by an
    * expect to catch Errors. If |errors| is non-empty, it reports a failure and
    * a message by joining |errors|. Consumers can use this to use assert/expect
    * functions asynchronously, but are then responsible for reporting errors to
    * the browser themselves through testDone().
    * @param {string} testFunction The function name to report on failure.
    * @param {Function} testBody The function to call.
    * @param {Array} testArguments The arguments to call |testBody| with.
    * @param {boolean} onlyAssertFails When true, only assertions cause failing
    *     testResult.
-   * @return {Array.<boolean, string>} [test-succeeded, message-if-failed]
+   * @return {Array<boolean, string>} [test-succeeded, message-if-failed]
    * @see createExpect
    * @see testResult
    */
   function runTestFunction(testFunction, testBody, testArguments,
                            onlyAssertFails) {
     currentTestFunction = testFunction;
     currentTestArguments = testArguments;
     var ok = createExpect(testBody).apply(null, testArguments);
     return testResult(onlyAssertFails && ok);
   }
@@ skipping 387 matching lines @@
      * Always call testDone().
      */
     ALWAYS: 3,
   };
 
   /**
    * Runs all |actions|.
    * @param {boolean} isAsync When true, call testDone() on Errors.
    * @param {WhenTestDone} whenTestDone Call testDone() at the appropriate
    *     time.
-   * @param {Array.<Object>} actions Actions to run.
+   * @param {Array<Object>} actions Actions to run.
    * @constructor
    */
   function RunAllAction(isAsync, whenTestDone, actions) {
     this.isAsync_ = isAsync;
     this.whenTestDone_ = whenTestDone;
     this.actions_ = actions;
   }
 
   RunAllAction.prototype = {
     /**
@@ skipping 225 matching lines @@
   exports.TEST = TEST;
   exports.TEST_F = TEST_F;
   exports.RUNTIME_TEST_F = TEST_F;
   exports.GEN = GEN;
   exports.GEN_INCLUDE = GEN_INCLUDE;
   exports.WhenTestDone = WhenTestDone;
 
   // Import the Mock4JS helpers.
   Mock4JS.addMockSupport(exports);
 })(this);