Typecheck some of ui/webui/resources/js/ with Closure compiler.

ui/webui/resources/js/load_time_data.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 This file defines a singleton which provides access to all data
  * that is available as soon as the page's resources are loaded (before DOM
  * content has finished loading). This data includes both localized strings and
  * any data that is important to have ready from a very early stage (e.g. things
  * that must be displayed right away).
  */
 
 var loadTimeData;
 
+// Expose this type globally as a temporary work around until
+// https://github.com/google/closure-compiler/issues/544 is fixed.
+/** @constructor */
+function LoadTimeData() {}
+
 (function() {
   'use strict';
 
-  function LoadTimeData() {
-  }
-
   LoadTimeData.prototype = {
     /**
      * Sets the backing object.
      * @param {Object} value The de-serialized page data.
      */
     set data(value) {
       expect(!this.data_, 'Re-setting data.');
       this.data_ = value;
     },
 
     /**
+     * @param {string} id An ID of a value that might exist.
      * @return {boolean} True if |id| is a key in the dictionary.
      */
     valueExists: function(id) {
       return id in this.data_;
     },
 
     /**
      * Fetches a value, expecting that it exists.
      * @param {string} id The key that identifies the desired value.
      * @return {*} The corresponding value.
      */
     getValue: function(id) {
       expect(this.data_, 'No data. Did you remember to include strings.js?');
       var value = this.data_[id];
       expect(typeof value != 'undefined', 'Could not find value for ' + id);
       return value;
     },
 
     /**
      * As above, but also makes sure that the value is a string.
      * @param {string} id The key that identifies the desired string.
      * @return {string} The corresponding string value.
      */
     getString: function(id) {
       var value = this.getValue(id);
       expectIsType(id, value, 'string');
-      return value;
+      return /** @type {string} */ (value);
     },
 
     /**
      * Returns a formatted localized string where $1 to $9 are replaced by the
      * second to the tenth argument.
      * @param {string} id The ID of the string we want.
-     * @param {...string} The extra values to include in the formatted output.
+     * @param {...string} var_args The extra values to include in the formatted
+     *     output.
      * @return {string} The formatted string.
      */
-    getStringF: function(id) {
+    getStringF: function(id, var_args) {
       var value = this.getString(id);
       if (!value)
-        return;
+        return '';
 
       var varArgs = arguments;
       return value.replace(/\$[$1-9]/g, function(m) {
         return m == '$$' ? '$' : varArgs[m[1]];
       });
     },
 
     /**
      * As above, but also makes sure that the value is a boolean.
      * @param {string} id The key that identifies the desired boolean.
      * @return {boolean} The corresponding boolean value.
      */
     getBoolean: function(id) {
       var value = this.getValue(id);
       expectIsType(id, value, 'boolean');
-      return value;
+      return /** @type {boolean} */ (value);
     },
 
     /**
      * As above, but also makes sure that the value is an integer.
      * @param {string} id The key that identifies the desired number.
      * @return {number} The corresponding number value.
      */
     getInteger: function(id) {
       var value = this.getValue(id);
       expectIsType(id, value, 'number');
       expect(value == Math.floor(value), 'Number isn\'t integer: ' + value);
-      return value;
+      return /** @type {number} */ (value);
     },
 
     /**
      * Override values in loadTimeData with the values found in |replacements|.
      * @param {Object} replacements The dictionary object of keys to replace.
      */
     overrideValues: function(replacements) {
       expect(typeof replacements == 'object',
              'Replacements must be a dictionary object.');
       for (var key in replacements) {
@@ skipping 21 matching lines @@
    * @param {string} type The type we expect |value| to be.
    */
   function expectIsType(id, value, type) {
     expect(typeof value == type, '[' + value + '] (' + id +
                                  ') is not a ' + type);
   }
 
   expect(!loadTimeData, 'should only include this file once');
   loadTimeData = new LoadTimeData;
 })();