flutter, inside [flutter/lib/src]

  Element? updateChild(Element? child, Widget? newWidget, Object? newSlot) {
    if (newWidget == null) {
      if (child != null) {
        deactivateChild(child);
      }
      return null;
    }

    final Element newChild;
    if (child != null) {
      bool hasSameSuperclass = true;
      assert(() {
        final int oldElementClass = Element._debugConcreteSubtype(child);
        final int newWidgetClass = Widget._debugConcreteSubtype(newWidget);
        hasSameSuperclass = oldElementClass == newWidgetClass;
        return true;
      }());
      if (hasSameSuperclass && child.widget == newWidget) {
        // ... ignore the lengthy element reusing logic here,
        // https://github.com/flutter/flutter/blob/master/packages/flutter/lib/src/widgets/framework.dart#L3982
      } else {
        deactivateChild(child);
        assert(child._parent == null);
        // The [debugProfileBuildsEnabled] code for this branch is inside
        // [inflateWidget], since some [Element]s call [inflateWidget] directly
        // instead of going through [updateChild].
        newChild = inflateWidget(newWidget, newSlot);
      }
    } else {
      // The [debugProfileBuildsEnabled] code for this branch is inside
      // [inflateWidget], since some [Element]s call [inflateWidget] directly
      // instead of going through [updateChild].
      newChild = inflateWidget(newWidget, newSlot);
    }

    assert(() {
      if (child != null) {
        _debugRemoveGlobalKeyReservation(child);
      }
      final Key? key = newWidget.key;
      if (key is GlobalKey) {
        assert(owner != null);
        owner!._debugReserveGlobalKeyFor(this, newChild, key);
      }
      return true;
    }());

    return newChild;
  }

  Element inflateWidget(Widget newWidget, Object? newSlot) {
    try {
      // ... Timeline tracking code omitted for brevity ...
      final Element newChild = newWidget.createElement();   <<<<<<<<
      assert(() {
        _debugCheckForCycles(newChild);
        return true;
      }());
      newChild.mount(this, newSlot);                        <<<<<<<<
      assert(newChild._lifecycleState == _ElementLifecycle.active);
      return newChild;
    } finally {
      if (isTimelineTracked) {
        FlutterTimeline.finishSync();
      }
    }
  }

abstract class ComponentElement extends Element {

  @override
  void mount(Element? parent, Object? newSlot) {
    super.mount(parent, newSlot);
    assert(_child == null);
    assert(_lifecycleState == _ElementLifecycle.active);
    _firstBuild();                   <<<< which eventually calls build();
    assert(_child != null);
  }

  @override
  @pragma('vm:notify-debugger-on-exception')
  void performRebuild() {
    Widget? built;
    try {
      // ...
      built = build();               <<<< build() is called here
    } catch (e, stack) {
      // ...
    } finally {
      // We delay marking the element as clean until after calling build() so
      // that attempts to markNeedsBuild() during build() will be ignored.
      super.performRebuild(); // clears the "dirty" flag
    }
    try {
      _child = updateChild(_child, built, slot);   <<<< recursive call to `updateChild`
      assert(_child != null);
    } catch (e, stack) {
      // ...
    }
  }
}

abstract class RenderObjectElement extends Element {
  @override
  void mount(Element? parent, Object? newSlot) {
    super.mount(parent, newSlot);
    assert(() {
      _debugDoingBuild = true;
      return true;
    }());
    _renderObject = (widget as RenderObjectWidget).createRenderObject(this);   <<<<<< 创建render object
    assert(!_renderObject!.debugDisposed!);
    assert(() {
      _debugDoingBuild = false;
      return true;
    }());
    assert(() {
      _debugUpdateRenderObjectOwner();
      return true;
    }());
    assert(slot == newSlot);
    attachRenderObject(newSlot);    <<<<<< attach to parent render object, 构建render object tree
    super.performRebuild(); // clears the "dirty" flag
  }
}

