Patched in Dartium JsInterop

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.
@@ skipping 54 matching lines @@
    *
    * This method needs to walk the entire tree and either remove elements and
    * attributes which are not recognized as safe or throw an exception which
    * will mark the entire tree as unsafe.
    */
   void sanitizeTree(Node node);
 
   /**
    * A sanitizer for trees that we trust. It does no validation and allows
    * any elements. It is also more efficient, since it can pass the text
-   * directly through to the underlying APIs without creating a document 
+   * directly through to the underlying APIs without creating a document
    * fragment to be sanitized.
    */
   static const trusted = const _TrustedHtmlTreeSanitizer();
 }
 
 /**
  * A sanitizer for trees that we trust. It does no validation and allows
  * any elements.
  */
 class _TrustedHtmlTreeSanitizer implements NodeTreeSanitizer {
   const _TrustedHtmlTreeSanitizer();
 
   sanitizeTree(Node node) {}
 }
-  
+
 /**
  * Defines the policy for what types of uris are allowed for particular
  * attribute values.
  *
  * This can be used to provide custom rules such as allowing all http:// URIs
  * for image attributes but only same-origin URIs for anchor tags.
  */
 abstract class UriPolicy {
   /**
    * Constructs the default UriPolicy which is to only allow Uris to the same
@@ skipping 33 matching lines @@
 }
 
 
 class _ThrowsNodeValidator implements NodeValidator {
   final NodeValidator validator;
 
   _ThrowsNodeValidator(this.validator) {}
 
   bool allowsElement(Element element) {
     if (!validator.allowsElement(element)) {
-      throw new ArgumentError(element.tagName);
+      throw new ArgumentError(element._safeTagName);
     }
     return true;
   }
 
   bool allowsAttribute(Element element, String attributeName, String value) {
     if (!validator.allowsAttribute(element, attributeName, value)) {
-      throw new ArgumentError('${element.tagName}[$attributeName="$value"]');
+      throw new ArgumentError('${element._safeTagName}[$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 {
@@ skipping 44 matching lines @@
     try {
       // If getting/indexing attributes throws, count that as corrupt.
       attrs = element.attributes;
       isAttr = attrs['is'];
       corrupted = Element._hasCorruptedAttributes(element);
     } catch(e) {}
      var elementText = 'element unprintable';
     try {
       elementText = element.toString();
     } catch(e) {}
-    var elementTagName = 'element tag unavailable';
-    try {
-      elementTagName = element.tagName;
-    } catch(e) {}
+    var elementTagName = element._safeTagName;
     _sanitizeElement(element, parent, corrupted, elementText, elementTagName,
         attrs, isAttr);
   }
 
   /// 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) {
@@ skipping 46 matching lines @@
       case Node.COMMENT_NODE:
       case Node.DOCUMENT_FRAGMENT_NODE:
       case Node.TEXT_NODE:
       case Node.CDATA_SECTION_NODE:
         break;
       default:
         _removeNode(node, parent);
     }
   }
 }