[Effen] Rename SkyNodeWrapper and SkyElementWrapper to match their current actual roles, RenderNode…

sky/framework/fn.dart

 // Copyright 2015 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.
 
 library fn;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:sky' as sky;
 import 'reflect.dart' as reflect;
@@ skipping 139 matching lines @@
   StyleNode(UINode content, this.style): super(content);
 }
 
 class ParentDataNode extends ContentNode {
   final ParentData parentData;
 
   ParentDataNode(UINode content, this.parentData): super(content);
 }
 
 /*
- * SkyNodeWrappers correspond to a desired state of a RenderCSS. They are fully
- * immutable, with one exception: A UINode which is a Component which lives within
- * an SkyElementWrapper's children list, may be replaced with the "old" instance if it
- * has become stateful.
+ * RenderNodeWrappers correspond to a desired state of a RenderCSS.
+ * They are fully immutable, with one exception: A UINode which is a
+ * Component which lives within an OneChildListRenderNodeWrapper's
+ * children list, may be replaced with the "old" instance if it has
+ * become stateful.
  */
-abstract class SkyNodeWrapper extends UINode {
+abstract class RenderNodeWrapper extends UINode {
 
-  static final Map<RenderCSS, SkyNodeWrapper> _nodeMap =
-      new HashMap<RenderCSS, SkyNodeWrapper>();
+  static final Map<RenderCSS, RenderNodeWrapper> _nodeMap =
+      new HashMap<RenderCSS, RenderNodeWrapper>();
 
-  static SkyNodeWrapper _getMounted(RenderCSS node) => _nodeMap[node];
+  static RenderNodeWrapper _getMounted(RenderCSS node) => _nodeMap[node];
 
-  SkyNodeWrapper({ Object key }) : super(key: key);
+  RenderNodeWrapper({ Object key }) : super(key: key);
 
-  SkyNodeWrapper get _emptyNode;
+  RenderNodeWrapper get _emptyNode;
 
   RenderCSS _createNode();
 
   void _sync(UINode old, RenderCSSContainer host, RenderCSS insertBefore) {
     if (old == null) {
       _root = _createNode();
       assert(_root != null);
       host.add(_root, before: insertBefore);
       old = _emptyNode;
     } else {
       _root = old._root;
       assert(_root != null);
     }
 
     _nodeMap[_root] = this;
     _syncNode(old);
   }
 
-  void _syncNode(SkyNodeWrapper old);
+  void _syncNode(RenderNodeWrapper old);
 
   void _removeChild(UINode node) {
     assert(_root is RenderCSSContainer);
     _root.remove(node._root);
     super._removeChild(node);
   }
 
   void _remove() {
     assert(_root != null);
     _nodeMap.remove(_root);
@@ skipping 84 matching lines @@
        super(content);
 
   void _handleEvent(sky.Event e) {
     sky.EventListener listener = listeners[e.type];
     if (listener != null) {
       listener(e);
     }
   }
 
   static void _dispatchEvent(sky.Event e) {
-    UINode target = SkyNodeWrapper._getMounted(bridgeEventTargetToRenderNode(e.target));
+    UINode target = RenderNodeWrapper._getMounted(bridgeEventTargetToRenderNode(e.target));
 
     // TODO(rafaelw): StopPropagation?
     while (target != null) {
       if (target is EventListenerNode) {
         target._handleEvent(e);
       }
 
       target = target._parent;
     }
   }
 
   static void _ensureDocumentListener(String eventType) {
     if (_registeredEvents.add(eventType)) {
       sky.document.addEventListener(eventType, _dispatchEvent);
     }
   }
 
   void _sync(UINode old, RenderCSSContainer host, RenderCSS insertBefore) {
     for (var type in listeners.keys) {
       _ensureDocumentListener(type);
     }
 
     super._sync(old, host, insertBefore);
   }
 }
 
 final List<UINode> _emptyList = new List<UINode>();
 
-abstract class SkyElementWrapper extends SkyNodeWrapper {
+abstract class OneChildListRenderNodeWrapper extends RenderNodeWrapper {
 
   final List<UINode> children;
   final Style style;
   final String inlineStyle;
 
-  SkyElementWrapper({
+  OneChildListRenderNodeWrapper({
     Object key,
     List<UINode> children,
     this.style,
     this.inlineStyle
   }) : this.children = children == null ? _emptyList : children,
        super(key: key) {
 
     assert(!_debugHasDuplicateIds());
   }
 
@@ skipping 15 matching lines @@
 
       if (!idSet.add(child._key)) {
         throw '''If multiple non-interchangeable nodes of the same type exist as children
                 of another node, they must have unique keys.
                 Duplicate: "${child._key}"''';
       }
     }
     return false;
   }
 
-  void _syncNode(SkyNodeWrapper old) {
-    SkyElementWrapper oldSkyElementWrapper = old as SkyElementWrapper;
+  void _syncNode(RenderNodeWrapper old) {
+    OneChildListRenderNodeWrapper oldOneChildListRenderNodeWrapper = old as OneChildListRenderNodeWrapper;
 
     List<Style> styles = new List<Style>();
     if (style != null)
       styles.add(style);
     ParentData parentData = null;
     UINode parent = _parent;
-    while (parent != null && parent is! SkyNodeWrapper) {
+    while (parent != null && parent is! RenderNodeWrapper) {
       if (parent is StyleNode && parent.style != null)
         styles.add(parent.style);
       else
       if (parent is ParentDataNode && parent.parentData != null) {
         if (parentData != null)
           parentData.merge(parent.parentData); // this will throw if the types aren't the same
         else
           parentData = parent.parentData;
       }
       parent = parent._parent;
     }
     _root.updateStyles(styles);
     if (parentData != null) {
       assert(_root.parentData != null);
       _root.parentData.merge(parentData); // this will throw if the types aren't approriate
       assert(parent != null);
       assert(parent._root != null);
       parent._root.markNeedsLayout();
     }
     _root.updateInlineStyle(inlineStyle);
 
-    _syncChildren(oldSkyElementWrapper);
+    _syncChildren(oldOneChildListRenderNodeWrapper);
   }
 
-  void _syncChildren(SkyElementWrapper oldSkyElementWrapper) {
+  void _syncChildren(OneChildListRenderNodeWrapper oldOneChildListRenderNodeWrapper) {
     if (_root is! RenderCSSContainer)
       return;
 
     var startIndex = 0;
     var endIndex = children.length;
 
-    var oldChildren = oldSkyElementWrapper.children;
+    var oldChildren = oldOneChildListRenderNodeWrapper.children;
     var oldStartIndex = 0;
     var oldEndIndex = oldChildren.length;
 
     RenderCSS nextSibling = null;
     UINode currentNode = null;
     UINode oldNode = null;
 
     void sync(int atIndex) {
       children[atIndex] = _syncChild(currentNode, oldNode, _root, nextSibling);
       assert(children[atIndex] != null);
@@ skipping 47 matching lines @@
         return false; // never re-order these nodes
 
       ensureOldIdMap();
       oldNode = oldNodeIdMap[currentNode._key];
       if (oldNode == null)
         return false;
 
       oldNodeIdMap[currentNode._key] = null; // mark it reordered
       assert(_root is RenderCSSContainer);
       assert(oldNode._root is RenderCSSContainer);
-      oldSkyElementWrapper._root.remove(oldNode._root);
+      oldOneChildListRenderNodeWrapper._root.remove(oldNode._root);
       _root.add(oldNode._root, before: nextSibling);
       return true;
     }
 
     // Scan forwards, this time we may re-order;
     nextSibling = _root.firstChild;
     while (startIndex < endIndex && oldStartIndex < oldEndIndex) {
       currentNode = children[startIndex];
       oldNode = oldChildren[oldStartIndex];
 
@@ skipping 23 matching lines @@
     // Removals
     currentNode = null;
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
       _removeChild(oldNode);
       advanceOldStartIndex();
     }
   }
 }
 
-class Container extends SkyElementWrapper {
+class Container extends OneChildListRenderNodeWrapper {
 
   RenderCSSContainer _root;
   RenderCSSContainer _createNode() => new RenderCSSContainer(this);
 
   static final Container _emptyContainer = new Container();
 
-  SkyNodeWrapper get _emptyNode => _emptyContainer;
+  RenderNodeWrapper get _emptyNode => _emptyContainer;
 
   Container({
     Object key,
     List<UINode> children,
     Style style,
     String inlineStyle
   }) : super(
     key: key,
     children: children,
     style: style,
     inlineStyle: inlineStyle
   );
 }
 
-class Paragraph extends SkyElementWrapper {
+class Paragraph extends OneChildListRenderNodeWrapper {
 
   RenderCSSParagraph _root;
   RenderCSSParagraph _createNode() => new RenderCSSParagraph(this);
 
   static final Paragraph _emptyContainer = new Paragraph();
 
-  SkyNodeWrapper get _emptyNode => _emptyContainer;
+  RenderNodeWrapper get _emptyNode => _emptyContainer;
 
   Paragraph({
     Object key,
     List<UINode> children,
     Style style,
     String inlineStyle
   }) : super(
     key: key,
     children: children,
     style: style,
     inlineStyle: inlineStyle
   );
 }
 
-class FlexContainer extends SkyElementWrapper {
+class FlexContainer extends OneChildListRenderNodeWrapper {
 
   RenderCSSFlex _root;
   RenderCSSFlex _createNode() => new RenderCSSFlex(this, this.direction);
 
   static final FlexContainer _emptyContainer = new FlexContainer();
     // direction doesn't matter if it's empty
 
-  SkyNodeWrapper get _emptyNode => _emptyContainer;
+  RenderNodeWrapper get _emptyNode => _emptyContainer;
 
   final FlexDirection direction;
 
   FlexContainer({
     Object key,
     List<UINode> children,
     Style style,
     String inlineStyle,
     this.direction: FlexDirection.Row
   }) : super(
     key: key,
     children: children,
     style: style,
     inlineStyle: inlineStyle
   );
 
   void _syncNode(UINode old) {
     super._syncNode(old);
     _root.direction = direction;
   }
 }
 
-class FillStackContainer extends SkyElementWrapper {
+class FillStackContainer extends OneChildListRenderNodeWrapper {
 
   RenderCSSStack _root;
   RenderCSSStack _createNode() => new RenderCSSStack(this);
 
   static final FillStackContainer _emptyContainer = new FillStackContainer();
 
-  SkyNodeWrapper get _emptyNode => _emptyContainer;
+  RenderNodeWrapper get _emptyNode => _emptyContainer;
 
   FillStackContainer({
     Object key,
     List<UINode> children,
     Style style,
     String inlineStyle
   }) : super(
     key: key,
     children: _positionNodesToFill(children),
     style: style,
     inlineStyle: inlineStyle
   );
 
   static StackParentData _fillParentData = new StackParentData()
                                                  ..top = 0.0
                                                  ..left = 0.0
                                                  ..right = 0.0
                                                  ..bottom = 0.0;
 
   static List<UINode> _positionNodesToFill(List<UINode> input) {
     if (input == null)
       return null;
     return input.map((node) {
       return new ParentDataNode(node, _fillParentData);
     }).toList();
   }
 }
 
-class TextFragment extends SkyElementWrapper {
+class TextFragment extends OneChildListRenderNodeWrapper {
 
   RenderCSSInline _root;
   RenderCSSInline _createNode() => new RenderCSSInline(this, this.data);
 
   static final TextFragment _emptyText = new TextFragment('');
 
-  SkyNodeWrapper get _emptyNode => _emptyText;
+  RenderNodeWrapper get _emptyNode => _emptyText;
 
   final String data;
 
   TextFragment(this.data, {
     Object key,
     Style style,
     String inlineStyle
   }) : super(
     key: key,
     style: style,
     inlineStyle: inlineStyle
   );
 
   void _syncNode(UINode old) {
     super._syncNode(old);
     _root.data = data;
   }
 }
 
-class Image extends SkyElementWrapper {
+class Image extends OneChildListRenderNodeWrapper {
 
   RenderCSSImage _root;
   RenderCSSImage _createNode() => new RenderCSSImage(this, this.src, this.width, this.height);
 
   static final Image _emptyImage = new Image();
 
-  SkyNodeWrapper get _emptyNode => _emptyImage;
+  RenderNodeWrapper get _emptyNode => _emptyImage;
 
   final String src;
   final int width;
   final int height;
 
   Image({
     Object key,
     Style style,
     String inlineStyle,
     this.width,
@@ skipping 238 matching lines @@
     _sync(null, _host, _root);
   }
 }
 
 class Text extends Component {
   Text(this.data) : super(key: '*text*');
   final String data;
   bool get interchangeable => true;
   UINode build() => new Paragraph(children: [new TextFragment(data)]);
 }