class MultiChildRenderObjectElement extends Element {
  @override
  void mount(Element? parent, Object? newSlot) {
    super.mount(parent, newSlot);
    final MultiChildRenderObjectWidget multiChildRenderObjectWidget =
        widget as MultiChildRenderObjectWidget;

    // <<<<<<<< create children elements for each child widget
    final List<Element> children = List<Element>.filled(
      multiChildRenderObjectWidget.children.length,
      _NullElement.instance,
    );
    Element? previousChild;

    // iterate through each child widget to create corresponding element，inflateWidget is called here
    for (int i = 0; i < children.length; i += 1) {
      final Element newChild = inflateWidget(
        multiChildRenderObjectWidget.children[i],
        IndexedSlot<Element?>(i, previousChild),
      );
      children[i] = newChild;
      previousChild = newChild;
    }
    _children = children;
  }
}

abstract class RenderObjectElement extends Element {

  @override
  void mount(Element? parent, Object? newSlot) {
    super.mount(parent, newSlot);
    // ...
    _renderObject = (widget as RenderObjectWidget).createRenderObject(this);
    // ...
    attachRenderObject(newSlot);
    super.performRebuild(); // clears the "dirty" flag
  }


  @override
  void attachRenderObject(Object? newSlot) {
    /// insert renderObject to its ancestor renderObject
    _ancestorRenderObjectElement?.insertRenderObjectChild(renderObject, newSlot);

    /// retrieve the "ParentDataElements" which provides parentData information such as alignment, flex, etc.
    /// and further apply the parentData to the renderObject, which will be used during layout phase.
    final List<ParentDataElement<ParentData>> parentDataElements =
        _findAncestorParentDataElements();
    for (final ParentDataElement<ParentData> parentDataElement in parentDataElements) {
      _updateParentData(parentDataElement.widget as ParentDataWidget<ParentData>);
    }
  }
}

class MultiChildRenderObjectElement extends RenderObjectElement {
  @override
  void insertRenderObjectChild(RenderObject child, IndexedSlot<Element?> slot) {
    final ContainerRenderObjectMixin<RenderObject, ContainerParentDataMixin<RenderObject>>
    renderObject = this.renderObject;
    assert(renderObject.debugValidateChild(child));
    renderObject.insert(child, after: slot.value?.renderObject);
    assert(renderObject == this.renderObject);
  }
}

mixin ContainerRenderObjectMixin<
  ChildType extends RenderObject,
  ParentDataType extends ContainerParentDataMixin<ChildType>
