pkg/third_party/html5lib: lots of cleanup

pkg/third_party/html5lib/lib/src/treebuilder.dart

 /** Internals to the tree builders. */
 library treebuilder;
 
 import 'dart:collection';
 import 'package:html5lib/dom.dart';
 import 'package:source_maps/span.dart' show FileSpan;
 import 'constants.dart';
 import 'list_proxy.dart';
 import 'token.dart';
 import 'utils.dart';
 
 // The scope markers are inserted when entering object elements,
 // marquees, table cells, and table captions, and are used to prevent formatting
 // from "leaking" into tables, object elements, and marquees.
-final Node Marker = null;
+const Node MARKER = null;
 
 // TODO(jmesserly): this should extend ListBase<Node>, but my simple attempt
 // didn't work.
 class ActiveFormattingElements extends ListProxy<Node> {
   ActiveFormattingElements() : super();
 
   // Override the "add" method.
   // TODO(jmesserly): I'd rather not override this; can we do this in the
   // calling code instead?
   void add(Node node) {
     int equalCount = 0;
-    if (node != Marker) {
+    if (node != MARKER) {
       for (Node element in reversed) {
-        if (element == Marker) {
+        if (element == MARKER) {
           break;
         }
         if (_nodesEqual(element, node)) {
           equalCount += 1;
         }
         if (equalCount == 3) {
           remove(element);
           break;
         }
       }
@@ skipping 62 matching lines @@
     insertFromTable = false;
 
     document = new Document();
   }
 
   bool elementInScope(target, {String variant}) {
     //If we pass a node in we match that. if we pass a string
     //match any node with that name
     bool exactNode = target is Node && target.nameTuple != null;
 
-    List listElements1 = scopingElements;
+    List listElements1 = SCOPING_ELEMENTS;
     List listElements2 = const [];
     bool invert = false;
     if (variant != null) {
       switch (variant) {
         case "button":
           listElements2 = const [const Pair(Namespaces.html, "button")];
           break;
         case "list":
           listElements2 = const [const Pair(Namespaces.html, "ol"),
                                  const Pair(Namespaces.html, "ul")];
@@ skipping 31 matching lines @@
     // code. It should still do the same though.
 
     // Step 1: stop the algorithm when there's nothing to do.
     if (activeFormattingElements.length == 0) {
       return;
     }
 
     // Step 2 and step 3: we start with the last element. So i is -1.
     int i = activeFormattingElements.length - 1;
     var entry = activeFormattingElements[i];
-    if (entry == Marker || openElements.contains(entry)) {
+    if (entry == MARKER || openElements.contains(entry)) {
       return;
     }
 
     // Step 6
-    while (entry != Marker && !openElements.contains(entry)) {
+    while (entry != MARKER && !openElements.contains(entry)) {
       if (i == 0) {
         //This will be reset to 0 below
         i = -1;
         break;
       }
       i -= 1;
       // Step 5: let entry be one earlier in the list.
       entry = activeFormattingElements[i];
     }
 
@@ skipping 19 matching lines @@
 
       // Step 11
       if (element == activeFormattingElements.last) {
         break;
       }
     }
   }
 
   void clearActiveFormattingElements() {
     var entry = activeFormattingElements.removeLast();
-    while (activeFormattingElements.length > 0 && entry != Marker) {
+    while (activeFormattingElements.length > 0 && entry != MARKER) {
       entry = activeFormattingElements.removeLast();
     }
   }
 
   /**
    * Check if an element exists between the end of the active
    * formatting elements and the last marker. If it does, return it, else
    * return null.
    */
   Node elementInActiveFormattingElements(String name) {
     for (Node item in activeFormattingElements.reversed) {
       // Check for Marker first because if it's a Marker it doesn't have a
       // name attribute.
-      if (item == Marker) {
+      if (item == MARKER) {
         break;
       } else if (item.tagName == name) {
         return item;
       }
     }
     return null;
   }
 
   void insertRoot(Token token) {
     var element = createElement(token);
@@ skipping 38 matching lines @@
         ..attributes = token.data
         ..sourceSpan = token.span;
     openElements.last.nodes.add(element);
     openElements.add(element);
     return element;
   }
 
   Element insertElementTable(token) {
     /** Create an element and insert it into the tree */
     var element = createElement(token);
-    if (!tableInsertModeElements.contains(openElements.last.tagName)) {
+    if (!TABLE_INSERT_MODE_ELEMENTS.contains(openElements.last.tagName)) {
       return insertElementNormal(token);
     } else {
       // We should be in the InTable mode. This means we want to do
       // special magic element rearranging
       var nodePos = getTableMisnestedNodePosition();
       if (nodePos[1] == null) {
         // TODO(jmesserly): I don't think this is reachable. If insertFromTable
         // is true, there will be a <table> element open, and it always has a
         // parent pointer.
         nodePos[0].nodes.add(element);
       } else {
         nodePos[0].insertBefore(element, nodePos[1]);
       }
       openElements.add(element);
     }
     return element;
   }
 
   /** Insert text data. */
   void insertText(String data, FileSpan span) {
     var parent = openElements.last;
 
     if (!insertFromTable || insertFromTable &&
-        !tableInsertModeElements.contains(openElements.last.tagName)) {
+        !TABLE_INSERT_MODE_ELEMENTS.contains(openElements.last.tagName)) {
       _insertText(parent, data, span);
     } else {
       // We should be in the InTable mode. This means we want to do
       // special magic element rearranging
       var nodePos = getTableMisnestedNodePosition();
       _insertText(nodePos[0], data, span, nodePos[1]);
     }
   }
 
   /**
@@ skipping 74 matching lines @@
   Document getDocument() => document;
 
   /** Return the final fragment. */
   DocumentFragment getFragment() {
     //XXX assert innerHTML
     var fragment = new DocumentFragment();
     openElements[0].reparentChildren(fragment);
     return fragment;
   }
 }