Make UINode's key a String

sky/sdk/lib/widgets/ui_node.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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 
 import '../app/view.dart';
 import '../rendering/box.dart';
 import '../rendering/object.dart';
 
 export '../rendering/box.dart' show BoxConstraints, BoxDecoration, Border, BorderSide, EdgeDims;
 export '../rendering/flex.dart' show FlexDirection;
 export '../rendering/object.dart' show Point, Size, Rect, Color, Paint, Path;
 
-
-// final sky.Tracing _tracing = sky.window.tracing;
-
 final bool _shouldLogRenderDuration = false;
 
-/*
- * All Effen nodes derive from UINode. All nodes have a _parent, a _key and
- * can be sync'd.
- */
+// All Effen nodes derive from UINode. All nodes have a _parent, a _key and
+// can be sync'd.
 abstract class UINode {
 
-  UINode({ Object key }) {
+  UINode({ String key }) {
     _key = key == null ? "$runtimeType" : "$runtimeType-$key";
     assert(this is AbstractUINodeRoot || _inRenderDirtyComponents); // you should not build the UI tree ahead of time, build it only during build()
   }
 
   String _key;
   String get key => _key;
 
   UINode _parent;
   UINode get parent => _parent;
 
@@ skipping 110 matching lines @@
     return node;
   }
 }
 
 
 // Descendants of TagNode provide a way to tag RenderObjectWrapper and
 // Component nodes with annotations, such as event listeners,
 // stylistic information, etc.
 abstract class TagNode extends UINode {
 
-  TagNode(UINode content, { Object key }) : this.content = content, super(key: key);
+  TagNode(UINode content, { String key })
+    : this.content = content, super(key: key);
 
   UINode content;
 
   void _sync(UINode old, dynamic slot) {
     UINode oldContent = old == null ? null : (old as TagNode).content;
     content = syncChild(content, oldContent, slot);
     assert(content.root != null);
     _root = content.root;
     assert(_root == root); // in case a subclass reintroduces it
   }
 
   void remove() {
     if (content != null)
       removeChild(content);
     super.remove();
   }
 
 }
 
 class ParentDataNode extends TagNode {
-  ParentDataNode(UINode content, this.parentData, { Object key }): super(content, key: key);
+  ParentDataNode(UINode content, this.parentData, { String key })
+    : super(content, key: key);
   final ParentData parentData;
 }
 
 typedef void GestureEventListener(sky.GestureEvent e);
 typedef void PointerEventListener(sky.PointerEvent e);
 typedef void EventListener(sky.Event e);
 
 class EventListenerNode extends TagNode  {
 
   EventListenerNode(UINode content, {
@@ skipping 76 matching lines @@
     if (listener != null) {
       listener(e);
     }
   }
 
 }
 
 
 abstract class Component extends UINode {
 
-  Component({ Object key, bool stateful })
+  Component({ String key, bool stateful })
       : _stateful = stateful != null ? stateful : false,
         _order = _currentOrder + 1,
         super(key: key);
 
-  Component.fromArgs(Object key, bool stateful)
-      : this(key: key, stateful: stateful);
-
   static Component _currentlyBuilding;
   bool get _isBuilding => _currentlyBuilding == this;
 
   bool _stateful;
   bool _dirty = true;
   bool _disqualifiedFromEverAppearingAgain = false;
 
   UINode _built;
   dynamic _slot; // cached slot from the last time we were synced
 
@@ skipping 38 matching lines @@
   // (but don't call super.syncFields() if you inherit directly from
   // Component, since that'll fire an assert).
   // If you don't ever become stateful, then don't override this.
   void syncFields(Component source) {
     assert(false);
   }
 
   final int _order;
   static int _currentOrder = 0;
 
-  /* There are three cases here:
-   * 1) Building for the first time:
-   *      assert(_built == null && old == null)
-   * 2) Re-building (because a dirty flag got set):
-   *      assert(_built != null && old == null)
-   * 3) Syncing against an old version
-   *      assert(_built == null && old != null)
-   */
+  // There are three cases here:
+  // 1) Building for the first time:
+  //      assert(_built == null && old == null)
+  // 2) Re-building (because a dirty flag got set):
+  //      assert(_built != null && old == null)
+  // 3) Syncing against an old version
+  //      assert(_built == null && old != null)
   void _sync(UINode old, dynamic slot) {
     assert(_built == null || old == null);
     assert(!_disqualifiedFromEverAppearingAgain);
 
     Component oldComponent = old as Component;
 
     _slot = slot;
 
     var oldBuilt;
     if (oldComponent == null) {
@@ skipping 87 matching lines @@
   assert(!_inRenderDirtyComponents);
   _dirtyComponents.add(c);
 
   if (!_buildScheduled) {
     _buildScheduled = true;
     new Future.microtask(_buildDirtyComponents);
   }
 }
 
 
-/*
- * 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 MultiChildRenderObjectWrapper's
- * children list, may be replaced with the "old" instance if it has
- * become stateful.
- */
+// 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 MultiChildRenderObjectWrapper's
+// children list, may be replaced with the "old" instance if it has
+// become stateful.
 abstract class RenderObjectWrapper extends UINode {
 
-  RenderObjectWrapper({
-    Object key
-  }) : super(key: key);
+  RenderObjectWrapper({ String key }) : super(key: key);
 
   RenderObject createNode();
 
   void insert(RenderObjectWrapper child, dynamic slot);
 
   static final Map<RenderObject, RenderObjectWrapper> _nodeMap =
       new HashMap<RenderObject, RenderObjectWrapper>();
 
   static RenderObjectWrapper _getMounted(RenderObject node) => _nodeMap[node];
 
@@ skipping 36 matching lines @@
 
   void remove() {
     assert(root != null);
     _nodeMap.remove(root);
     super.remove();
   }
 }
 
 abstract class OneChildRenderObjectWrapper extends RenderObjectWrapper {
 
-  OneChildRenderObjectWrapper({ UINode child, Object key }) : _child = child, super(key: key);
+  OneChildRenderObjectWrapper({ UINode child, String key })
+    : _child = child, super(key: key);
 
   UINode _child;
   UINode get child => _child;
 
   void syncRenderObject(RenderObjectWrapper old) {
     super.syncRenderObject(old);
     UINode oldChild = old == null ? null : (old as OneChildRenderObjectWrapper).child;
     _child = syncChild(child, oldChild, null);
   }
 
@@ skipping 19 matching lines @@
     super.remove();
   }
 
 }
 
 abstract class MultiChildRenderObjectWrapper extends RenderObjectWrapper {
 
   // In MultiChildRenderObjectWrapper subclasses, slots are RenderObject nodes
   // to use as the "insert before" sibling in ContainerRenderObjectMixin.add() calls
 
-  MultiChildRenderObjectWrapper({
-    Object key,
-    List<UINode> children
-  }) : this.children = children == null ? const [] : children,
-       super(key: key) {
+  MultiChildRenderObjectWrapper({ String key, List<UINode> children })
+    : this.children = children == null ? const [] : children,
+      super(key: key) {
     assert(!_debugHasDuplicateIds());
   }
 
   final List<UINode> children;
 
   void insert(RenderObjectWrapper child, dynamic slot) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(slot == null || slot is RenderObject);
     assert(root is ContainerRenderObjectMixin);
     root.add(child.root, before: slot);
@@ skipping 267 matching lines @@
     if (root.parent == null) {
       // we haven't attached it yet
       assert(_container.child == null);
       _container.child = root;
     }
     assert(root.parent == _container);
   }
 
   UINode build() => builder();
 }