Format all files under tools and utils directory.

tools/dom/src/Validators.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.dom.html;
 
-
 /**
  * Interface used to validate that only accepted elements and attributes are
  * allowed while parsing HTML strings into DOM nodes.
  *
  * In general, customization of validation behavior should be done via the
  * [NodeValidatorBuilder] class to mitigate the chances of incorrectly
  * implementing validation rules.
  */
 abstract class NodeValidator {
-
   /**
    * Construct a default NodeValidator which only accepts whitelisted HTML5
    * elements and attributes.
    *
    * If a uriPolicy is not specified then the default uriPolicy will be used.
    */
   factory NodeValidator({UriPolicy uriPolicy}) =>
       new _Html5NodeValidator(uriPolicy: uriPolicy);
 
   factory NodeValidator.throws(NodeValidator base) =>
@@ skipping 17 matching lines @@
 /**
  * Performs sanitization of a node tree after construction to ensure that it
  * does not contain any disallowed elements or attributes.
  *
  * In general custom implementations of this class should not be necessary and
  * all validation customization should be done in custom NodeValidators, but
  * custom implementations of this class can be created to perform more complex
  * tree sanitization.
  */
 abstract class NodeTreeSanitizer {
-
   /**
    * Constructs a default tree sanitizer which will remove all elements and
    * attributes which are not allowed by the provided validator.
    */
   factory NodeTreeSanitizer(NodeValidator validator) =>
       new _ValidatingTreeSanitizer(validator);
 
   /**
    * Called with the root of the tree which is to be sanitized.
    *
@@ skipping 52 matching lines @@
  * (such as https://example.com:80).
  */
 class _SameOriginUriPolicy implements UriPolicy {
   final AnchorElement _hiddenAnchor = new AnchorElement();
   final Location _loc = window.location;
 
   bool allowsUri(String uri) {
     _hiddenAnchor.href = uri;
     // IE leaves an empty hostname for same-origin URIs.
     return (_hiddenAnchor.hostname == _loc.hostname &&
-        _hiddenAnchor.port == _loc.port &&
-        _hiddenAnchor.protocol == _loc.protocol) ||
+            _hiddenAnchor.port == _loc.port &&
+            _hiddenAnchor.protocol == _loc.protocol) ||
         (_hiddenAnchor.hostname == '' &&
-        _hiddenAnchor.port == '' &&
-        (_hiddenAnchor.protocol == ':' || _hiddenAnchor.protocol == ''));
+            _hiddenAnchor.port == '' &&
+            (_hiddenAnchor.protocol == ':' || _hiddenAnchor.protocol == ''));
   }
 }
 
-
 class _ThrowsNodeValidator implements NodeValidator {
   final NodeValidator validator;
 
   _ThrowsNodeValidator(this.validator) {}
 
   bool allowsElement(Element element) {
     if (!validator.allowsElement(element)) {
       throw new ArgumentError(Element._safeTagName(element));
     }
     return true;
   }
 
   bool allowsAttribute(Element element, String attributeName, String value) {
     if (!validator.allowsAttribute(element, attributeName, value)) {
-      throw new ArgumentError('${Element._safeTagName(element)}[$attributeName="$value"]');
+      throw new ArgumentError(
+          '${Element._safeTagName(element)}[$attributeName="$value"]');
     }
   }
 }
 
-
 /**
  * Standard tree sanitizer which validates a node tree against the provided
  * validator and removes any nodes or attributes which are not allowed.
  */
 class _ValidatingTreeSanitizer implements NodeTreeSanitizer {
   NodeValidator validator;
   _ValidatingTreeSanitizer(this.validator) {}
 
   void sanitizeTree(Node node) {
     void walk(Node node, Node parent) {
@@ skipping 11 matching lines @@
           // children of node and, but we have no way of getting to the next
           // child, so start again from the last child.
           _removeNode(child, node);
           child = null;
           nextChild = node.lastChild;
         }
         if (child != null) walk(child, node);
         child = nextChild;
       }
     }
