Settings menu item in stock2 doesn't work

sky/sdk/lib/widgets/widget.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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 
 import '../app/view.dart';
 import '../rendering/box.dart';
 import '../rendering/object.dart';
 
 export '../rendering/box.dart' show BoxConstraints, BoxDecoration, Border, BorderSide, EdgeDims;
 export '../rendering/flex.dart' show FlexDirection;
 export '../rendering/object.dart' show Point, Size, Rect, Color, Paint, Path;
 
 final bool _shouldLogRenderDuration = false;
 
 // All Effen nodes derive from Widget. All nodes have a _parent, a _key and
 // can be sync'd.
 abstract class Widget {
 
   Widget({ String key }) {
     _key = key != null ? key : runtimeType.toString();
-    assert(this is AbstractWidgetRoot || _inRenderDirtyComponents); // you should not build the UI tree ahead of time, build it only during build()
+    assert(this is AbstractWidgetRoot || this is App || _inRenderDirtyComponents); // you should not build the UI tree ahead of time, build it only during build()
   }
 
   String _key;
   String get key => _key;
 
   Widget _parent;
   Widget get parent => _parent;
 
   bool _mounted = false;
   bool _wasMounted = false;
@@ skipping 430 matching lines @@
   RenderObject createNode();
 
   void insert(RenderObjectWrapper child, dynamic slot);
 
   static final Map<RenderObject, RenderObjectWrapper> _nodeMap =
       new HashMap<RenderObject, RenderObjectWrapper>();
 
   static RenderObjectWrapper _getMounted(RenderObject node) => _nodeMap[node];
 
   void _sync(Widget old, dynamic slot) {
-    assert(parent != null);
+    assert(parent != null || this is RenderViewWrapper);

[Hixie, 2015/06/17 19:21:25]

This should never be called for RenderViewWrapper. It does tons of work that's
irrelevant for that class. We should just override it in RenderViewWrapper to do
the one line of code we care about (_root = createNode()), and in fact, maybe
should even fix that.

In fact, maybe we should refactor RenderObjectWrapper into two, so that
RenderViewWrapper can inherit from a version of it that doesn't use
createNode().

     if (old == null) {
       _root = createNode();
       var ancestor = findAncestor(RenderObjectWrapper);
       if (ancestor is RenderObjectWrapper)
         ancestor.insert(this, slot);
     } else {
       _root = old.root;
     }
     assert(_root == root); // in case a subclass reintroduces it
     assert(root != null);
@@ skipping 272 matching lines @@
       while (target != null && target.root == targetRoot) {
         if (target is Listener)
           target._handleEvent(event);
         target = target._parent;
       }
     }
   }
 
 }
 
+abstract class App extends Component {
+}
+
 abstract class AbstractWidgetRoot extends Component {
 
-  AbstractWidgetRoot({ RenderView renderViewOverride }) : super(stateful: true) {
-    WidgetAppView.initWidgetAppView(renderViewOverride: renderViewOverride);
+  AbstractWidgetRoot() : super(stateful: true) {
     _mounted = true;
     _scheduleComponentForRender(this);
   }
 
   void syncFields(AbstractWidgetRoot source) {
     assert(false);
     // if we get here, it implies that we have a parent
   }
 
   void _buildIfDirty() {
     assert(_dirty);
     assert(_mounted);
     assert(parent == null);
     _sync(null, null);
   }
 
 }
 
-abstract class App extends AbstractWidgetRoot {
+class RenderViewWrapper extends OneChildRenderObjectWrapper {
+  RenderViewWrapper({ String key, Widget child }) : super(key: key, child: child);
+  RenderView get root => super.root;
+  RenderView createNode() => WidgetAppView._appView.renderView;
+}
 
-  App({ RenderView renderViewOverride }) : super(renderViewOverride: renderViewOverride);
+class AppContainer extends AbstractWidgetRoot {
+  AppContainer(this.app);
+  final App app;
+  Widget build() => new RenderViewWrapper(child: app);
+}
 
-  void _buildIfDirty() {
-    super._buildIfDirty();
-
-    if (root.parent == null) {
-      // we haven't attached it yet
-      WidgetAppView._appView.root = root;
-    }
-    assert(root.parent is RenderView);
-  }
-
+void runApp(App app, { RenderView renderViewOverride }) {
+  WidgetAppView.initWidgetAppView(renderViewOverride: renderViewOverride);
+  new AppContainer(app);
 }
 
 typedef Widget Builder();
 
 class RenderBoxToWidgetAdapter extends AbstractWidgetRoot {
 
   RenderBoxToWidgetAdapter(
     RenderObjectWithChildMixin<RenderBox> container,
     this.builder
   ) : _container = container, super() {
@@ skipping 24 matching lines @@
     if (root.parent == null) {
       // we haven't attached it yet
       assert(_container.child == null);
       _container.child = root;
     }
     assert(root.parent == _container);
   }
 
   Widget build() => builder();
 }