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

chrome/browser/resources/chromeos/chromevox/common/traverse_math.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.
 
 goog.provide('cvox.TraverseMath');
 
 goog.require('cvox.ChromeVox');
 goog.require('cvox.DomUtil');
 goog.require('cvox.SemanticTree');
 
@@ skipping 113 matching lines @@
     // If a node has a cvoxid attribute we know that it contains a LaTeX
     // expression that we have rewritten into its corresponding MathML
     // representation, which we can speak and walk.
     if (!node.hasAttribute('cvoxid')) {
       return;
     }
     var cvoxid = node.getAttribute('cvoxid');
     node = this.allTexs_[cvoxid];
   }
   if (cvox.DomUtil.isMathJax(node)) {
-      this.activeMathmlHost = this.allMathjaxs_[node.getAttribute('id')];
+    this.activeMathmlHost = this.allMathjaxs_[node.getAttribute('id')];
   }
   this.activeMath = this.activeMathmlHost || node;
   this.activeNode = this.activeMathmlHost || node;
   if (this.activeNode && cvox.TraverseMath.setSemantic_ &&
       this.activeNode.nodeType == Node.ELEMENT_NODE) {
     this.activeNode =
-        (new cvox.SemanticTree(/** @type {!Element} */ (this.activeNode))).xml();
+        (new cvox.SemanticTree(/** @type {!Element} */ (this.activeNode)))
+            .xml();
   }
 };
 
 
 /**
  * Adds a mapping of a MathJax node to its MathML representation to the
  * dictionary of MathJax elements.
  * @param {!Node} mml The MathML node.
  * @param {string} id The MathJax node id.
  */
 cvox.TraverseMath.prototype.addMathjax = function(mml, id) {
   var spanId = cvox.DomUtil.getMathSpanId(id);
   if (spanId) {
     this.allMathjaxs_[spanId] = mml;
   } else {
     this.redoMathjaxs(mml, id);
   }
 };
 
 
 /**
  * Retries to compute MathML representations of MathJax elements, if
  * they have not been filled in during rendering.
  * @param {!Node} mml The MathML node.
  * @param {string} id The MathJax node id.
  */
 cvox.TraverseMath.prototype.redoMathjaxs = function(mml, id) {
-  var fetch = goog.bind(function() {this.addMathjax(mml, id);}, this);
+  var fetch = goog.bind(function() {
+    this.addMathjax(mml, id);
+  }, this);
   setTimeout(fetch, 500);
 };
 
 
 /**
  * Initializes the MathJax to MathML mapping.
  * We first try to get all MathJax elements that are already being rendered.
  * Secondly, we register a signal to get updated on all elements that are
  * rendered or re-rendered later.
  */
 cvox.TraverseMath.prototype.initializeMathjaxs = function() {
-  var callback =
-      goog.bind(function(mml, id) {
-                  this.addMathjax(mml, id);
-                }, this);
-  cvox.ChromeVox.mathJax.isMathjaxActive(
-      function(bool) {
-        if (bool) {
-          cvox.ChromeVox.mathJax.getAllJax(callback);
-          cvox.ChromeVox.mathJax.registerSignal(callback, 'New Math');
-        }
-      });
+  var callback = goog.bind(function(mml, id) {
+    this.addMathjax(mml, id);
+  }, this);
+  cvox.ChromeVox.mathJax.isMathjaxActive(function(bool) {
+    if (bool) {
+      cvox.ChromeVox.mathJax.getAllJax(callback);
+      cvox.ChromeVox.mathJax.registerSignal(callback, 'New Math');
+    }
+  });
 };
 
 
 /**
  * Initializes the elements in the page that we identify as potentially
  * containing tex or asciimath alt text.
  */
 cvox.TraverseMath.prototype.initializeAltMaths = function() {
   if (!document.querySelector(
-      cvox.DomUtil.altMathQuerySelector('tex') + ', ' +
+          cvox.DomUtil.altMathQuerySelector('tex') + ', ' +
           cvox.DomUtil.altMathQuerySelector('asciimath'))) {
     return;
   }
-  var callback = goog.bind(
-      function(mml, id) {
-        this.allTexs_[id] = mml;
-      }, this);
+  var callback = goog.bind(function(mml, id) {
+    this.allTexs_[id] = mml;
+  }, this);
   // Inject a minimalistic version of MathJax into the page.
   cvox.ChromeVox.mathJax.injectScripts();
   // Once MathJax is injected we harvest all Latex and AsciiMath in alt
   // attributes and translate them to MathML expression.
-  cvox.ChromeVox.mathJax.isMathjaxActive(
-      function(active) {
-        if (active) {
-          cvox.ChromeVox.mathJax.configMediaWiki();
-          cvox.ChromeVox.mathJax.getAllTexs(callback);
-          cvox.ChromeVox.mathJax.getAllAsciiMaths(callback);
-        }
-      });
+  cvox.ChromeVox.mathJax.isMathjaxActive(function(active) {
+    if (active) {
+      cvox.ChromeVox.mathJax.configMediaWiki();
+      cvox.ChromeVox.mathJax.getAllTexs(callback);
+      cvox.ChromeVox.mathJax.getAllAsciiMaths(callback);
+    }
+  });
 };
 
 
 /**
  * Moves to the next leaf node in the current Math expression if it exists.
  * @param {boolean} reverse True if reversed. False by default.
  * @param {function(!Node):boolean} pred Predicate deciding what a leaf is.
  * @return {Node} The next node.
  */
 cvox.TraverseMath.prototype.nextLeaf = function(reverse, pred) {
   if (this.activeNode && this.activeMath) {
     var next = pred(this.activeNode) ?
-      cvox.DomUtil.directedFindNextNode(
-          this.activeNode, this.activeMath, reverse, pred) :
-      cvox.DomUtil.directedFindFirstNode(this.activeNode, reverse, pred);
+        cvox.DomUtil.directedFindNextNode(
+            this.activeNode, this.activeMath, reverse, pred) :
+        cvox.DomUtil.directedFindFirstNode(this.activeNode, reverse, pred);
     if (next) {
       this.activeNode = next;
     }
   }
   return this.activeNode;
 };
 
 
 // TODO (sorge) Refactor this logic into single walkers.
 /**
  * Returns a string with the content of the active node.
  * @return {string} The active content.
  */
 cvox.TraverseMath.prototype.activeContent = function() {
   return this.activeNode.textContent;
 };
 
 
 /**
  * Moves to the next subtree from a given node in a depth first fashion.
  * @param {boolean} reverse True if reversed. False by default.
  * @param {function(!Node):boolean} pred Predicate deciding what a subtree is.
  * @return {Node} The next subtree.
  */
 cvox.TraverseMath.prototype.nextSubtree = function(reverse, pred) {
   if (!this.activeNode || !this.activeMath) {
     return null;
   }
   if (!reverse) {
-    var child = cvox.DomUtil.directedFindFirstNode(
-        this.activeNode, reverse, pred);
+    var child =
+        cvox.DomUtil.directedFindFirstNode(this.activeNode, reverse, pred);
     if (child) {
       this.activeNode = child;
     } else {
       var next = cvox.DomUtil.directedFindNextNode(
           this.activeNode, this.activeMath, reverse, pred);
       if (next) {
-          this.activeNode = next;
+        this.activeNode = next;
       }
     }
   } else {
     if (this.activeNode == this.activeMath) {
-      var child = cvox.DomUtil.directedFindDeepestNode(
-          this.activeNode, reverse, pred);
+      var child =
+          cvox.DomUtil.directedFindDeepestNode(this.activeNode, reverse, pred);
       if (child != this.activeNode) {
         this.activeNode = child;
         return this.activeNode;
       }
     }
     var prev = cvox.DomUtil.directedFindNextNode(
-      this.activeNode, this.activeMath, reverse, pred, true, true);
+        this.activeNode, this.activeMath, reverse, pred, true, true);
     if (prev) {
       this.activeNode = prev;
     }
   }
   return this.activeNode;
 };
 
 
 /**
  * left or right in the math expression.
  * Navigation is bounded by the presence of a sibling.
  * @param {boolean} r True to move left; false to move right.
  * @return {Node} The result.
  */
 cvox.TraverseMath.prototype.nextSibling = function(r) {
   if (!this.activeNode || !this.activeMath) {
     return null;
   }
   var node = this.activeNode;
-      node = r ? node.previousSibling : node.nextSibling;
+  node = r ? node.previousSibling : node.nextSibling;
   if (!node) {
     return null;
   }
   this.activeNode = node;
   return this.activeNode;
 };
 
 
 /**
  * Moves up or down the math expression.
@@ skipping 18 matching lines @@
 };
 
 
 /**
  * Adds a list of domains and styles to the existing one.
  * @param {Array<string>} domains List of domain names.
  * @param {Array<string>} styles List of style names.
  */
 cvox.TraverseMath.prototype.addDomainsAndStyles = function(domains, styles) {
   this.allDomains.push.apply(
-      this.allDomains,
-      domains.filter(
-          goog.bind(function(x) {return this.allDomains.indexOf(x) < 0;},
-                    this)));
+      this.allDomains, domains.filter(goog.bind(function(x) {
+        return this.allDomains.indexOf(x) < 0;
+      }, this)));
   this.allStyles.push.apply(
-      this.allStyles,
-      styles.filter(
-          goog.bind(function(x) {return this.allStyles.indexOf(x) < 0;},
-                    this)));
+      this.allStyles, styles.filter(goog.bind(function(x) {
+        return this.allStyles.indexOf(x) < 0;
+      }, this)));
 };
 
 
 /**
  * Gets a list of domains and styles from the symbol and function mappings.
  * Depending on the platform they either live in the background page or
  * in the android math map.
  */
 cvox.TraverseMath.prototype.initDomainsAndStyles = function() {
   if (cvox.ChromeVox.host['mathMap']) {
     this.addDomainsAndStyles(
         cvox.ChromeVox.host['mathMap'].allDomains,
         cvox.ChromeVox.host['mathMap'].allStyles);
-    } else {
-      cvox.ChromeVox.host.sendToBackgroundPage(
-          {'target': 'Math',
-           'action': 'getDomains'});
-    }
+  } else {
+    cvox.ChromeVox.host.sendToBackgroundPage(
+        {'target': 'Math', 'action': 'getDomains'});
+  }
 };
 
 
 /**
  * Sets the domain for the TraverseMath object to the next one in the list
  * restarting from the first, if necessary.
  * @return {string} The name of the newly set domain.
  */
 cvox.TraverseMath.prototype.cycleDomain = function() {
   this.initDomainsAndStyles();
@@ skipping 55 matching lines @@
  * @return {Node} The active node, if it exists.
  */
 cvox.TraverseMath.prototype.getAttachedActiveNode = function() {
   var node = this.activeNode;
   if (!node || node.nodeType != Node.ELEMENT_NODE) {
     return null;
   }
   var id = node.getAttribute('spanID');
   return document.getElementById(id);
 };