Run clang-format on ui/webui/resources

ui/webui/resources/js/i18n_template_no_process.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.
 
 /** @typedef {Document|DocumentFragment|Element} */
 var ProcessingRoot;
 
 /**
  * @fileoverview This is a simple template engine inspired by JsTemplates
  * optimized for i18n.
@@ skipping 95 matching lines @@
             targetObject[path] = value;
             // In case we set innerHTML (ignoring others) we need to recursively
             // check the content.
             if (path == 'innerHTML') {
               for (var i = 0; i < element.children.length; ++i) {
                 processWithoutCycles(element.children[i], data, visited, false);
               }
             }
           }
         } else {
-          element.setAttribute(propName, /** @type {string} */(value));
+          element.setAttribute(propName, /** @type {string} */ (value));
         }
       });
     }
   };
 
   var prefixes = [''];
 
   // Only look through shadow DOM when it's supported. As of April 2015, iOS
   // Chrome doesn't support shadow DOM.
   if (Element.prototype.createShadowRoot)
     prefixes.push('* /deep/ ');
 
   var attributeNames = Object.keys(handlers);
-  var selector = prefixes.map(function(prefix) {
-    return prefix + '[' + attributeNames.join('], ' + prefix + '[') + ']';
-  }).join(', ');
+  var selector = prefixes
+                     .map(function(prefix) {
+                       return prefix + '[' +
+                           attributeNames.join('], ' + prefix + '[') + ']';
+                     })
+                     .join(', ');
 
   /**
    * Processes a DOM tree using a |data| source to populate template values.
    * @param {!ProcessingRoot} root The root of the DOM tree to process.
    * @param {!LoadTimeData} data The data to draw from.
    */
   function process(root, data) {
     processWithoutCycles(root, data, new Set(), true);
   }
 
   /**
    * Internal process() method that stops cycles while processing.
    * @param {!ProcessingRoot} root
    * @param {!LoadTimeData} data
    * @param {!Set<ProcessingRoot>} visited Already visited roots.
    * @param {boolean} mark Whether nodes should be marked processed.
    */
   function processWithoutCycles(root, data, visited, mark) {
     if (visited.has(root)) {
       // Found a cycle. Stop it.
       return;
     }
 
     // Mark the node as visited before recursing.
     visited.add(root);
 
     var importLinks = root.querySelectorAll('link[rel=import]');
     for (var i = 0; i < importLinks.length; ++i) {
-      var importLink = /** @type {!HTMLLinkElement} */(importLinks[i]);
+      var importLink = /** @type {!HTMLLinkElement} */ (importLinks[i]);
       if (!importLink.import) {
         // Happens when a <link rel=import> is inside a <template>.
         // TODO(dbeam): should we log an error if we detect that here?
         continue;
       }
       processWithoutCycles(importLink.import, data, visited, mark);
     }
 
     var templates = root.querySelectorAll('template');
     for (var i = 0; i < templates.length; ++i) {
-      var template = /** @type {HTMLTemplateElement} */(templates[i]);
+      var template = /** @type {HTMLTemplateElement} */ (templates[i]);
       if (!template.content)
         continue;
       processWithoutCycles(template.content, data, visited, mark);
     }
 
     var isElement = root instanceof Element;
     if (isElement && root.webkitMatchesSelector(selector))
-      processElement(/** @type {!Element} */(root), data, visited);
+      processElement(/** @type {!Element} */ (root), data, visited);
 
     var elements = root.querySelectorAll(selector);
     for (var i = 0; i < elements.length; ++i) {
       processElement(elements[i], data, visited);
     }
 
     if (mark) {
       var processed = isElement ? [root] : root.children;
       if (processed) {
         for (var i = 0; i < processed.length; ++i) {
@@ skipping 11 matching lines @@
    */
   function processElement(element, data, visited) {
     for (var i = 0; i < attributeNames.length; i++) {
       var name = attributeNames[i];
       var attribute = element.getAttribute(name);
       if (attribute != null)
         handlers[name](element, attribute, data, visited);
     }
   }
 
-  return {
-    process: process
-  };
+  return {process: process};
 }());