Added more typechecking functions and unit tests for existing code.

remoting/webapp/crd/js/typecheck.js

 // Copyright 2014 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.
 
 /**
+ * @param {*} value the value to check; must be an object
+ * @return {*} the argument
+ */
+function assertDefined(value) {
+  if (value !== undefined) {
+    return value;
+  } else {
+    throw new Error('Undefined value');

[kelvinp, 2015/03/17 21:41:48]

we have a function base.debug.assert which current doesn't throw but only logs
an error message.

I think we can probably modify that function to throw and use base.debug.assert
here.

Same for the functions below.

In general, we are moving away from global functions so please add the new
functions to the base namespace.

[John Williams, 2015/03/18 17:23:01]

I tried rewriting in terms of assert, but it won't make the code any shorter
without sacrificing informative error messages.
Done.

+  }
+}
+
+/**
+ * @param {*} value the value to check; must be an object
+ * @return {!Array} the argument
+ */
+function assertArray(value) {
+  if (value instanceof Array) {

[kelvinp, 2015/03/17 21:41:48]

Nit: Array.isArray(value) as it is more robust across iframes.
http://stackoverflow.com/questions/22289727/difference-between-using-array-is...

[John Williams, 2015/03/18 17:23:01]

Done.

+    return /** @type {!Array} */ (value);
+  } else {
+    throw new Error('Invalid data type' +
+                    ' (expected: array, actual: ' + typeof value + ')');
+  }
+}
+
+/**
+ * @param {*} value the value to check; must be a boolean
+ * @return {boolean} the argument
+ */
+function assertBoolean(value) {
+  if (typeof value == 'boolean') {
+    return /** @type {boolean} */ (value);
+  } else {
+    throw new Error('Invalid data type' +
+                    ' (expected: boolean, actual: ' + typeof value + ')');
+  }
+}
+
+/**
+ * @param {*} value the value to check; must be a number
+ * @return {number} the argument
+ */
+function assertNumber(value) {
+  if (typeof value == 'number') {
+    return /** @type {number} */ (value);
+  } else {
+    throw new Error('Invalid data type' +
+                    ' (expected: number, actual: ' + typeof value + ')');
+  }
+}
+
+/**
+ * @param {*} value the value to check; must be an object
+ * @return {!Object} the argument
+ */
+function assertObject(value) {
+  if (value instanceof Object && !(value instanceof Array)) {
+    return /** @type {!Object} */ (value);
+  } else {
+    throw new Error('Invalid data type' +
+                    ' (expected: object, actual: ' + typeof value + ')');
+  }
+}
+
+/**
+ * @param {*} value the value to check; must be a string
+ * @return {string} the argument
+ */
+function assertString(value) {
+  if (typeof value == 'string') {
+    return /** @type {string} */ (value);
+  } else {
+    throw new Error('Invalid data type' +
+                    ' (expected: string, actual: ' + typeof value + ')');
+  }
+}
+
+/**
  * Get the |key| attribute in the given |dict| and verify that it is an
  * array value.

[kelvinp, 2015/03/17 21:41:48]

comment needs update. array value no longer applies.

[John Williams, 2015/03/18 17:23:01]

I just got rid of this function entirely.

  *
+ * If the attribute is not an array, then an exception will be thrown unless
+ * a default value is specified in |opt_default|.
+ *
+ * @param {Object<string,*>} dict The dictionary containing the |key|
+ * @param {string} key The key to typecheck in the |dict|.
+ * @param {*=} opt_default The value to return if the key is not a bool.
+ * @return {*} The |key| attribute value as an object.
+ */
+function getAttr(dict, key, opt_default) {
+  var value = /** @type {*} */ (dict[key]);
+  if (value === undefined) {
+    if (opt_default === undefined) {
+      throw new Error('Undefined value for ' + key);
+    } else {
+      return opt_default;
+    }
+  }
+  return value;
+}
+
+/**
+ * Get the |key| attribute in the given |dict| and verify that it is an
+ * array value.
+ *
  * If the attribute is not an array, then an exception will be thrown unless
  * a default value is specified in |opt_default|.
  *
  * @param {Object<string,*>} dict The dictionary containing the |key|
  * @param {string} key The key to typecheck in the |dict|.
  * @param {Array=} opt_default The value to return if the key is not a bool.
  * @return {Array} The |key| attribute value as an object.
  */
 function getArrayAttr(dict, key, opt_default) {
   var value = /** @type {Array} */ (dict[key]);
   if (!(value instanceof Array)) {
     if (opt_default === undefined) {
-      throw 'Invalid data type for ' + key +
-          ' (expected: array, actual: ' + typeof value + ')';
+      throw new Error('Invalid data type for ' + key +
+                      ' (expected: array, actual: ' + typeof value + ')');
     } else {
       return opt_default;
     }
   }
   return value;
 }
 
 /**
  * Get the |key| attribute in the given |dict| and verify that it is a
  * boolean value.
  *
  * If the attribute is not a boolean, then an exception will be thrown unless
  * a default value is specified in |opt_default|.
  *
  * @param {Object<string,*>} dict The dictionary containing the |key|
  * @param {string} key The key to typecheck in the |dict|.
  * @param {boolean=} opt_default The value to return if the key is not a bool.
  * @return {boolean} The |key| attribute value as a boolean.
  */
 function getBooleanAttr(dict, key, opt_default) {
   var value = /** @type {boolean} */ (dict[key]);
   if (value == 'true' || value == 'false') {
     return (value == 'true');
   }
   if (typeof value !== 'boolean') {
     if (opt_default === undefined) {
-      throw 'Invalid data type for ' + key +
-          ' (expected: boolean, actual: ' + typeof value + ')';
+      throw new Error('Invalid data type for ' + key +
+                      ' (expected: boolean, actual: ' + typeof value + ')');
     } else {
       return opt_default;
     }
   }
   return value;
 }
 
 /**
  * Get the |key| attribute in the given |dict| and verify that it is a
  * number value.
  *
  * If the attribute is not a number, then an exception will be thrown unless
  * a default value is specified in |opt_default|.
  *
  * @param {Object<string,*>} dict The dictionary containing the |key|
  * @param {string} key The key to typecheck in the |dict|.
  * @param {number=} opt_default The value to return if the key is not a number.
  * @return {number} The |key| attribute value as a number.
  */
 function getNumberAttr(dict, key, opt_default) {
   var value = /** @type {number} */(dict[key]);
   if (typeof value != 'number') {
     if (opt_default === undefined) {
-      throw 'Invalid data type for ' + key +
-          ' (expected: number, actual: ' + typeof value + ')';
+      throw new Error('Invalid data type for ' + key +
+                      ' (expected: number, actual: ' + typeof value + ')');
     } else {
       return opt_default;
     }
   }
   return value;
 }
 
 /**
  * Get the |key| attribute in the given |dict| and verify that it is an
  * object value.
  *
  * If the attribute is not an object, then an exception will be thrown unless
  * a default value is specified in |opt_default|.
  *
  * @param {Object<string,*>} dict The dictionary containing the |key|
  * @param {string} key The key to typecheck in the |dict|.
  * @param {Object=} opt_default The value to return if the key is not a bool.
  * @return {Object} The |key| attribute value as an object.
  */
 function getObjectAttr(dict, key, opt_default) {
   var value = /** @type {Object} */ (dict[key]);
-  if (typeof value != 'object') {
+  if (!(value instanceof Object) || value instanceof Array) {
     if (opt_default === undefined) {
-      throw 'Invalid data type for ' + key +
-          ' (expected: object, actual: ' + typeof value + ')';
+      throw new Error('Invalid data type for ' + key +
+                      ' (expected: object, actual: ' + typeof value + ')');
     } else {
       return opt_default;
     }
   }
   return value;
 }
 
 /**
  * Get the |key| attribute in the given |dict| and verify that it is a
  * string value.
  *
  * If the attribute is not a string, then an exception will be thrown unless
  * a default value is specified in |opt_default|.
  *
  * @param {Object<string,*>} dict The dictionary containing the |key|
  * @param {string} key The key to typecheck in the |dict|.
  * @param {string=} opt_default The value to return if the key is not a string.
  * @return {string} The |key| attribute value as a string.
  */
 function getStringAttr(dict, key, opt_default) {
   var value =  /** @type {string} */ (dict[key]);
   if (typeof value != 'string') {
     if (opt_default === undefined) {
-      throw 'Invalid data type for ' + key +
-          ' (expected: string, actual: ' + typeof value + ')';
+      throw new Error('Invalid data type for ' + key +
+                      ' (expected: string, actual: ' + typeof value + ')');
     } else {
       return opt_default;
     }
   }
   return value;
 }
 
 /**
  * Return a JSON object parsed from a string.
  *
  * If the string cannot be parsed, or does not result in an object, then an
  * exception will be thrown.
  *
  * @param {string} jsonString The JSON string to parse.
  * @return {Object} The JSON object created from the |jsonString|.
  */
 function getJsonObjectFromString(jsonString) {
   var value = base.jsonParseSafe(jsonString);
   if (typeof value != 'object') {
-    throw 'Invalid data type (expected: Object, actual: ' + typeof value + ')';
+    throw new Error('Invalid data type (expected: Object, actual: ' +
+                    typeof value + ')');
   }
   return value;
 }