Rename RenderNode to RenderObject.

sky/sdk/lib/framework/fn2.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 'app.dart';
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 import 'package:vector_math/vector_math.dart';
 import 'reflect.dart' as reflect;
 import 'rendering/block.dart';
 import 'rendering/box.dart';
 import 'rendering/flex.dart';
-import 'rendering/node.dart';
+import 'rendering/object.dart';
 import 'rendering/paragraph.dart';
 import 'rendering/stack.dart';
 
 // final sky.Tracing _tracing = sky.window.tracing;
 
 final bool _shouldLogRenderDuration = false;
 final bool _shouldTrace = false;
 
 enum _SyncOperation { IDENTICAL, INSERTION, STATEFUL, STATELESS, REMOVAL }
 
 /*
  * All Effen nodes derive from UINode. All nodes have a _parent, a _key and
  * can be sync'd.
  */
 abstract class UINode {
   String _key;
   UINode _parent;
   UINode get parent => _parent;
-  RenderNode root;
+  RenderObject root;
   bool _defunct = false;
 
   UINode({ Object key }) {
     _key = key == null ? "$runtimeType" : "$runtimeType-$key";
     assert(this is App || _inRenderDirtyComponents); // you should not build the UI tree ahead of time, build it only during build()
   }
 
   // Subclasses which implements Nodes that become stateful may return true
   // if the |old| node has become stateful and should be retained.
   bool _willSync(UINode old) => false;
 
   bool get interchangeable => false; // if true, then keys can be duplicated
 
   void _sync(UINode old, dynamic slot);
-  // 'slot' is the identifier that the parent RenderNodeWrapper uses to know
+  // 'slot' is the identifier that the parent RenderObjectWrapper uses to know
   // where to put this descendant
 
   void _remove() {
     _defunct = true;
     root = null;
     handleRemoved();
   }
   void handleRemoved() { }
 
   UINode findAncestor(Type targetType) {
@@ skipping 55 matching lines @@
     // new component was built that could re-use some of it. Consider
     // syncing the new VDOM against the old one.
     if (oldNode != null && node._key != oldNode._key) {
       removeChild(oldNode);
     }
 
     if (node._willSync(oldNode)) {
       _traceSync(_SyncOperation.STATEFUL, node._key);
       oldNode._sync(node, slot);
       node._defunct = true;
-      assert(oldNode.root is RenderNode);
+      assert(oldNode.root is RenderObject);
       return oldNode;
     }
 
     assert(!node._defunct);
     node._parent = this;
 
     if (oldNode == null) {
       _traceSync(_SyncOperation.INSERTION, node._key);
     } else {
       _traceSync(_SyncOperation.STATELESS, node._key);
     }
     node._sync(oldNode, slot);
     if (oldNode != null)
       oldNode._defunct = true;
 
-    assert(node.root is RenderNode);
+    assert(node.root is RenderObject);
     return node;
   }
 }
 
 abstract class ContentNode extends UINode {
   UINode content;
 
   ContentNode(UINode content) : this.content = content, super(key: content._key);
 
   void _sync(UINode old, dynamic slot) {
@@ skipping 98 matching lines @@
 
   void _handleEvent(sky.Event e) {
     sky.EventListener listener = listeners[e.type];
     if (listener != null) {
       listener(e);
     }
   }
 }
 
 /*
- * RenderNodeWrappers correspond to a desired state of a RenderNode.
+ * RenderObjectWrappers correspond to a desired state of a RenderObject.
  * They are fully immutable, with one exception: A UINode which is a
- * Component which lives within an OneChildListRenderNodeWrapper's
+ * Component which lives within an OneChildListRenderObjectWrapper's
  * children list, may be replaced with the "old" instance if it has
  * become stateful.
  */
-abstract class RenderNodeWrapper extends UINode {
+abstract class RenderObjectWrapper extends UINode {
 
-  static final Map<RenderNode, RenderNodeWrapper> _nodeMap =
-      new HashMap<RenderNode, RenderNodeWrapper>();
+  static final Map<RenderObject, RenderObjectWrapper> _nodeMap =
+      new HashMap<RenderObject, RenderObjectWrapper>();
 
-  static RenderNodeWrapper _getMounted(RenderNode node) => _nodeMap[node];
+  static RenderObjectWrapper _getMounted(RenderObject node) => _nodeMap[node];
 
-  RenderNodeWrapper({
+  RenderObjectWrapper({
     Object key
   }) : super(key: key);
 
-  RenderNode createNode();
+  RenderObject createNode();
 
-  void insert(RenderNodeWrapper child, dynamic slot);
+  void insert(RenderObjectWrapper child, dynamic slot);
 
   void _sync(UINode old, dynamic slot) {
     if (old == null) {
       root = createNode();
       assert(root != null);
-      var ancestor = findAncestor(RenderNodeWrapper);
-      if (ancestor is RenderNodeWrapper)
+      var ancestor = findAncestor(RenderObjectWrapper);
+      if (ancestor is RenderObjectWrapper)
         ancestor.insert(this, slot);
     } else {
       root = old.root;
       assert(root != null);
     }
 
     _nodeMap[root] = this;
-    syncRenderNode(old);
+    syncRenderObject(old);
   }
 
-  void syncRenderNode(RenderNodeWrapper old) {
+  void syncRenderObject(RenderObjectWrapper old) {
     ParentData parentData = null;
     UINode parent = _parent;
-    while (parent != null && parent is! RenderNodeWrapper) {
+    while (parent != null && parent is! RenderObjectWrapper) {
       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;
     }
     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();
     }
   }
 
   void removeChild(UINode node) {
     root.remove(node.root);
     super.removeChild(node);
   }
 
   void _remove() {
     assert(root != null);
     _nodeMap.remove(root);
     super._remove();
   }
 }
 
-abstract class OneChildRenderNodeWrapper extends RenderNodeWrapper {
+abstract class OneChildRenderObjectWrapper extends RenderObjectWrapper {
   final UINode child;
 
-  OneChildRenderNodeWrapper({ this.child, Object key }) : super(key: key);
+  OneChildRenderObjectWrapper({ this.child, Object key }) : super(key: key);
 
-  void insert(RenderNodeWrapper child, dynamic slot) {
+  void insert(RenderObjectWrapper child, dynamic slot) {
     assert(slot == null);
     root.child = child.root;
   }
 
-  void syncRenderNode(RenderNodeWrapper old) {
-    super.syncRenderNode(old);
-    UINode oldChild = old == null ? null : (old as OneChildRenderNodeWrapper).child;
+  void syncRenderObject(RenderObjectWrapper old) {
+    super.syncRenderObject(old);
+    UINode oldChild = old == null ? null : (old as OneChildRenderObjectWrapper).child;
     syncChild(child, oldChild, null);
   }
 
   void _remove() {
     assert(child != null);
     removeChild(child);
     super._remove();
   }
 }
 
-class Padding extends OneChildRenderNodeWrapper {
+class Padding extends OneChildRenderObjectWrapper {
   RenderPadding root;
   final EdgeDims padding;
 
   Padding({ this.padding, UINode child, Object key })
     : super(child: child, key: key);
 
   RenderPadding createNode() => new RenderPadding(padding: padding);
 
-  void syncRenderNode(Padding old) {
-    super.syncRenderNode(old);
+  void syncRenderObject(Padding old) {
+    super.syncRenderObject(old);
     root.padding = padding;
   }
 }
 
-class DecoratedBox extends OneChildRenderNodeWrapper {
+class DecoratedBox extends OneChildRenderObjectWrapper {
   RenderDecoratedBox root;
   final BoxDecoration decoration;
 
   DecoratedBox({ this.decoration, UINode child, Object key })
     : super(child: child, key: key);
 
   RenderDecoratedBox createNode() => new RenderDecoratedBox(decoration: decoration);
 
-  void syncRenderNode(DecoratedBox old) {
-    super.syncRenderNode(old);
+  void syncRenderObject(DecoratedBox old) {
+    super.syncRenderObject(old);
     root.decoration = decoration;
   }
 }
 
-class SizedBox extends OneChildRenderNodeWrapper {
+class SizedBox extends OneChildRenderObjectWrapper {
   RenderSizedBox root;
   final sky.Size desiredSize;
 
   SizedBox({ this.desiredSize, UINode child, Object key })
     : super(child: child, key: key);
 
   RenderSizedBox createNode() => new RenderSizedBox(desiredSize: desiredSize);
 
-  void syncRenderNode(SizedBox old) {
-    super.syncRenderNode(old);
+  void syncRenderObject(SizedBox old) {
+    super.syncRenderObject(old);
     root.desiredSize = desiredSize;
   }
 }
 
-class Transform extends OneChildRenderNodeWrapper {
+class Transform extends OneChildRenderObjectWrapper {
   RenderTransform root;
   final Matrix4 transform;
 
   Transform({ this.transform, UINode child, Object key })
     : super(child: child, key: key);
 
   RenderTransform createNode() => new RenderTransform(transform: transform);
 
-  void syncRenderNode(Transform old) {
-    super.syncRenderNode(old);
+  void syncRenderObject(Transform old) {
+    super.syncRenderObject(old);
     root.transform = transform;
   }
 }
 
 final List<UINode> _emptyList = new List<UINode>();
 
-abstract class OneChildListRenderNodeWrapper extends RenderNodeWrapper {
+abstract class OneChildListRenderObjectWrapper extends RenderObjectWrapper {
 
-  // In OneChildListRenderNodeWrapper subclasses, slots are RenderNode nodes
-  // to use as the "insert before" sibling in ContainerRenderNodeMixin.add() calls
+  // In OneChildListRenderObjectWrapper subclasses, slots are RenderObject nodes
+  // to use as the "insert before" sibling in ContainerRenderObjectMixin.add() calls
 
   final List<UINode> children;
 
-  OneChildListRenderNodeWrapper({
+  OneChildListRenderObjectWrapper({
     Object key,
     List<UINode> children
   }) : this.children = children == null ? _emptyList : children,
   super(
     key: key
   ) {
     assert(!_debugHasDuplicateIds());
   }
 
-  void insert(RenderNodeWrapper child, dynamic slot) {
-    assert(slot == null || slot is RenderNode);
+  void insert(RenderObjectWrapper child, dynamic slot) {
+    assert(slot == null || slot is RenderObject);
     root.add(child.root, before: slot);
   }
 
   void _remove() {
     assert(children != null);
     for (var child in children) {
       assert(child != null);
       removeChild(child);
     }
     super._remove();
   }
 
   bool _debugHasDuplicateIds() {
     var idSet = new HashSet<String>();
     for (var child in children) {
       assert(child != null);
       if (child.interchangeable)
         continue; // when these nodes are reordered, we just reassign the data
 
       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 syncRenderNode(OneChildListRenderNodeWrapper old) {
-    super.syncRenderNode(old);
+  void syncRenderObject(OneChildListRenderObjectWrapper old) {
+    super.syncRenderObject(old);
 
-    if (root is! ContainerRenderNodeMixin)
+    if (root is! ContainerRenderObjectMixin)
       return;
 
     var startIndex = 0;
     var endIndex = children.length;
 
     var oldChildren = old == null ? [] : old.children;
     var oldStartIndex = 0;
     var oldEndIndex = oldChildren.length;
 
-    RenderNode nextSibling = null;
+    RenderObject nextSibling = null;
     UINode currentNode = null;
     UINode oldNode = null;
 
     void sync(int atIndex) {
       children[atIndex] = syncChild(currentNode, oldNode, nextSibling);
       assert(children[atIndex] != null);
     }
 
     // Scan backwards from end of list while nodes can be directly synced
     // without reordering.
@@ skipping 41 matching lines @@
     bool searchForOldNode() {
       if (currentNode.interchangeable)
         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 ContainerRenderNodeMixin);
-      assert(oldNode.root is ContainerRenderNodeMixin);
+      assert(root is ContainerRenderObjectMixin);
+      assert(oldNode.root is ContainerRenderObjectMixin);
 
       old.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) {
@@ skipping 26 matching lines @@
     // Removals
     currentNode = null;
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
       removeChild(oldNode);
       advanceOldStartIndex();
     }
   }
 }
 
-class BlockContainer extends OneChildListRenderNodeWrapper {
+class BlockContainer extends OneChildListRenderObjectWrapper {
   RenderBlock root;
   RenderBlock createNode() => new RenderBlock();
 
   BlockContainer({ Object key, List<UINode> children })
     : super(key: key, children: children);
 }
 
-class StackContainer extends OneChildListRenderNodeWrapper {
+class StackContainer extends OneChildListRenderObjectWrapper {
   RenderStack root;
   RenderStack createNode() => new RenderStack();
 
   StackContainer({ Object key, List<UINode> children })
     : super(key: key, children: children);
 }
 
-class Paragraph extends RenderNodeWrapper {
+class Paragraph extends RenderObjectWrapper {
   RenderParagraph root;
   RenderParagraph createNode() => new RenderParagraph(text: text);
 
   final String text;
 
   Paragraph({ Object key, this.text }) : super(key: key);
 
-  void syncRenderNode(UINode old) {
-    super.syncRenderNode(old);
+  void syncRenderObject(UINode old) {
+    super.syncRenderObject(old);
     root.text = text;
   }
 }
 
-class FlexContainer extends OneChildListRenderNodeWrapper {
+class FlexContainer extends OneChildListRenderObjectWrapper {
   RenderFlex root;
   RenderFlex createNode() => new RenderFlex(direction: this.direction);
 
   final FlexDirection direction;
 
   FlexContainer({
     Object key,
     List<UINode> children,
     this.direction: FlexDirection.Horizontal
   }) : super(key: key, children: children);
 
-  void syncRenderNode(UINode old) {
-    super.syncRenderNode(old);
+  void syncRenderObject(UINode old) {
+    super.syncRenderObject(old);
     root.direction = direction;
   }
 }
 
 class FlexExpandingChild extends ParentDataNode {
   FlexExpandingChild(UINode content, [int flex = 1])
     : super(content, new FlexBoxParentData()..flex = flex);
 }
 
-class Image extends RenderNodeWrapper {
+class Image extends RenderObjectWrapper {
   RenderImage root;
   RenderImage createNode() => new RenderImage(this.src, this.size);
 
   final String src;
   final sky.Size size;
 
   Image({
     Object key,
     this.src,
     this.size
   }) : super(key: key);
 
-  void syncRenderNode(UINode old) {
-    super.syncRenderNode(old);
+  void syncRenderObject(UINode old) {
+    super.syncRenderObject(old);
     root.src = src;
     root.requestedSize = size;
   }
 }
 
 
 Set<Component> _mountedComponents = new HashSet<Component>();
 Set<Component> _unmountedComponents = new HashSet<Component>();
 
 void _enqueueDidMount(Component c) {
@@ skipping 106 matching lines @@
       _mountCallbacks.forEach((fn) => fn());
   }
 
   void _didUnmount() {
     if (_unmountCallbacks != null)
       _unmountCallbacks.forEach((fn) => fn());
   }
 
   // TODO(rafaelw): It seems wrong to expose DOM at all. This is presently
   // needed to get sizing info.
-  RenderNode getRoot() => root;
+  RenderObject getRoot() => root;
 
   void _remove() {
     assert(_built != null);
     assert(root != null);
     removeChild(_built);
     _built = null;
     _enqueueDidUnmount(this);
     super._remove();
   }
 
@@ skipping 119 matching lines @@
     return current;
   }
 }
 
 class _AppView extends AppView {
   _AppView() : super(null);
 
   void dispatchEvent(sky.Event event, HitTestResult result) {
     super.dispatchEvent(event, result);
 
-    UINode target = RenderNodeWrapper._getMounted(result.path.first);
+    UINode target = RenderObjectWrapper._getMounted(result.path.first);
 
     // TODO(rafaelw): StopPropagation?
     while (target != null) {
       if (target is EventListenerNode)
         target._handleEvent(event);
       target = target._parent;
     }
   }
 }
 
@@ skipping 16 matching lines @@
     assert(root.parent is RenderView);
   }
 }
 
 class Text extends Component {
   Text(this.data) : super(key: '*text*');
   final String data;
   bool get interchangeable => true;
   UINode build() => new Paragraph(text: data);
 }