[Effen] Expose various private members so that fn classes can exist outside fn.dart

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 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 import 'reflect.dart' as reflect;
 import 'layout2.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;
-  RenderCSS _root;
+  RenderCSS 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
   // where to put this descendant
 
   void _remove() {
     _defunct = true;
-    _root = null;
+    root = null;
     handleRemoved();
   }
   void handleRemoved() { }
 
   UINode findAncestor(Type targetType) {
     var ancestor = _parent;
     while (ancestor != null && !reflectClass(ancestor.runtimeType).isSubtypeOf(reflectClass(targetType)))
       ancestor = ancestor._parent;
     return ancestor;
   }
@@ skipping 20 matching lines @@
 
   void _traceSync(_SyncOperation op, String key) {
     if (!_shouldTrace)
       return;
 
     String opString = op.toString().toLowerCase();
     String outString = opString.substring(opString.indexOf('.') + 1);
     _trace('_sync($outString) $key');
   }
 
-  void _removeChild(UINode node) {
+  void removeChild(UINode node) {
     _traceSync(_SyncOperation.REMOVAL, node._key);
     node._remove();
   }
 
   // Returns the child which should be retained as the child of this node.
   UINode _syncChild(UINode node, UINode oldNode, dynamic slot) {
     assert(node != null);
     assert(oldNode == null || node._key == oldNode._key);
 
     if (node == oldNode) {
       _traceSync(_SyncOperation.IDENTICAL, node._key);
       return node; // Nothing to do. Subtrees must be identical.
     }
 
     // TODO(rafaelw): This eagerly removes the old DOM. It may be that a
     // 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);
+      removeChild(oldNode);
     }
 
     if (node._willSync(oldNode)) {
       _traceSync(_SyncOperation.STATEFUL, node._key);
       oldNode._sync(node, slot);
       node._defunct = true;
-      assert(oldNode._root is RenderCSS);
+      assert(oldNode.root is RenderCSS);
       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 RenderCSS);
+    assert(node.root is RenderCSS);
     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) {
     UINode oldContent = old == null ? null : (old as ContentNode).content;
     content = _syncChild(content, oldContent, slot);
-    assert(content._root != null);
-    _root = content._root;
+    assert(content.root != null);
+    root = content.root;
   }
 
   void _remove() {
     if (content != null)
-      _removeChild(content);
+      removeChild(content);
     super._remove();
   }
 }
 
 class StyleNode extends ContentNode {
   final Style style;
 
   StyleNode(UINode content, this.style): super(content);
 }
 
@@ skipping 135 matching lines @@
 
   RenderNodeWrapper({
     Object key,
     this.style,
     this.inlineStyle
   }) : super(key: key);
 
   final Style style;
   final String inlineStyle;
 
-  RenderCSS _createNode();
-  RenderNodeWrapper get _emptyNode;
+  RenderCSS createNode();
+  RenderNodeWrapper get emptyNode;
 
   void insert(RenderNodeWrapper child, dynamic slot);
 
   void _sync(UINode old, dynamic slot) {
     if (old == null) {
-      _root = _createNode();
-      assert(_root != null);
+      root = createNode();
+      assert(root != null);
       var ancestor = findAncestor(RenderNodeWrapper);
       if (ancestor is RenderNodeWrapper)
         ancestor.insert(this, slot);
-      old = _emptyNode;
+      old = emptyNode;
     } else {
-      _root = old._root;
-      assert(_root != null);
+      root = old.root;
+      assert(root != null);
     }
 
-    _nodeMap[_root] = this;
-    _syncRenderNode(old);
+    _nodeMap[root] = this;
+    syncRenderNode(old);
   }
 
-  void _syncRenderNode(RenderNodeWrapper old) {
+  void syncRenderNode(RenderNodeWrapper old) {
     RenderNodeWrapper oldRenderNodeWrapper = old as RenderNodeWrapper;
 
     List<Style> styles = new List<Style>();
     if (style != null)
       styles.add(style);
     ParentData parentData = null;
     UINode parent = _parent;
     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);
+    root.updateStyles(styles);
     if (parentData != null) {
-      assert(_root.parentData != null);
-      _root.parentData.merge(parentData); // this will throw if the types aren't approriate
+      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();
+      assert(parent.root != null);
+      parent.root.markNeedsLayout();
     }
-    _root.updateInlineStyle(inlineStyle);
+    root.updateInlineStyle(inlineStyle);
   }
 
