Rename OneChildListRenderObjectWrapper to MultiChildRenderObjectWrapper to avoid the confusing simi…

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';
@@ skipping 243 matching lines @@
     sky.EventListener listener = listeners[e.type];
     if (listener != null) {
       listener(e);
     }
   }
 }
 
 /*
  * 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 OneChildListRenderObjectWrapper's
+ * 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 {
 
   static final Map<RenderObject, RenderObjectWrapper> _nodeMap =
       new HashMap<RenderObject, RenderObjectWrapper>();
 
   static RenderObjectWrapper _getMounted(RenderObject node) => _nodeMap[node];
 
@@ skipping 132 matching lines @@
   RenderTransform createNode() => new RenderTransform(transform: transform);
 
   void syncRenderObject(Transform old) {
     super.syncRenderObject(old);
     root.transform = transform;
   }
 }
 
 final List<UINode> _emptyList = new List<UINode>();
 
-abstract class OneChildListRenderObjectWrapper extends RenderObjectWrapper {
+abstract class MultiChildRenderObjectWrapper extends RenderObjectWrapper {
 
-  // In OneChildListRenderObjectWrapper subclasses, slots are RenderObject nodes
+  // In MultiChildRenderObjectWrapper subclasses, slots are RenderObject nodes
   // to use as the "insert before" sibling in ContainerRenderObjectMixin.add() calls
 
   final List<UINode> children;
 
-  OneChildListRenderObjectWrapper({
+  MultiChildRenderObjectWrapper({
     Object key,
     List<UINode> children
   }) : this.children = children == null ? _emptyList : children,
   super(
     key: key
   ) {
     assert(!_debugHasDuplicateIds());
   }
 
   void insert(RenderObjectWrapper child, dynamic slot) {
@@ skipping 25 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 syncRenderObject(OneChildListRenderObjectWrapper old) {
+  void syncRenderObject(MultiChildRenderObjectWrapper old) {
     super.syncRenderObject(old);
 
     if (root is! ContainerRenderObjectMixin)
       return;
 
     var startIndex = 0;
     var endIndex = children.length;
 
     var oldChildren = old == null ? [] : old.children;
     var oldStartIndex = 0;
@@ skipping 102 matching lines @@
     // Removals
     currentNode = null;
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
       removeChild(oldNode);
       advanceOldStartIndex();
     }
   }
 }
 
-class BlockContainer extends OneChildListRenderObjectWrapper {
+class BlockContainer extends MultiChildRenderObjectWrapper {
   RenderBlock root;
   RenderBlock createNode() => new RenderBlock();
 
   BlockContainer({ Object key, List<UINode> children })
     : super(key: key, children: children);
 }
 
-class StackContainer extends OneChildListRenderObjectWrapper {
+class StackContainer extends MultiChildRenderObjectWrapper {
   RenderStack root;
   RenderStack createNode() => new RenderStack();
 
   StackContainer({ Object key, List<UINode> children })
     : super(key: key, children: children);
 }
 
 class Paragraph extends RenderObjectWrapper {
   RenderParagraph root;
   RenderParagraph createNode() => new RenderParagraph(text: text);
 
   final String text;
 
   Paragraph({ Object key, this.text }) : super(key: key);
 
   void syncRenderObject(UINode old) {
     super.syncRenderObject(old);
     root.text = text;
   }
 }
 
-class FlexContainer extends OneChildListRenderObjectWrapper {
+class FlexContainer extends MultiChildRenderObjectWrapper {
   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);
@@ skipping 320 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);
 }