Making almost all dom_ methods private. Exceptions will be addressed in a later CL.

tools/dom/templates/html/impl/impl_Node.darttemplate

 // Copyright (c) 2012, 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 $LIBRARYNAME;
 
 /**
  * Lazy implementation of the child nodes of an element that does not request
  * the actual child nodes of an element until strictly necessary greatly
  * improving performance for the typical cases where it is not required.
@@ skipping 76 matching lines @@
     _this.insertAllBefore(iterable, item);
   }
 
   void setAll(int index, Iterable<Node> iterable) {
     throw new UnsupportedError("Cannot setAll on Node list");
   }
 
   Node removeLast() {
     final result = last;
     if (result != null) {
-      _this.$dom_removeChild(result);
+      _this._removeChild(result);
     }
     return result;
   }
 
   Node removeAt(int index) {
     var result = this[index];
     if (result != null) {
-      _this.$dom_removeChild(result);
+      _this._removeChild(result);
     }
     return result;
   }
 
   bool remove(Object object) {
     if (object is! Node) return false;
     Node node = object;
     if (!identical(_this, node.parentNode)) return false;
-    _this.$dom_removeChild(node);
+    _this._removeChild(node);
     return true;
   }
 
   void _filter(bool test(Node node), bool removeMatching) {
     // This implementation of removeWhere/retainWhere is more efficient
     // than the default in ListBase. Child nodes can be removed in constant
     // time.
     Node child = _this.firstChild;
     while (child != null) {
       Node nextChild = child.nextNode;
       if (test(child) == removeMatching) {
-        _this.$dom_removeChild(child);
+        _this._removeChild(child);
       }
       child = nextChild;
     }
   }
 
   void removeWhere(bool test(Node node)) {
     _filter(test, true);
   }
 
   void retainWhere(bool test(Node node)) {
     _filter(test, false);
   }
 
   void clear() {
     _this.text = '';
   }
 
   void operator []=(int index, Node value) {
-    _this.$dom_replaceChild(value, this[index]);
+    _this._replaceChild(value, this[index]);
   }
 
   Iterator<Node> get iterator => _this.$dom_childNodes.iterator;
 
   // From List<Node>:
 
   // TODO(jacobr): this could be implemented for child node lists.
   // The exception we throw here is misleading.
   void sort([Comparator<Node> compare]) {
     throw new UnsupportedError("Cannot sort Node list");
@@ skipping 61 matching lines @@
 
   /**
    * Removes this node from the DOM.
    */
   @DomName('Node.removeChild')
   void remove() {
     // TODO(jacobr): should we throw an exception if parent is already null?
     // TODO(vsm): Use the native remove when available.
     if (this.parentNode != null) {
       final Node parent = this.parentNode;
-      parentNode.$dom_removeChild(this);
+      parentNode._removeChild(this);
     }
   }
 
   /**
    * Replaces this node with another node.
    */
   @DomName('Node.replaceChild')
   Node replaceWith(Node otherNode) {
     try {
       final Node parent = this.parentNode;
-      parent.$dom_replaceChild(otherNode, this);
+      parent._replaceChild(otherNode, this);
     } catch (e) {
 
     };
     return this;
   }
 
   /**
    * Inserts all of the nodes into this node directly before refChild.
    *
    * See also:
@@ skipping 63 matching lines @@
   Map<String, dynamic> get bindings =>
       TemplateElement.mdvPackage(this).bindings;
 
   /** Gets the template instance that instantiated this node, if any. */
   @Experimental()
   TemplateInstance get templateInstance =>
       TemplateElement.mdvPackage(this).templateInstance;
 
 $!MEMBERS
 }