Revert "Example showing alternate async measurement solution"

client/view/view.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.
 
 #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.
-   * 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.
-   */
+  /** Override this to perform behavior after the window is resized. */
   // 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.
-  LayoutCallback windowResized() => null;
+  void windowResized() {}
 
   /**
    * 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() {
-    // 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);
+    _measureLayout().then((bool changed) {
+      if (changed) {
+        _applyLayoutToChildren();
       }
-      // 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();
   }
 }