Make the menu items in the drawer change colour when tapped, per Material spec.

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 '../base/hit_test.dart';
@@ skipping 205 matching lines @@
 
 }
 
 class ParentDataNode extends TagNode {
   ParentDataNode(Widget child, this.parentData, { String key })
     : super(child, key: key);
   final ParentData parentData;
 }
 
 abstract class Inherited extends TagNode {
+
   Inherited({ String key, Widget child }) : super._withKey(child, key);
+
+  void _sync(Widget old, dynamic slot) {
+    if (old != null && syncShouldNotify(old)) {
+      void notifyChildren(Widget child) {
+        if (child is Component &&
+            child._dependencies != null &&
+            child._dependencies.contains(runtimeType))

[abarth-chromium, 2015/07/06 20:13:43]

Do we want to capture runtimeType in a final variable outside the closure to
avoid calling it all the time?

+          child._dependenciesChanged();
+        if (child.runtimeType != this)

[abarth-chromium, 2015/07/06 20:13:43]

child.runtimeType != runtimeType

?

+          child.walkChildren(notifyChildren);
+      }
+      walkChildren(notifyChildren);
+    }
+    super._sync(old, slot);
+  }
+
+  bool syncShouldNotify(Inherited old);
+
 }
 
 typedef void GestureEventListener(sky.GestureEvent e);
 typedef void PointerEventListener(sky.PointerEvent e);
 typedef void EventListener(sky.Event e);
 
 class Listener extends TagNode  {
 
   Listener({
     String key,
@@ skipping 110 matching lines @@
     _built = null;
     super.remove();
   }
 
   void detachRoot() {
     assert(_built != null);
     assert(root != null);
     _built.detachRoot();
   }
 
+  Set<Type> _dependencies;
   Inherited inheritedOfType(Type targetType) {
+    if (_dependencies == null)
+      _dependencies = new Set<Type>();
+    _dependencies.add(targetType);
     Widget ancestor = parent;
     while (ancestor != null && ancestor.runtimeType != targetType)
       ancestor = ancestor.parent;
     return ancestor;
   }
+  void _dependenciesChanged() {
+    // called by Inherited.sync()
+    scheduleBuild();
+  }
 
-  bool _retainStatefulNodeIfPossible(Widget old) {
+  bool _retainStatefulNodeIfPossible(Component old) {
     assert(!_disqualifiedFromEverAppearingAgain);
 
-    Component oldComponent = old as Component;
-    if (oldComponent == null || !oldComponent._stateful)
+    if (old == null || !old._stateful)
       return false;
 
-    assert(runtimeType == oldComponent.runtimeType);
-    assert(key == oldComponent.key);
+    assert(runtimeType == old.runtimeType);
+    assert(key == old.key);
 
     // Make |this|, the newly-created object, into the "old" Component, and kill it
     _stateful = false;
-    _built = oldComponent._built;
+    _built = old._built;
     assert(_built != null);
     _disqualifiedFromEverAppearingAgain = true;
 
-    // Make |oldComponent| the "new" component
-    oldComponent._built = null;
-    oldComponent._dirty = true;
-    oldComponent.syncFields(this);
+    // Make |old| the "new" component
+    old._built = null;
+    old._dirty = true;
+    old.syncFields(this);
     return true;
   }
 
   // This is called by _retainStatefulNodeIfPossible(), during
   // syncChild(), just before _sync() is called.
   // This must be implemented on any subclass that can become stateful
   // (but don't call super.syncFields() if you inherit directly from
   // Component, since that'll fire an assert).
   // If you don't ever become stateful, then don't override this.
   void syncFields(Component source) {
     assert(false);
   }
 
+  // order corresponds to _build_ order, not depth in the tree.
+  // All the Components built by a particular other Component will have the
+  // same order, regardless of whether one is subsequently inserted
+  // into another. The order is used to not tell a Component to
+  // rebuild if the Component that it built has itself been rebuilt.
   final int _order;
   static int _currentOrder = 0;
 
   // There are three cases here:
   // 1) Building for the first time:
   //      assert(_built == null && old == null)
   // 2) Re-building (because a dirty flag got set):
   //      assert(_built != null && old == null)
   // 3) Syncing against an old version
   //      assert(_built == null && old != null)
@@ skipping 32 matching lines @@
   void _buildIfDirty() {
     assert(!_disqualifiedFromEverAppearingAgain);
     if (!_dirty || !_mounted)
       return;
 
     assert(root != null);
     _sync(null, _slot);
   }
 
   void scheduleBuild() {
-    setState(() {});
+    assert(!_disqualifiedFromEverAppearingAgain);
+    if (_isBuilding || _dirty || !_mounted)
+      return;
+    _dirty = true;
+    _scheduleComponentForRender(this);
   }
 
   void setState(Function fn()) {
-    assert(!_disqualifiedFromEverAppearingAgain);
     assert(_stateful);
     fn();
-    if (_isBuilding || _dirty || !_mounted)
-      return;
-
-    _dirty = true;
-    _scheduleComponentForRender(this);
+    scheduleBuild();
   }
 
   Widget build();
 
 }
 
 Set<Component> _dirtyComponents = new Set<Component>();
 bool _buildScheduled = false;
 bool _inRenderDirtyComponents = false;
 
 List<int> _debugFrameTimes = <int>[];
 
+void _absorbDirtyComponents(List<Component> list) {
+  list.addAll(_dirtyComponents);
+  _dirtyComponents.clear();
+  list.sort((Component a, Component b) => a._order - b._order);
+}
+
 void _buildDirtyComponents() {
   Stopwatch sw;
   if (_shouldLogRenderDuration)
     sw = new Stopwatch()..start();
 
+  _inRenderDirtyComponents = true;
   try {
     sky.tracing.begin('Widgets._buildDirtyComponents');
-    _inRenderDirtyComponents = true;
-
-    List<Component> sortedDirtyComponents = _dirtyComponents.toList();
-    sortedDirtyComponents.sort((Component a, Component b) => a._order - b._order);
-    for (var comp in sortedDirtyComponents) {
-      comp._buildIfDirty();
+    List<Component> sortedDirtyComponents = new List<Component>();
+    _absorbDirtyComponents(sortedDirtyComponents);
+    int index = 0;
+    while (index < sortedDirtyComponents.length) {
+      Component component = sortedDirtyComponents[index];
+      component._buildIfDirty();
+      if (_dirtyComponents.length > 0) {
+        // the following assert verifies that we're not rebuilding anyone twice in one frame
+        assert(_dirtyComponents.every((Component component) => !sortedDirtyComponents.contains(component)));
+        _absorbDirtyComponents(sortedDirtyComponents);
+        index = 0;
+      } else {
+        index += 1;
+      }
     }
-
-    _dirtyComponents.clear();
+  } finally {
     _buildScheduled = false;
-  } finally {
     _inRenderDirtyComponents = false;
     sky.tracing.end('Widgets._buildDirtyComponents');
   }
 
   Widget._notifyMountStatusChanged();
 
   if (_shouldLogRenderDuration) {
     sw.stop();
     _debugFrameTimes.add(sw.elapsedMicroseconds);
     if (_debugFrameTimes.length >= 1000) {
       _debugFrameTimes.sort();
       const int i = 99;
       print('_buildDirtyComponents: ${i+1}th fastest frame out of the last ${_debugFrameTimes.length}: ${_debugFrameTimes[i]} microseconds');
       _debugFrameTimes.clear();
     }
   }
 }
 
 void _scheduleComponentForRender(Component c) {
-  assert(!_inRenderDirtyComponents);
   _dirtyComponents.add(c);
-
   if (!_buildScheduled) {
     _buildScheduled = true;
     new Future.microtask(_buildDirtyComponents);
   }
 }
 
 
 // RenderObjectWrappers correspond to a desired state of a RenderObject.
 // They are fully immutable, with one exception: A Widget which is a
 // Component which lives within an MultiChildRenderObjectWrapper's
@@ skipping 446 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();
 }