DO NOT SUBMIT: what chrome/browser/resources/ could eventually look like with clang-format

chrome/browser/resources/chromeos/chromevox/speech_rules/base_rule_store.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 Base class for all speech rule stores.
  *
  * The base rule store implements some basic functionality that is common to
  * most speech rule stores.
  */
@@ skipping 53 matching lines @@
 
 
 /**
  * @override
  */
 cvox.BaseRuleStore.prototype.lookupRule = function(node, dynamic) {
   if (!node ||
       (node.nodeType != Node.ELEMENT_NODE && node.nodeType != Node.TEXT_NODE)) {
     return null;
   }
-  var matchingRules = this.speechRules_.filter(
-      goog.bind(
-          function(rule) {
-            return this.testDynamicConstraints(dynamic, rule) &&
-                this.testPrecondition_(/** @type {!Node} */ (node), rule);},
-          this));
+  var matchingRules = this.speechRules_.filter(goog.bind(function(rule) {
+    return this.testDynamicConstraints(dynamic, rule) &&
+        this.testPrecondition_(/** @type {!Node} */ (node), rule);
+  }, this));
   return (matchingRules.length > 0) ?
-    this.pickMostConstraint_(dynamic, matchingRules) : null;
+      this.pickMostConstraint_(dynamic, matchingRules) :
+      null;
 };
 
 
 /**
  * @override
  */
 cvox.BaseRuleStore.prototype.defineRule = function(
     name, dynamic, action, prec, cstr) {
   try {
     var postc = cvox.SpeechRule.Action.fromString(action);
     var cstrList = Array.prototype.slice.call(arguments, 4);
     var fullPrec = new cvox.SpeechRule.Precondition(prec, cstrList);
     var dynamicCstr = {};
     dynamicCstr[cvox.SpeechRule.DynamicCstrAttrib.STYLE] = dynamic;
     var rule = new cvox.SpeechRule(name, dynamicCstr, fullPrec, postc);
   } catch (err) {
     if (err.name == 'RuleError') {
       console.log('Rule Error ', prec, '(' + dynamic + '):', err.message);
       return null;
-    }
-    else {
+    } else {
       throw err;
     }
   }
   this.addRule(rule);
   return rule;
 };
 
 
 /**
  * @override
@@ skipping 62 matching lines @@
 
 
 /**
  * Removes duplicates of the given rule from the rule store. Thereby duplicates
  * are identified by having the same precondition and dynamic constraint.
  * @param {cvox.SpeechRule} rule The rule.
  */
 cvox.BaseRuleStore.prototype.removeDuplicates = function(rule) {
   for (var i = this.speechRules_.length - 1, oldRule;
        oldRule = this.speechRules_[i]; i--) {
-         if (oldRule != rule &&
-             cvox.BaseRuleStore.compareDynamicConstraints_(
-                 oldRule.dynamicCstr, rule.dynamicCstr) &&
-                     cvox.BaseRuleStore.comparePreconditions_(oldRule, rule)) {
-           this.speechRules_.splice(i, 1);
-         }
-       }
+    if (oldRule != rule &&
+        cvox.BaseRuleStore.compareDynamicConstraints_(
+            oldRule.dynamicCstr, rule.dynamicCstr) &&
+        cvox.BaseRuleStore.comparePreconditions_(oldRule, rule)) {
+      this.speechRules_.splice(i, 1);
+    }
+  }
 };
 
 
 // TODO (sorge) These should move into the speech rule functions.
 /**
  * Checks if we have a custom query and applies it. Otherwise returns null.
  * @param {!Node} node The initial node.
  * @param {string} funcName A function name.
  * @return {Array<Node>} The list of resulting nodes.
  */
