Big merge from experimental to bleeding edge.

samples/swarm/swarm_ui_lib/layout/GridLayout.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of layout;
 
 /**
  * Implements a grid-based layout system based on:
  * [http://dev.w3.org/csswg/css3-grid-align/]
  *
@@ skipping 136 matching lines @@
    * and Grid rows. The goal of the function is to ensure:
    *   1. That each Grid Track satisfies its minSizing
    *   2. That each Grid Track grows from the breadth which satisfied its
    *      minSizing to a breadth which satifies its
    *      maxSizing, subject to RemainingSpace.
    */
   // Note: spec does not correctly doc all the parameters to this function.
   void _computeUsedBreadthOfTracks(List<GridTrack> tracks) {
 
     // TODO(jmesserly): as a performance optimization we could cache this
-    final items = CollectionUtils.map(view.childViews, (view_) => view_.layout);
+    final items = view.childViews
+        .mappedBy((view_) => view_.layout)
+        .toList();
     CollectionUtils.sortBy(items, (item) => _getSpanCount(item));
 
     // 1. Initialize per Grid Track variables
     for (final t in tracks) {
       // percentage or length sizing functions will return a value
       // min-content, max-content, or a fraction will be set to 0
       t.usedBreadth = t.minSizing.resolveLength(_getGridContentSize());
       t.maxBreadth = t.maxSizing.resolveLength(_getGridContentSize());
       t.updatedBreadth = 0;
     }
@@ skipping 79 matching lines @@
   /**
    * This method computes a '1fr' value, referred to as the
    * tempBreadth, for a set of Grid Tracks. The value computed
    * will ensure that when the tempBreadth is multiplied by the
    * fractions associated with tracks, that the UsedBreadths of tracks
    * will increase by an amount equal to the maximum of zero and the specified
    * freeSpace less the sum of the current UsedBreadths.
    */
   num _calcNormalizedFractionBreadth(List<GridTrack> tracks) {
 
-    final fractionTracks = tracks.filter((t) => t.maxSizing.isFraction);
+    final fractionTracks = tracks.where((t) => t.maxSizing.isFraction).toList();
 
     // Note: the spec has various bugs in this function, such as mismatched
     // identifiers and names that aren't defined. For the most part it's
     // possible to figure out the meaning. It's also a bit confused about
     // how to compute spaceNeededFromFractionTracks, but that should just be the
     // set to the remaining free space after usedBreadth is accounted for.
 
     // We use the tempBreadth field to store the normalized fraction breadth
     for (final t in fractionTracks) {
       t.tempBreadth = t.usedBreadth / t.maxSizing.fractionValue;
@@ skipping 65 matching lines @@
    * This function prioritizes the distribution of space driven by Grid Items
    * in content-sized Grid Tracks by the Grid Item's spanCount. That is, Grid
    * Items having a lower spanCount have an opportunity to increase the size of
    * the Grid Tracks they cover before those with larger SpanCounts.
    *
    * Note: items are assumed to be already sorted in increasing span count
    */
   void _distributeSpaceBySpanCount(List<ViewLayout> items,
       ContentSizeMode sizeMode, _BreadthAccumulator breadth) {
 
-    items = items.filter((item) =>
-        _hasContentSizedTracks(_getTracks(item), sizeMode, breadth));
+    items = items.where((item) =>
+        _hasContentSizedTracks(_getTracks(item), sizeMode, breadth)).toList();
 
     var tracks = [];
 
     for (int i = 0; i < items.length; i++) {
       final item = items[i];
 
       final itemTargetSize = item.measureContent(this, _dimension, sizeMode);
 
       final spannedTracks = _getTracks(item);
       _distributeSpaceToTracks(spannedTracks, itemTargetSize, breadth, true);
@@ skipping 25 matching lines @@
    */
   static bool _hasContentSizedTracks(Collection<GridTrack> tracks,
       ContentSizeMode sizeMode, _BreadthAccumulator breadth) {
 
     for (final t in tracks) {
       final fn = breadth.getSizingFunction(t);
       if (sizeMode == ContentSizeMode.MAX && fn.isMaxContentSized ||
           sizeMode == ContentSizeMode.MIN && fn.isContentSized) {
 
         // Make sure we don't cross a fractional track
-        return tracks.length == 1 || !tracks.some((t_) => t_.isFractional);
+        return tracks.length == 1 || !tracks.any((t_) => t_.isFractional);
       }
     }
     return false;
   }
 
   /** Ensures that the numbered track exists. */
   void _ensureTrack(List<GridTrack> tracks, TrackSizing sizing,
       int start, int span) {
     // Start is 1-based. Make it 0-based.
     start -= 1;
@@ skipping 12 matching lines @@
   }
 
   /**
    * Scans children creating GridLayoutParams as needed, and creates all of the
    * rows and columns that we will need.
    *
    * Note: this can potentially create new rows/columns, so this needs to be
    * run before the track sizing algorithm.
    */
   void _ensureAllTracks() {
-    final items = CollectionUtils.map(view.childViews, (view_) => view_.layout);
+    final items = view.childViews.mappedBy((view_) => view_.layout);
 
     for (final child in items) {
       if (child.layoutParams == null) {
         final p = new GridLayoutParams(child.view, this);
         _ensureTrack(_rowTracks, rowSizing, p.row, p.rowSpan);
         _ensureTrack(_columnTracks, columnSizing, p.column, p.columnSpan);
         child.layoutParams = p;
       }
       child.cacheExistingBrowserLayout();
     }
   }
 
   /**
    * Given the track sizes that were computed, position children in the grid.
    */
   void _setBoundsOfChildren() {
-    final items = CollectionUtils.map(view.childViews, (view_) => view_.layout);
+    final items = view.childViews.mappedBy((view_) => view_.layout);
 
     for (final item in items) {
       GridLayoutParams childLayout = item.layoutParams;
       var xPos = _getTrackLocationX(childLayout);
       var yPos = _getTrackLocationY(childLayout);
 
       int left = xPos.start, width = xPos.length;
       int top = yPos.start, height = yPos.length;
 
       // Somewhat counterintuitively (at least to me):
@@ skipping 46 matching lines @@
       span = childLayout.columnSpan;
       tracks = _columnTracks;
     } else if (_dimension == Dimension.HEIGHT) {
       start = childLayout.row - 1;
       span = childLayout.rowSpan;
       tracks = _rowTracks;
     }
 
     assert(start >= 0 && span >= 1);
 
-    final result = new List<GridTrack>(span);
+    final result = new List<GridTrack>.fixedLength(span);
     for (int i = 0; i < span; i++) {
       result[i] = tracks[start + i];
     }
     return result;
   }
 
   int _getSpanCount(ViewLayout item) {
     GridLayoutParams childLayout = item.layoutParams;
     return (_dimension == Dimension.WIDTH ?
         childLayout.columnSpan : childLayout.rowSpan);
   }
 }