+
     walk(node, null);
   }
 
   /// Aggressively try to remove node.
   void _removeNode(Node node, Node parent) {
     // If we have the parent, it's presumably already passed more sanitization
     // or is the fragment, so ask it to remove the child. And if that fails
     // try to set the outer html.
     if (parent == null) {
       node.remove();
@@ skipping 20 matching lines @@
     var isAttr;
     try {
       // If getting/indexing attributes throws, count that as corrupt.
       attrs = element.attributes;
       isAttr = attrs['is'];
       var corruptedTest1 = Element._hasCorruptedAttributes(element);
 
       // On IE, erratically, the hasCorruptedAttributes test can return false,
       // even though it clearly is corrupted. A separate copy of the test
       // inlining just the basic check seems to help.
-      corrupted = corruptedTest1 ? true : Element._hasCorruptedAttributesAdditionalCheck(element);
-    } catch(e) {}
+      corrupted = corruptedTest1
+          ? true
+          : Element._hasCorruptedAttributesAdditionalCheck(element);
+    } catch (e) {}
     var elementText = 'element unprintable';
     try {
       elementText = element.toString();
-    } catch(e) {}
+    } catch (e) {}
     try {
       var elementTagName = Element._safeTagName(element);
       _sanitizeElement(element, parent, corrupted, elementText, elementTagName,
           attrs, isAttr);
-    } on ArgumentError { // Thrown by _ThrowsNodeValidator
+    } on ArgumentError {
+      // Thrown by _ThrowsNodeValidator
       rethrow;
-    } catch(e) {  // Unexpected exception sanitizing -> remove
+    } catch (e) {
+      // Unexpected exception sanitizing -> remove
       _removeNode(element, parent);
       window.console.warn('Removing corrupted element $elementText');
     }
   }
 
   /// Having done basic sanity checking on the element, and computed the
   /// important attributes we want to check, remove it if it's not valid
   /// or not allowed, either as a whole or particular attributes.
   void _sanitizeElement(Element element, Node parent, bool corrupted,
       String text, String tag, Map attrs, String isAttr) {
     if (false != corrupted) {
-       _removeNode(element, parent);
-      window.console.warn(
-          'Removing element due to corrupted attributes on <$text>');
-       return;
+      _removeNode(element, parent);
+      window.console
+          .warn('Removing element due to corrupted attributes on <$text>');
+      return;
     }
     if (!validator.allowsElement(element)) {
       _removeNode(element, parent);
-      window.console.warn(
-          'Removing disallowed element <$tag> from $parent');
+      window.console.warn('Removing disallowed element <$tag> from $parent');
       return;
     }
 
     if (isAttr != null) {
       if (!validator.allowsAttribute(element, 'is', isAttr)) {
         _removeNode(element, parent);
         window.console.warn('Removing disallowed type extension '
             '<$tag is="$isAttr">');
         return;
       }
     }
 
     // TODO(blois): Need to be able to get all attributes, irrespective of
     // XMLNS.
     var keys = attrs.keys.toList();
     for (var i = attrs.length - 1; i >= 0; --i) {
       var name = keys[i];
-      if (!validator.allowsAttribute(element, name.toLowerCase(),
-          attrs[name])) {
+      if (!validator.allowsAttribute(
+          element, name.toLowerCase(), attrs[name])) {
         window.console.warn('Removing disallowed attribute '
             '<$tag $name="${attrs[name]}">');
         attrs.remove(name);
       }
     }
 
     if (element is TemplateElement) {
       TemplateElement template = element;
       sanitizeTree(template.content);
-     }
+    }
   }
 
   /// Sanitize the node and its children recursively.
   void sanitizeNode(Node node, Node parent) {
     switch (node.nodeType) {
       case Node.ELEMENT_NODE:
         _sanitizeUntrustedElement(node, parent);
         break;
       case Node.COMMENT_NODE:
       case Node.DOCUMENT_FRAGMENT_NODE:
       case Node.TEXT_NODE:
       case Node.CDATA_SECTION_NODE:
         break;
       default:
         _removeNode(node, parent);
     }
   }
 }