Revert "Example showing alternate async measurement solution"

client/touch/Scroller.dart

-// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// 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.
 
 /**
  * Implementation of a custom scrolling behavior.
  * This behavior overrides native scrolling for an area. This area can be a
  * single defined part of a page, the entire page, or several different parts
  * of a page.
  *
  * To use this scrolling behavior you need to define a frame and the content.
@@ skipping 13 matching lines @@
  * For this to work properly you need to set -webkit-text-size-adjust to 'none'
  * on an ancestor element of the frame, or on the frame itself. If you forget
  * this you may see the text content of the scrollable area changing size as it
  * moves.
  *
  * The behavior is intended to support vertical and horizontal scrolling, and
  * scrolling with momentum when a touch gesture flicks with enough velocity.
  */
 typedef void Callback();
 
+// Helper method to await the completion of 2 futures.
+void joinFutures(List<Future> futures, Callback callback) {
+  int count = 0;
+  int len = futures.length;
+  void helper(value) {
+    count++;
+    if (count == len) {
+      callback();
+    }
+  }
+  for (Future p in futures) {
+    p.then(helper);
+  }
+}
+
 class Scroller implements Draggable, MomentumDelegate {
 
   /** Pixels to move each time an arrow key is pressed. */
   static final ARROW_KEY_DELTA = 30;
   static final SCROLL_WHEEL_VELOCITY = 0.01;
   static final FAST_SNAP_DECELERATION_FACTOR = 0.84;
   static final PAGE_KEY_SCROLL_FRACTION = .85;
 
   // TODO(jacobr): remove this static variable.
   static bool _dragInProgress = false;
@@ skipping 164 matching lines @@
             break;
             */
         }
         if (handled) {
           e.preventDefault();
         }
       });
     // The scrollable element must be relatively positioned.
     // TODO(jacobr): this assert fires asynchronously which could be confusing.
     if (_scrollTechnique == ScrollerScrollTechnique.RELATIVE_POSITIONING) {
-      window.requestMeasurementFrame(() {
-        assert(_element.computedStyle.position != "static");
+      _element.computedStyle.then((CSSStyleDeclaration style) {
+        assert(style.position != "static");
       });
     }
 
     _initLayer();
   }
 
   EventListenerList get onScrollerStart() {
     if (_onScrollerStart === null) {
       _onScrollerStart = new SimpleEventListenerList();
     }
@@ skipping 250 matching lines @@
   void onTouchEnd() {
   }
 
   /**
    * Prepare the scrollable area for possible movement.
    */
   bool onTouchStart(TouchEvent e) {
     reconfigure(() {
       final touch = e.touches[0];
       if (_momentum.decelerating) {
-        // TODO(jacobr): this won't do any good as it is called too late due
-        // to async measurement.
         e.preventDefault();
         e.stopPropagation();
         stop();
       }
       _contentStartOffset = _contentOffset.clone();
       _snapContentOffsetToBounds();
     });
     return true;
   }
 
@@ skipping 18 matching lines @@
     _minOffset.x = 0;
     _minOffset.y = 0;
     reconfigure(() => _setContentOffset(_maxPoint.x, _maxPoint.y));
   }
 
   /**
    * Recalculate dimensions of the frame and the content. Adjust the minPoint
    * and maxPoint allowed for scrolling.
    */
   void _resize(Callback callback) {
-    window.requestMeasurementFrame(() {
-      final offset = _frame.rect.offset;
+    final frameRect = _frame.rect;
+    Future contentSizeFuture;
 
-      if (_lookupContentSizeDelegate !== null) {
-        // Guaranteed to be called within a measurement frame
-        _contentSize = _lookupContentSizeDelegate();
-      } else {
-        final scroll = _element.rect.scroll;
-        _contentSize = new Size(scroll.width, scroll.height);
-      }
+    if (_lookupContentSizeDelegate !== null) {
+      contentSizeFuture = _lookupContentSizeDelegate();
+      contentSizeFuture.then((Size size) {
+        _contentSize = size;
+      });
+    } else {
+      contentSizeFuture = _element.rect;
+      contentSizeFuture.then((ElementRect rect) {
+        _contentSize = new Size(rect.scroll.width, rect.scroll.height);
+      });
+    }
 
-      _scrollSize = new Size(offset.width, offset.height);
+    joinFutures(<Future>[frameRect, contentSizeFuture], () {
+      _scrollSize = new Size(frameRect.value.offset.width,
+                             frameRect.value.offset.height);
       Size adjusted = _getAdjustedContentSize();
       _maxPoint = new Coordinate(-_maxOffset.x, -_maxOffset.y);
       _minPoint = new Coordinate(
           Math.min(
               _scrollSize.width - adjusted.width + _minOffset.x, _maxPoint.x),
           Math.min(
               _scrollSize.height - adjusted.height + _minOffset.y, _maxPoint.y));
-      return callback;
+      callback();
     });
   }
 
   Coordinate _snapToBounds(num x, num y) {
     num clampX = GoogleMath.clamp(_minPoint.x, x, _maxPoint.x);
     num clampY = GoogleMath.clamp(_minPoint.y, y, _maxPoint.y);
     return new Coordinate(clampX, clampY);
   }
 
   /**
@@ skipping 142 matching lines @@
     for (EventListener listener in _listeners) {
       listener(evt);
     }
   }
 }
 
 class ScrollerScrollTechnique {
   static final TRANSFORM_3D = 1;
   static final RELATIVE_POSITIONING = 2;
 }