> {
 void insert(ChildType child, {ChildType? after}) {
    // ...
    _insertIntoChildList(child, after: after);
  }
}

  /// Data for use by the parent render object.
  ///
  /// The parent data is used by the render object that lays out this object
  /// (typically this object's parent in the render tree) to store information
  /// relevant to itself and to any other nodes who happen to know exactly what
  /// the data means. The parent data is opaque to the child.
  ///
  ///  * The parent data field must not be directly set, except by calling
  ///    [setupParentData] on the parent node.
  ///  * The parent data can be set before the child is added to the parent, by
  ///    calling [setupParentData] on the future parent node.
  ///  * The conventions for using the parent data depend on the layout protocol
  ///    used between the parent and child. For example, in box layout, the
  ///    parent data is completely opaque but in sector layout the child is
  ///    permitted to read some fields of the parent data.
  ParentData? parentData;

  /// Override to setup parent data correctly for your children.
  ///
  /// You can call this function to set up the parent data for child before the
  /// child is added to the parent's child list.
  void setupParentData(covariant RenderObject child);

  void adoptChild(RenderObject child);
  void dropChild(RenderObject child);
  void visitChildren(RenderObjectVisitor visitor);

  /// Adds the given child to the end of the child list.
  ///
  /// The child's [parentData] must have been set up correctly beforehand by
  /// calling [setupParentData].
  void add(RenderBox child) {
    insert(child, after: _lastChild);
  }

  /// Removes the given child from the child list.
  void remove(RenderBox child) {
    final BoxParentData childParentData = child.parentData! as BoxParentData;
    assert(childParentData.previousSibling != null || childParentData.nextSibling != null || _firstChild == child);
    _removeFromChildList(child);
    childParentData.previousSibling = null;
    childParentData.nextSibling = null;
  }

  /// The pipeline owner for this render box.
  ///
  /// The pipeline owner manages the rendering pipeline, including layout,
  /// painting, and compositing.
  PipelineOwner get owner => _owner!;
  PipelineOwner? _owner;

  /// Mark this render object as attached to the given owner.
  ///
  /// Typically called only from the [parent]'s [attach] method, and by the
  /// [owner] to mark the root of a tree as attached.
  ///
  /// Subclasses with children should override this method to
  /// [attach] all their children to the same [owner]
  /// after calling the inherited method, as in `super.attach(owner)`.
  void attach(PipelineOwner owner);

  /// Mark this render object as detached from its [PipelineOwner].
  ///
  /// Typically called only from the [parent]'s [detach], and by the [owner] to
  /// mark the root of a tree as detached.
  ///
  /// Subclasses with children should override this method to
  /// [detach] all their children after calling the inherited method,
  /// as in `super.detach()`.
  void detach();

 Constraints? _constraints;


  /// Whether this [RenderObject] is a known relayout boundary.
  ///
  /// A relayout boundary is a [RenderObject] whose parent does not rely on the
  /// child [RenderObject]'s size in its own layout algorithm. In other words,
  /// if a [RenderObject]'s [performLayout] implementation does not ask the child
  /// for its size at all, **the child** is a relayout boundary.
  ///
  /// which affects how layout invalidation is propagated through the render tree.
  bool? _isRelayoutBoundary;


  /// Mark this render object's layout information as dirty, and either register
  /// this object with its [PipelineOwner], or defer to the parent, depending on
  /// whether this object is a relayout boundary or not respectively.
  ///
  void markNeedsLayout();

  /// Whether this render object repaints separately from its parent.
  ///
  /// Override this in subclasses to indicate that instances of your class ought
  /// to repaint independently. For example, render objects that repaint
  /// frequently might want to repaint themselves without requiring their parent
  /// to repaint.
  ///
  /// See [RepaintBoundary] for more information about how repaint boundaries function.
  bool get isRepaintBoundary => false;

  final LayerHandle<ContainerLayer> _layerHandle = LayerHandle<ContainerLayer>();

  /// Mark this render object as having changed its visual appearance.
  ///
  /// See also:
  ///
  ///  * [RepaintBoundary], to scope a subtree of render objects to their own
  ///    layer, thus limiting the number of nodes that [markNeedsPaint] must mark
  ///    dirty.
  void markNeedsPaint()

  /// Paint this render object into the given context at the given offset.
  ///
  /// Subclasses should override this method to provide a visual appearance
  /// for themselves. The render object's local coordinate system is
  /// axis-aligned with the coordinate system of the context's canvas and the
  /// render object's local origin (i.e, x=0 and y=0) is placed at the given
  /// offset in the context's canvas.
  ///
  /// Do not call this function directly. If you wish to paint yourself, call
  /// [markNeedsPaint] instead to schedule a call to this function. If you wish
  /// to paint one of your children, call [PaintingContext.paintChild] on the
  /// given `context`.
  ///
  /// When painting one of your children (via a paint child function on the
  /// given context), the current canvas held by the context might change
  /// because draw operations before and after painting children might need to
  /// be recorded on separate compositing layers.
  void paint(PaintingContext context, Offset offset);

  /// An estimate of the bounds within which this render object will paint.
  /// Useful for debugging flags such as [debugPaintLayerBordersEnabled].
  ///
  /// These are also the bounds used by [showOnScreen] to make a [RenderObject]
  /// visible on screen.
  Rect get paintBounds;

  /// Override this method to implement hit testing for your render object.
  ///
  /// The default implementation does nothing and returns false.
  ///
  /// The given position is in the local coordinate system of this render
  /// object (i.e. with the origin at the top left of this render object).
  ///
  /// If this render object hits at the given position, it should add itself
  /// to the given [HitTestResult], and then typically it should also
  /// hit test its children by calling their [hitTest] methods.
  ///
  /// Returns true if the hit test was successful (i.e. if this render object
  /// or one of its descendants added itself to the [HitTestResult]).
  bool hitTest(HitTestResult result, {required Offset position});

  void _handlePersistentFrameCallback(Duration timeStamp) {
    drawFrame();
    _scheduleMouseTrackerUpdate();
  }

