Example showing alternate async measurement solution

client/view/view.dart

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2012, 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.
 
 #library("view");
 
 #import('dart:html');
 #import('../base/base.dart');
 #import('../observable/observable.dart');
 #import('../touch/touch.dart');
 #import('../layout/layout.dart');
@@ skipping 149 matching lines @@
   /**
    * Override this to perform behavior after this View has been removed from the
    * document. This can be a convenient time to unregister event handlers bound
    * in enterDocument().
    *
    * This will be called each time the View is removed from the document, if it
    * is added and removed multiple times.
    */
   void exitDocument() {}
 
-  /** Override this to perform behavior after the window is resized. */
+  /**
+   * Override this to perform behavior after the window is resized.
+   * This method is guaranteed to be called within a measurement frame.  To
+   * manipulate the DOM, return a LayoutCallback which will be execututed
+   * in the normal context.
+   */
   // TODO(jmesserly): this isn't really the event we want. Ideally we want to
   // fire the event only if this particular View changed size. Also we should
   // give a view the ability to measure itself when added to the document.
-  void windowResized() {}
+  LayoutCallback windowResized() => null;
 
   /**
    * Registers the given listener callback to the given observable. Also
    * immedially invokes the callback once as if a change has just come in. This
    * lets you define a render() method that renders the skeleton of a view, then
    * register a bunch of listeners which all fire to populate the view with
    * model data.
    */
   void watch(Observable observable, void watcher(EventSummary summary)) {
     // Make a fake summary for the initial watch.
@@ skipping 124 matching lines @@
   }
 
   void _unhookGlobalLayoutEvents() {
     if (_resizeHandler != null) {
       window.on.resize.remove(_resizeHandler);
       _resizeHandler = null;
     }
   }
 
   void doLayout() {
-    _measureLayout().then((bool changed) {
-      if (changed) {
-        _applyLayoutToChildren();
+    // Callbacks to execute after all layouts are complete.
+    final callbacks = <LayoutCallback>[];
+    bool changed = false;
+    void _measureLayout(View v) {
+      assert(window.inMeasurementFrame);
+      LayoutCallback callback = v.windowResized();
+      if (callback != null) {
+        callbacks.add(callback);
       }
+      // TODO(jmesserly): this logic is more complex than it needs to be
+      // because we're taking pains to not initialize _layout if it's not
+      // needed. Is that a good tradeoff?
+      if (ViewLayout.hasCustomLayout(v)) {
+        final rect = v._node.rect.client;
+        if (v.layout.measureLayout(rect.width, rect.height)) {
+          changed = true;
+        }
+      } else {
+        for (final child in v.childViews) {
+          _measureLayout(child);
+        }
+      }
+    }
+
+    window.requestMeasurementFrame(() {
+      _measureLayout(this);
+      return () {
+        if (changed) {
+          _applyLayoutToChildren();
+        }
+        for (LayoutCallback callback in callbacks) {
+          callback();
+        }
+      };
     });
   }
 
-  Future<bool> _measureLayout() {
-    final changed = new Completer<bool>();
-    _measureLayoutHelper(changed);
-
-    window.requestLayoutFrame(() {
-      if (!changed.future.isComplete) {
-        changed.complete(false);
-      }
-    });
-    return changed.future;
-  }
-
-  void _measureLayoutHelper(Completer<bool> changed) {
-    windowResized();
-
-    // TODO(jmesserly): this logic is more complex than it needs to be because
-    // we're taking pains to not initialize _layout if it's not needed. Is that
-    // a good tradeoff?
-    if (ViewLayout.hasCustomLayout(this)) {
-      Completer sizeCompleter = new Completer<Size>();
-      _node.rect.then((ElementRect rect) {
-        sizeCompleter.complete(
-            new Size(rect.client.width, rect.client.height));
-      });
-      layout.measureLayout(sizeCompleter.future, changed);
-    } else {
-      for (final child in childViews) {
-        child._measureLayoutHelper(changed);
-      }
-    }
-  }
-
   void _applyLayoutToChildren() {
     for (final child in childViews) {
       child._applyLayout();
     }
   }
 
   void _applyLayout() {
     if (_layout != null) {
       _layout.applyLayout();
     }
     _applyLayoutToChildren();
   }
 }