Refactor stateful parts of Component into StatefulComponent

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 119 matching lines @@
     // belonged to the old node, continue to live on in the replacement node.
     node.remove();
     assert(node.parent == null);
   }
 
   void detachRoot();
 
   // Returns the child which should be retained as the child of this node.
   Widget syncChild(Widget newNode, Widget oldNode, dynamic slot) {
 
-    assert(oldNode is! Component ||
-           (oldNode is Component && !oldNode._disqualifiedFromEverAppearingAgain)); // TODO(ianh): Simplify this once the analyzer is cleverer
-
     if (newNode == oldNode) {
       assert(newNode == null || newNode.mounted);
       assert(newNode is! RenderObjectWrapper ||
              (newNode is RenderObjectWrapper && newNode._ancestor != null)); // TODO(ianh): Simplify this once the analyzer is cleverer
       if (newNode != null)
         newNode.setParent(this);
       return newNode; // Nothing to do. Subtrees must be identical.
     }
 
     if (newNode == null) {
@@ skipping 199 matching lines @@
     sky.EventListener listener = listeners[e.type];
     if (listener != null) {
       listener(e);
     }
   }
 
 }
 
 abstract class Component extends Widget {
 
-  Component({ String key, bool stateful })
-      : _stateful = stateful != null ? stateful : false,
-        _order = _currentOrder + 1,
+  Component({ String key })
+      : _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();
-  }
-
   void remove() {
     assert(_built != null);
     assert(root != null);
     removeChild(_built);
     _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(Component old) {
-    assert(!_disqualifiedFromEverAppearingAgain);
-
-    if (old == null || !old._stateful)
-      return false;
-
-    assert(runtimeType == old.runtimeType);
-    assert(key == old.key);
-
-    // Make |this|, the newly-created object, into the "old" Component, and kill it
-    _stateful = false;
-    _built = old._built;
-    assert(_built != null);
-    _disqualifiedFromEverAppearingAgain = true;
-
-    // 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)
   void _sync(Component old, dynamic slot) {
     assert(_built == null || old == null);
-    assert(!_disqualifiedFromEverAppearingAgain);
 
     _slot = slot;
 
     var oldBuilt;
     if (old == null) {
       oldBuilt = _built;
     } else {
       assert(_built == null);
       oldBuilt = old._built;
     }
 
     int lastOrder = _currentOrder;
     _currentOrder = _order;
     _currentlyBuilding = this;
     _built = build();
     assert(_built != null);
     _currentlyBuilding = null;
     _currentOrder = lastOrder;
 
     _built = syncChild(_built, oldBuilt, slot);
     assert(_built != null);
     assert(_built.parent == this);
     _dirty = false;
     _root = _built.root;
     assert(_root == root); // in case a subclass reintroduces it
     assert(root != null);
   }
 
   void _buildIfDirty() {
-    assert(!_disqualifiedFromEverAppearingAgain);
     if (!_dirty || !_mounted)
       return;
 
     assert(root != null);
     _sync(null, _slot);
   }
 
   void scheduleBuild() {
-    assert(!_disqualifiedFromEverAppearingAgain);
     if (_isBuilding || _dirty || !_mounted)
       return;
     _dirty = true;
     _scheduleComponentForRender(this);
   }
 
-  void setState(Function fn()) {
-    assert(_stateful);
-    fn();
-    scheduleBuild();
-  }
-
   Widget build();
 
 }
 
+abstract class StatefulComponent extends Component {
+
+  StatefulComponent({ String key }) : super(key: key);
+
+  bool _disqualifiedFromEverAppearingAgain = false;
+
+  void didMount() {
+    assert(!_disqualifiedFromEverAppearingAgain);
+    super.didMount();
+  }
+
+  void _buildIfDirty() {
+    assert(!_disqualifiedFromEverAppearingAgain);
+    super._buildIfDirty();
+  }
+
+  void _sync(Widget old, dynamic slot) {
+    assert(!_disqualifiedFromEverAppearingAgain);
+    super._sync(old, slot);
+  }
+
+  Widget syncChild(Widget node, Widget oldNode, dynamic slot) {
+    assert(!_disqualifiedFromEverAppearingAgain);
+    return super.syncChild(node, oldNode, slot);
+  }
+
+  bool _retainStatefulNodeIfPossible(StatefulComponent old) {
+    assert(!_disqualifiedFromEverAppearingAgain);
+
+    if (old == null)
+      return false;
+
+    assert(runtimeType == old.runtimeType);
+    assert(key == old.key);
+
+    // Make |this|, the newly-created object, into the "old" Component, and kill it
+    _built = old._built;
+    assert(_built != null);
+    _disqualifiedFromEverAppearingAgain = true;
+
+    // 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. Derived
+  // classes should override this method to update `this` to
+  // account for the new values the parent passed to `source`.
+  // Make sure to call super.syncFields(source) unless you are
+  // extending StatefulComponent directly.
+  void syncFields(Component source);
+
+  void setState(Function fn()) {
+    assert(!_disqualifiedFromEverAppearingAgain);
+    fn();
+    scheduleBuild();
+  }
+}
+
 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);
@@ skipping 397 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 App extends StatefulComponent {
 
-  // Apps are assumed to be stateful
-  App({ String key }) : super(key: key, stateful: true);
+  App({ String key }) : super(key: key);
 
   void _handleEvent(sky.Event event) {
     if (event.type == 'back')
       onBack();
   }
 
   void didMount() {
     super.didMount();
     SkyBinding.instance.addEventListener(_handleEvent);
   }
 
   void didUnmount() {
     super.didUnmount();
     SkyBinding.instance.removeEventListener(_handleEvent);
   }
 
+  void syncFields(Component source) { }
+
   // Override this to handle back button behavior in your app
   void onBack() { }
 }
 
-abstract class AbstractWidgetRoot extends Component {
+abstract class AbstractWidgetRoot extends StatefulComponent {
 
-  AbstractWidgetRoot() : super(stateful: true) {
+  AbstractWidgetRoot() {
     _mounted = true;
     _scheduleComponentForRender(this);
   }
 
   void syncFields(AbstractWidgetRoot source) {
     assert(false);
     // if we get here, it implies that we have a parent
   }
 
   void _buildIfDirty() {
@@ skipping 64 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();
 }