enum SchedulerPhase {
  /// No frame is being processed. Tasks (scheduled by
  /// [SchedulerBinding.scheduleTask]), microtasks (scheduled by
  /// [scheduleMicrotask]), [Timer] callbacks, event handlers (e.g. from user
  /// input), and other callbacks (e.g. from [Future]s, [Stream]s, and the like)
  /// may be executing.
  idle,

  /// The transient callbacks (scheduled by
  /// [SchedulerBinding.scheduleFrameCallback]) are currently executing.
  ///
  /// Typically, these callbacks handle updating objects to new animation
  /// states.
  ///
  /// See [SchedulerBinding.handleBeginFrame].
  transientCallbacks,

  /// Microtasks scheduled during the processing of transient callbacks are
  /// current executing.
  ///
  /// This may include, for instance, callbacks from futures resolved during the
  /// [transientCallbacks] phase.
  midFrameMicrotasks,

  /// The persistent callbacks (scheduled by
  /// [SchedulerBinding.addPersistentFrameCallback]) are currently executing.
  ///
  /// Typically, this is the build/layout/paint pipeline. See
  /// [WidgetsBinding.drawFrame] and [SchedulerBinding.handleDrawFrame].
  persistentCallbacks,

  /// The post-frame callbacks (scheduled by
  /// [SchedulerBinding.addPostFrameCallback]) are currently executing.
  ///
  /// Typically, these callbacks handle cleanup and scheduling of work for the
  /// next frame.
  ///
  /// See [SchedulerBinding.handleDrawFrame].
  postFrameCallbacks,
}

mixin SchedulerBinding on BindingBase {
  @protected
  void ensureFrameCallbacksRegistered() {
    platformDispatcher.onBeginFrame ??= _handleBeginFrame;
    platformDispatcher.onDrawFrame ??= _handleDrawFrame;
  }
}

// Ticker 注册瞬态回调
class Ticker {
  void scheduleTick({bool rescheduling = false}) {
    _animationId = SchedulerBinding.instance.scheduleFrameCallback(
      _tick,  // ← 这个回调在 handleBeginFrame 中执行
      rescheduling: rescheduling,
    );
  }

  void _tick(Duration elapsed) {
    // 更新动画值
    _onTick?.call(elapsed);
    // 继续下一帧
    scheduleTick(rescheduling: true);
  }
}

// AnimationController 使用 Ticker
class AnimationController {
  void _tick(Duration elapsed) {
    // 计算动画进度
    _value = lerpDouble(_lowerBound, _upperBound, progress);
    // 通知监听器
    notifyListeners();
  }
}

mixin RendererBinding on SchedulerBinding {
  @protected
  void drawFrame() {
    rootPipelineOwner.flushLayout();
    rootPipelineOwner.flushCompositingBits();
    rootPipelineOwner.flushPaint();
    if (sendFramesToEngine) {
      for (final RenderView renderView in renderViews) {
        renderView.compositeFrame(); // this sends the bits to the GPU
      }
      rootPipelineOwner.flushSemantics(); // this sends the semantics to the OS.
      _firstFrameSent = true;
    }
  }
}