Remove all the caching of Theme data, since perf data suggests it wasn't helping.

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 204 matching lines @@
   }
 
 }
 
 class ParentDataNode extends TagNode {
   ParentDataNode(Widget child, this.parentData, { String key })
     : super(child, key: key);
   final ParentData parentData;
 }
 
-abstract class _Heir implements Widget {
-  Map<Type, Inherited> _traits;
-  Inherited inheritedOfType(Type type) => _traits == null ? null : _traits[type];
-
-  static _Heir _getHeirAncestor(Widget widget) {
-    Widget ancestor = widget;
-    while (ancestor != null && !(ancestor is _Heir)) {
-      ancestor = ancestor.parent;
-    }
-    return ancestor as _Heir;
-  }
-
-  void _updateTraitsFromParent(Widget parent) {
-    _Heir ancestor = _getHeirAncestor(parent);
-    if (ancestor == null || ancestor._traits == null) return;
-    _updateTraits(ancestor._traits);
-  }
-
-  void _updateTraitsRecursively(Widget widget) {
-    if (widget is _Heir)
-      widget._updateTraits(_traits);
-    else
-      widget.walkChildren(_updateTraitsRecursively);
-  }
-
-  void _updateTraits(Map<Type, Inherited> newTraits) {
-    if (newTraits != _traits) {
-      _traits = newTraits;
-      walkChildren(_updateTraitsRecursively);
-    }
-  }
-}
-
-abstract class Inherited extends TagNode with _Heir {
-  Inherited({ String key, Widget child }) : super._withKey(child, key) {
-    _traits = new Map<Type, Inherited>();
-  }
-
-  void set _traits(Map<Type, Inherited> value) {
-    super._traits = new Map<Type, Inherited>.from(value)
-                                            ..[runtimeType] = this;
-  }
-
-  // TODO(jackson): When Dart supports super in mixins we can move to _Heir
-  void setParent(Widget parent) {
-    _updateTraitsFromParent(parent);
-    super.setParent(parent);
-  }
+abstract class Inherited extends TagNode {
+  Inherited({ String key, Widget child }) : super._withKey(child, key);
 }
 
 typedef void GestureEventListener(sky.GestureEvent e);
 typedef void PointerEventListener(sky.PointerEvent e);
 typedef void EventListener(sky.Event e);
 
 class Listener extends TagNode  {
 
   Listener({
     Widget child,
@@ skipping 73 matching lines @@
 
   void _handleEvent(sky.Event e) {
     sky.EventListener listener = listeners[e.type];
     if (listener != null) {
       listener(e);
     }
   }
 
 }
 
-abstract class Component extends Widget with _Heir {
+abstract class Component extends Widget {
 
   Component({ String key, bool stateful })
       : _stateful = stateful != null ? stateful : false,
         _order = _currentOrder + 1,
         super._withKey(key);
 
   static Component _currentlyBuilding;
   bool get _isBuilding => _currentlyBuilding == this;
 
   bool _stateful;
   bool _dirty = true;
   bool _disqualifiedFromEverAppearingAgain = false;
 
   Widget _built;
   dynamic _slot; // cached slot from the last time we were synced
 
   void didMount() {
     assert(!_disqualifiedFromEverAppearingAgain);
     super.didMount();
   }
 
-  // TODO(jackson): When Dart supports super in mixins we can move to _Heir
-  void setParent(Widget parent) {
-    _updateTraitsFromParent(parent);
-    super.setParent(parent);
-  }
-
   void remove() {
     assert(_built != null);
     assert(root != null);
     removeChild(_built);
     _built = null;
     super.remove();
   }
 
   void detachRoot() {
     assert(_built != null);
     assert(root != null);
     _built.detachRoot();
   }
 
+  Inherited inheritedOfType(Type targetType) {
+    Widget ancestor = parent;
+    while (ancestor != null && ancestor.runtimeType != targetType)
+      ancestor = ancestor.parent;
+    return ancestor;
+  }
+
   bool _retainStatefulNodeIfPossible(Widget old) {
     assert(!_disqualifiedFromEverAppearingAgain);
 
     Component oldComponent = old as Component;
     if (oldComponent == null || !oldComponent._stateful)
       return false;
 
     assert(runtimeType == oldComponent.runtimeType);
     assert(key == oldComponent.key);
 
@@ skipping 595 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();
 }