Run clang-format on .js files in c/b/r/chromeos/chromevox

chrome/browser/resources/chromeos/chromevox/speech_rules/speech_rule.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.
 
 /**
  * @fileoverview An interface definition of a speech rule.
  *
  * A speech rule is a data structure along with supporting methods that
  * stipulates how to transform a tree structure such as XML, a browser DOM, or
  * HTML into a format (usually strings) suitable for rendering by a
@@ skipping 36 matching lines @@
 /**
  *
  * @override
  */
 cvox.SpeechRule.prototype.toString = function() {
   var cstrStrings = [];
   for (var key in this.dynamicCstr) {
     cstrStrings.push(this.dynamicCstr[key]);
   }
   return this.name + ' | ' + cstrStrings.join('.') + ' | ' +
-    this.precondition.toString() + ' ==> ' +
-    this.action.toString();
+      this.precondition.toString() + ' ==> ' + this.action.toString();
 };
 
 
 /**
  * Mapping for types of speech rule components.
  * @enum {string}
  */
 cvox.SpeechRule.Type = {
   NODE: 'NODE',
   MULTI: 'MULTI',
   TEXT: 'TEXT',
   PERSONALITY: 'PERSONALITY'
 };
 
 
 /**
  * Maps a string to a valid speech rule type.
  * @param {string} str Input string.
  * @return {cvox.SpeechRule.Type}
  */
 cvox.SpeechRule.Type.fromString = function(str) {
   switch (str) {
-    case '[n]': return cvox.SpeechRule.Type.NODE;
-    case '[m]': return cvox.SpeechRule.Type.MULTI;
-    case '[t]': return cvox.SpeechRule.Type.TEXT;
-    case '[p]': return cvox.SpeechRule.Type.PERSONALITY;
-    default: throw 'Parse error: ' + str;
+    case '[n]':
+      return cvox.SpeechRule.Type.NODE;
+    case '[m]':
+      return cvox.SpeechRule.Type.MULTI;
+    case '[t]':
+      return cvox.SpeechRule.Type.TEXT;
+    case '[p]':
+      return cvox.SpeechRule.Type.PERSONALITY;
+    default:
+      throw 'Parse error: ' + str;
   }
 };
 
 
 /**
  * Maps a speech rule type to a human-readable string.
  * @param {cvox.SpeechRule.Type} speechType
  * @return {string} Output string.
  */
 cvox.SpeechRule.Type.toString = function(speechType) {
   switch (speechType) {
-    case cvox.SpeechRule.Type.NODE: return '[n]';
-    case cvox.SpeechRule.Type.MULTI: return '[m]';
-    case cvox.SpeechRule.Type.TEXT: return '[t]';
-    case cvox.SpeechRule.Type.PERSONALITY: return '[p]';
-    default: throw 'Unknown type error: ' + speechType;
+    case cvox.SpeechRule.Type.NODE:
+      return '[n]';
+    case cvox.SpeechRule.Type.MULTI:
+      return '[m]';
+    case cvox.SpeechRule.Type.TEXT:
+      return '[t]';
+    case cvox.SpeechRule.Type.PERSONALITY:
+      return '[p]';
+    default:
+      throw 'Unknown type error: ' + speechType;
   }
 };
 
 
 /**
  * Defines a component within a speech rule.
  * @param {{type: cvox.SpeechRule.Type, content: string}} kwargs The input
  * component in JSON format.
  * @constructor
  */
@@ skipping 44 matching lines @@
     case cvox.SpeechRule.Type.NODE:
     case cvox.SpeechRule.Type.MULTI:
       var bracket = rest.indexOf(' (');
       if (bracket == -1) {
         output.content = rest.trim();
         rest = '';
         break;
       }
       output.content = rest.substring(0, bracket).trim();
       rest = rest.slice(bracket).trimLeft();
-    break;
+      break;
   }
   output = new cvox.SpeechRule.Component(output);
   if (rest) {
     output.addAttributes(rest);
   }
   return output;
 };
 
 
 /**
@@ skipping 67 matching lines @@
 };
 
 
 /**
  * Parses an input string into a speech rule class object.
  * @param {string} input The input string.
  * @return {cvox.SpeechRule.Action} The resulting object.
  */
 cvox.SpeechRule.Action.fromString = function(input) {
   var comps = cvox.SpeechRule.splitString_(input, ';')
-      .filter(function(x) {return x.match(/\S/);})
-      .map(function(x) {return x.trim();});
+                  .filter(function(x) {
+                    return x.match(/\S/);
+                  })
+                  .map(function(x) {
+                    return x.trim();
+                  });
   var newComps = [];
   for (var i = 0; i < comps.length; i++) {
     var comp = cvox.SpeechRule.Component.fromString(comps[i]);
     if (comp) {
       newComps.push(comp);
     }
   }
-return new cvox.SpeechRule.Action(newComps);
+  return new cvox.SpeechRule.Action(newComps);
 };
 
 
 /**
  * @override
  */
 cvox.SpeechRule.Action.prototype.toString = function() {
-  var comps = this.components.map(function(c) { return c.toString(); });
+  var comps = this.components.map(function(c) {
+    return c.toString();
+  });
   return comps.join('; ');
 };
 
 
 // TODO (sorge) Separatation of xpath expressions and custom functions.
 // Also test validity of xpath expressions.
 /**
  * Constructs a valid precondition for a speech rule.
  * @param {string} query A node selector function or xpath expression.
  * @param {Array<string>=} opt_constraints A list of constraint functions.
@@ skipping 34 matching lines @@
   while (str != '') {
     var sepPos = str.search(sep);
     if (sepPos == -1) {
       if ((str.match(/"/g) || []).length % 2 != 0) {
         throw new cvox.SpeechRule.OutputError(
             'Invalid string in expression: ' + str);
       }
       strList.push(prefix + str);
       prefix = '';
       str = '';
-    } else if (
-        (str.substring(0, sepPos).match(/"/g) || []).length % 2 == 0) {
+    } else if ((str.substring(0, sepPos).match(/"/g) || []).length % 2 == 0) {
       strList.push(prefix + str.substring(0, sepPos));
       prefix = '';
       str = str.substring(sepPos + 1);
     } else {
       var nextQuot = str.substring(sepPos).search('"');
       if (nextQuot == -1) {
         throw new cvox.SpeechRule.OutputError(
             'Invalid string in expression: ' + str);
       } else {
         prefix = prefix + str.substring(0, sepPos + nextQuot + 1);
         str = str.substring(sepPos + nextQuot + 1);
       }
     }
   }
   if (prefix) {
     strList.push(prefix);
   }
   return strList;
 };
 
 
 /**
  * Attributes for dynamic constraints.
  * We define one default attribute as style. Speech rule stores can add other
  * attributes later.
  * @enum {string}
  */
-cvox.SpeechRule.DynamicCstrAttrib =
-{
+cvox.SpeechRule.DynamicCstrAttrib = {
   STYLE: 'style'
 };
 
 
 /**
  * Dynamic constraints are a means to specialize rules that can be changed
  * dynamically by the user, for example by choosing different styles, etc.
  * @typedef {!Object<cvox.SpeechRule.DynamicCstrAttrib, string>}
  */
 cvox.SpeechRule.DynamicCstr;
 
 
 /**
  * Error object for signaling parsing errors.
  * @param {string} msg The error message.
  * @constructor
  * @extends {Error}
  */
 cvox.SpeechRule.OutputError = function(msg) {
   this.name = 'RuleError';
   this.message = msg || '';
 };
 goog.inherits(cvox.SpeechRule.OutputError, Error);