-cvox.BaseRuleStore.prototype.applyCustomQuery = function(
-    node, funcName) {
+cvox.BaseRuleStore.prototype.applyCustomQuery = function(node, funcName) {
   var func = this.customQueries.lookup(funcName);
   return func ? func(node) : null;
 };
 
 
 /**
  * Applies either an Xpath selector or a custom query to the node
  * and returns the resulting node list.
  * @param {!Node} node The initial node.
  * @param {string} expr An Xpath expression string or a name of a custom
@@ skipping 37 matching lines @@
 };
 
 
 /**
  * Tests whether a speech rule satisfies a set of dynamic constraints.
  * @param {!cvox.SpeechRule.DynamicCstr} dynamic Dynamic constraints.
  * @param {cvox.SpeechRule} rule The rule.
  * @return {boolean} True if the preconditions apply to the node.
  * @protected
  */
-cvox.BaseRuleStore.prototype.testDynamicConstraints = function(
-    dynamic, rule) {
+cvox.BaseRuleStore.prototype.testDynamicConstraints = function(dynamic, rule) {
   // We allow a default value for each dynamic constraints attribute.
   // The idea is that when we can not find a speech rule matching the value for
   // a particular attribute in the dynamic constraintwe choose the one that has
   // the value 'default'.
   var allKeys = /** @type {Array<cvox.SpeechRule.DynamicCstrAttrib>} */ (
       Object.keys(dynamic));
-  return allKeys.every(
-      function(key) {
-        return dynamic[key] == rule.dynamicCstr[key] ||
-            rule.dynamicCstr[key] == 'default';
-      });
+  return allKeys.every(function(key) {
+    return dynamic[key] == rule.dynamicCstr[key] ||
+        rule.dynamicCstr[key] == 'default';
+  });
 };
 
 
 /**
  * Get a set of all dynamic constraint values.
  * @return {!Object<cvox.SpeechRule.DynamicCstrAttrib, Array<string>>} The
  *     object with all annotations.
  */
 cvox.BaseRuleStore.prototype.getDynamicConstraintValues = function() {
   var result = {};
@@ skipping 18 matching lines @@
  * @param {cvox.SpeechRule} rule The speech rule to match.
  * @return {number} The number of matching dynamic constraint values.
  * @private
  */
 cvox.BaseRuleStore.prototype.countMatchingDynamicConstraintValues_ = function(
     dynamic, rule) {
   var result = 0;
   for (var i = 0, key; key = this.dynamicCstrAttribs[i]; i++) {
     if (dynamic[key] == rule.dynamicCstr[key]) {
       result++;
-    } else break;
+    } else
+      break;
   }
   return result;
 };
 
 
 /**
  * Picks the result of the most constraint rule by prefering those:
  * 1) that best match the dynamic constraints.
  * 2) with the most additional constraints.
  * @param {cvox.SpeechRule.DynamicCstr} dynamic Dynamic constraints.
  * @param {!Array<cvox.SpeechRule>} rules An array of rules.
  * @return {cvox.SpeechRule} The most constraint rule.
  * @private
  */
 cvox.BaseRuleStore.prototype.pickMostConstraint_ = function(dynamic, rules) {
-  rules.sort(goog.bind(
-      function(r1, r2) {
-        var count1 = this.countMatchingDynamicConstraintValues_(dynamic, r1);
-        var count2 = this.countMatchingDynamicConstraintValues_(dynamic, r2);
-        // Rule one is a better match, don't swap.
-        if (count1 > count2) {
-          return -1;
-        }
-        // Rule two is a better match, swap.
-        if (count2 > count1) {
-          return 1;
-        }
-        // When same number of dynamic constraint attributes matches for
-        // both rules, compare length of static constraints.
-        return (r2.precondition.constraints.length -
-            r1.precondition.constraints.length);},
-      this));
+  rules.sort(goog.bind(function(r1, r2) {
+    var count1 = this.countMatchingDynamicConstraintValues_(dynamic, r1);
+    var count2 = this.countMatchingDynamicConstraintValues_(dynamic, r2);
+    // Rule one is a better match, don't swap.
+    if (count1 > count2) {
+      return -1;
+    }
+    // Rule two is a better match, swap.
+    if (count2 > count1) {
+      return 1;
+    }
+    // When same number of dynamic constraint attributes matches for
+    // both rules, compare length of static constraints.
+    return (
+        r2.precondition.constraints.length -
+        r1.precondition.constraints.length);
+  }, this));
   return rules[0];
 };
 
 
 /**
  * Test the precondition of a speech rule.
  * @param {!Node} node on which to test applicability of the rule.
  * @param {cvox.SpeechRule} rule The rule to be tested.
  * @return {boolean} True if the preconditions apply to the node.
  * @private
  */
 cvox.BaseRuleStore.prototype.testPrecondition_ = function(node, rule) {
   var prec = rule.precondition;
   return this.applyQuery(node, prec.query) === node &&
-      prec.constraints.every(
-          goog.bind(function(cstr) {
-                      return this.applyConstraint(node, cstr);},
-                    this));
+      prec.constraints.every(goog.bind(function(cstr) {
+        return this.applyConstraint(node, cstr);
+      }, this));
 };
 
 
 // TODO (sorge) Define the following methods directly on the dynamic constraint
 //     and precondition classes, respectively.
 /**
  * Compares two dynamic constraints and returns true if they are equal.
  * @param {cvox.SpeechRule.DynamicCstr} cstr1 First dynamic constraints.
  * @param {cvox.SpeechRule.DynamicCstr} cstr2 Second dynamic constraints.
  * @return {boolean} True if the dynamic constraints are equal.
  * @private
  */
-cvox.BaseRuleStore.compareDynamicConstraints_ = function(
-    cstr1, cstr2) {
+cvox.BaseRuleStore.compareDynamicConstraints_ = function(cstr1, cstr2) {
   if (Object.keys(cstr1).length != Object.keys(cstr2).length) {
     return false;
   }
   for (var key in cstr1) {
     if (!cstr2[key] || cstr1[key] !== cstr2[key]) {
       return false;
     }
   }
   return true;
 };
 
 
 /**
  * Compares two static constraints (i.e., lists of precondition constraints) and
  * returns true if they are equal.
  * @param {Array<string>} cstr1 First static constraints.
  * @param {Array<string>} cstr2 Second static constraints.
  * @return {boolean} True if the static constraints are equal.
  * @private
  */
-cvox.BaseRuleStore.compareStaticConstraints_ = function(
-    cstr1, cstr2) {
+cvox.BaseRuleStore.compareStaticConstraints_ = function(cstr1, cstr2) {
   if (cstr1.length != cstr2.length) {
     return false;
   }
   for (var i = 0, cstr; cstr = cstr1[i]; i++) {
     if (cstr2.indexOf(cstr) == -1) {
       return false;
     }
   }
   return true;
 };
 
 
 /**
  * Compares the preconditions of two speech rules.
  * @param {cvox.SpeechRule} rule1 The first speech rule.
  * @param {cvox.SpeechRule} rule2 The second speech rule.
  * @return {boolean} True if the preconditions are equal.
  * @private
  */
 cvox.BaseRuleStore.comparePreconditions_ = function(rule1, rule2) {
   var prec1 = rule1.precondition;
   var prec2 = rule2.precondition;
   if (prec1.query != prec2.query) {
     return false;
-    }
+  }
   return cvox.BaseRuleStore.compareStaticConstraints_(
       prec1.constraints, prec2.constraints);
 };