-  void _removeChild(UINode node) {
-    assert(_root is RenderCSSContainer);
-    _root.remove(node._root);
-    super._removeChild(node);
+  void removeChild(UINode node) {
+    assert(root is RenderCSSContainer);
+    root.remove(node.root);
+    super.removeChild(node);
   }
 
   void _remove() {
-    assert(_root != null);
-    _nodeMap.remove(_root);
+    assert(root != null);
+    _nodeMap.remove(root);
     super._remove();
   }
 }
 
 final List<UINode> _emptyList = new List<UINode>();
 
 abstract class OneChildListRenderNodeWrapper extends RenderNodeWrapper {
 
   // In OneChildListRenderNodeWrapper subclasses, slots are RenderCSS nodes
   // to use as the "insert before" sibling in RenderCSSContainer.add() calls
 
   final List<UINode> children;
 
   OneChildListRenderNodeWrapper({
     Object key,
     List<UINode> children,
     Style style,
     String inlineStyle
   }) : this.children = children == null ? _emptyList : children,
   super(
     key: key,
     style: style,
     inlineStyle: inlineStyle
   ) {
     assert(!_debugHasDuplicateIds());
   }
 
   void insert(RenderNodeWrapper child, dynamic slot) {
     assert(slot == null || slot is RenderCSS);
-    _root.add(child._root, before: slot);
+    root.add(child.root, before: slot);
   }
 
   void _remove() {
     assert(children != null);
     for (var child in children) {
       assert(child != null);
-      _removeChild(child);
+      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 syncRenderNode(OneChildListRenderNodeWrapper old) {
+    super.syncRenderNode(old);
 
-    if (_root is! RenderCSSContainer)
+    if (root is! RenderCSSContainer)
       return;
 
     var startIndex = 0;
     var endIndex = children.length;
 
     var oldChildren = old.children;
     var oldStartIndex = 0;
     var oldEndIndex = oldChildren.length;
 
     RenderCSS nextSibling = null;
@@ skipping 51 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 RenderCSSContainer);
-      assert(oldNode._root is RenderCSSContainer);
+      assert(root is RenderCSSContainer);
+      assert(oldNode.root is RenderCSSContainer);
 
-      old._root.remove(oldNode._root);
-      _root.add(oldNode._root, before: nextSibling);
+      old.root.remove(oldNode.root);
+      root.add(oldNode.root, before: nextSibling);
 
       return true;
     }
 
     // Scan forwards, this time we may re-order;
-    nextSibling = _root.firstChild;
+    nextSibling = root.firstChild;
     while (startIndex < endIndex && oldStartIndex < oldEndIndex) {
       currentNode = children[startIndex];
       oldNode = oldChildren[oldStartIndex];
 
       if (currentNode._key == oldNode._key) {
         assert(currentNode.runtimeType == oldNode.runtimeType);
-        nextSibling = _root.childAfter(nextSibling);
+        nextSibling = root.childAfter(nextSibling);
         sync(startIndex);
         startIndex++;
         advanceOldStartIndex();
         continue;
       }
 
       oldNode = null;
       searchForOldNode();
       sync(startIndex);
       startIndex++;
     }
 
     // New insertions
     oldNode = null;
     while (startIndex < endIndex) {
       currentNode = children[startIndex];
       sync(startIndex);
       startIndex++;
     }
 
     // Removals
     currentNode = null;
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
-      _removeChild(oldNode);
+      removeChild(oldNode);
       advanceOldStartIndex();
     }
   }
 }
 
 class Container extends OneChildListRenderNodeWrapper {
 
-  RenderCSSContainer _root;
-  RenderCSSContainer _createNode() => new RenderCSSContainer(this);
+  RenderCSSContainer root;
+  RenderCSSContainer createNode() => new RenderCSSContainer(this);
 
   static final Container _emptyContainer = new Container();
 
-  RenderNodeWrapper 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 OneChildListRenderNodeWrapper {
 
-  RenderCSSParagraph _root;
-  RenderCSSParagraph _createNode() => new RenderCSSParagraph(this);
+  RenderCSSParagraph root;
+  RenderCSSParagraph createNode() => new RenderCSSParagraph(this);
 
   static final Paragraph _emptyContainer = new Paragraph();
 
-  RenderNodeWrapper 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 OneChildListRenderNodeWrapper {
 
-  RenderCSSFlex _root;
-  RenderCSSFlex _createNode() => new RenderCSSFlex(this, this.direction);
+  RenderCSSFlex root;
+  RenderCSSFlex createNode() => new RenderCSSFlex(this, this.direction);
 
   static final FlexContainer _emptyContainer = new FlexContainer();
     // direction doesn't matter if it's empty
 
-  RenderNodeWrapper 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 _syncRenderNode(UINode old) {
-    super._syncRenderNode(old);
-    _root.direction = direction;
+  void syncRenderNode(UINode old) {
+    super.syncRenderNode(old);
+    root.direction = direction;
   }
 }
 
 class FillStackContainer extends OneChildListRenderNodeWrapper {
 
-  RenderCSSStack _root;
-  RenderCSSStack _createNode() => new RenderCSSStack(this);
+  RenderCSSStack root;
+  RenderCSSStack createNode() => new RenderCSSStack(this);
 
   static final FillStackContainer _emptyContainer = new FillStackContainer();
 
-  RenderNodeWrapper 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,
@@ skipping 10 matching lines @@
     if (input == null)
       return null;
     return input.map((node) {
       return new ParentDataNode(node, _fillParentData);
     }).toList();
   }
 }
 
 class TextFragment extends RenderNodeWrapper {
 
-  RenderCSSInline _root;
-  RenderCSSInline _createNode() => new RenderCSSInline(this, this.data);
+  RenderCSSInline root;
+  RenderCSSInline createNode() => new RenderCSSInline(this, this.data);
 
   static final TextFragment _emptyText = new TextFragment('');
 
-  RenderNodeWrapper 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 _syncRenderNode(UINode old) {
-    super._syncRenderNode(old);
-    _root.data = data;
+  void syncRenderNode(UINode old) {
+    super.syncRenderNode(old);
+    root.data = data;
   }
 }
 
 class Image extends RenderNodeWrapper {
 
-  RenderCSSImage _root;
-  RenderCSSImage _createNode() => new RenderCSSImage(this, this.src, this.width, this.height);
+  RenderCSSImage root;
+  RenderCSSImage createNode() => new RenderCSSImage(this, this.src, this.width, this.height);
 
   static final Image _emptyImage = new Image();
 
-  RenderNodeWrapper 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,
     this.height,
     this.src
   }) : super(
     key: key,
     style: style,
     inlineStyle: inlineStyle
   );
 
-  void _syncRenderNode(UINode old) {
-    super._syncRenderNode(old);
-    _root.configure(this.src, this.width, this.height);
+  void syncRenderNode(UINode old) {
+    super.syncRenderNode(old);
+    root.configure(this.src, this.width, this.height);
   }
 }
 
 
 Set<Component> _mountedComponents = new HashSet<Component>();
 Set<Component> _unmountedComponents = new HashSet<Component>();
 
 void _enqueueDidMount(Component c) {
   assert(!_notifingMountStatus);
   _mountedComponents.add(c);
@@ skipping 104 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.
-  RenderCSS getRoot() => _root;
+  RenderCSS getRoot() => root;
 
   void _remove() {
     assert(_built != null);
-    assert(_root != null);
-    _removeChild(_built);
+    assert(root != null);
+    removeChild(_built);
     _built = null;
     _enqueueDidUnmount(this);
     super._remove();
   }
 
   bool _willSync(UINode old) {
     Component oldComponent = old as Component;
     if (oldComponent == null || !oldComponent._stateful)
       return false;
 
@@ skipping 38 matching lines @@
 
     int lastOrder = _currentOrder;
     _currentOrder = _order;
     _currentlyBuilding = this;
     _built = build();
     _currentlyBuilding = null;
     _currentOrder = lastOrder;
 
     _built = _syncChild(_built, oldBuilt, slot);
     _dirty = false;
-    _root = _built._root;
-    assert(_root != null);
+    root = _built.root;
+    assert(root != null);
   }
 
   void _buildIfDirty() {
     if (!_dirty || _defunct)
       return;
 
     _trace('$_key rebuilding...');
-    assert(_root != null);
+    assert(root != null);
     _sync(null, _slot);
   }
 
   void scheduleBuild() {
     setState(() {});
   }
 
   void setState(Function fn()) {
     _stateful = true;
     fn();
@@ skipping 14 matching lines @@
     _host = new RenderCSSRoot(this);
     _scheduleComponentForRender(this);
   }
 
   void _buildIfDirty() {
     if (!_dirty || _defunct)
       return;
 
     _trace('$_key rebuilding...');
     _sync(null, null);
-    if (_root.parent == null)
-      _host.add(_root);
-    assert(_root.parent == _host);
+    if (root.parent == null)
+      _host.add(root);
+    assert(root.parent == _host);
   }
 }
 
 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)]);
 }