abstract class RenderObject extends AbstractNode with DiagnosticableTreeMixin implements HitTestTarget {

abstract class RenderObjectElement extends Element {  
  @protected
  void insertRenderObjectChild(covariant RenderObject child, covariant dynamic slot) {
    insertChildRenderObject(child, slot);
  }
}

class SingleChildRenderObjectElement extends RenderObjectElement {
  @override
  SingleChildRenderObjectWidget get widget => super.widget as SingleChildRenderObjectWidget;
  
  ...
    
	@override
  void insertRenderObjectChild(RenderObject child, dynamic slot) {
    final RenderObjectWithChildMixin<RenderObject> renderObject = this.renderObject as RenderObjectWithChildMixin<RenderObject>;
    renderObject.child = child;
  }
}

mixin RenderObjectWithChildMixin<ChildType extends RenderObject> on RenderObject {
	set child(ChildType? value) {
    if (_child != null)
      // 卸载老节点
      dropChild(_child!);
    // 更新子节点引用
    _child = value;
    if (_child != null)
      // 挂载新节点
      adoptChild(_child!);
  }
}
abstract class RenderObject extends AbstractNode with DiagnosticableTreeMixin implements HitTestTarget {
  @override
  void adoptChild(RenderObject child) {
    // 初始化 ParentData
    setupParentData(child);
    // Layout标脏
    markNeedsLayout();
    // 合成位标脏
    markNeedsCompositingBitsUpdate();
    // 辅助信息Semantic标脏
    markNeedsSemanticsUpdate();
    // 调用AbstractNode.adoptChild()，挂载到 Render Tree，将child.parent指向自己，更新树的深度
    super.adoptChild(child);
  }
}

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

mixin ContainerRenderObjectMixin<ChildType extends RenderObject, ParentDataType extends ContainerParentDataMixin<ChildType>> on RenderObject {
	void insert(ChildType child, { ChildType? after }) {
    adoptChild(child);
    _insertIntoChildList(child, after: after);
  }
  ...
  void _insertIntoChildList(ChildType child, { ChildType? after }) {
    final ParentDataType childParentData = child.parentData as ParentDataType;
    _childCount += 1;
    if (after == null) {
      // 依附的兄弟节点为空，插入在第一个子节点
      childParentData.nextSibling = _firstChild;
      if (_firstChild != null) {
        final ParentDataType _firstChildParentData = _firstChild!.parentData as ParentDataType;
        _firstChildParentData.previousSibling = child;
      }
      _firstChild = child;
      _lastChild ??= child;
    } else {
      final ParentDataType afterParentData = after.parentData as ParentDataType;
      if (afterParentData.nextSibling == null) {
        // 依附的兄弟节点没有相关联的下一个兄弟节点，插入在兄弟节点队尾
        childParentData.previousSibling = after;
        afterParentData.nextSibling = child;
        _lastChild = child;
      } else {
        // 依附的兄弟节点有相关联的下一个兄弟节点，插入在兄弟节点中间
        childParentData.nextSibling = afterParentData.nextSibling;
        childParentData.previousSibling = after;
        // set up links from siblings to child
        final ParentDataType childPreviousSiblingParentData = childParentData.previousSibling!.parentData as ParentDataType;
        final ParentDataType childNextSiblingParentData = childParentData.nextSibling!.parentData as ParentDataType;
        childPreviousSiblingParentData.nextSibling = child;
        childNextSiblingParentData.previousSibling = child;
      }
    }
  }
	...
}

abstract class RenderObject extends AbstractNode with DiagnosticableTreeMixin implements HitTestTarget {  
	void markNeedsLayout() {
    // 如果已经标脏，避免重复标脏
    if (_needsLayout) {
      return;
    }
    if (_relayoutBoundary != this) {
      // 如果 _relayoutBoundary 布局边界不是本节点，那么向上遍历
      markParentNeedsLayout();
    } else {
      // 如果 _relayoutBoundary 布局边界是自本节点，将本节点加入 owner._nodesNeedingLayout 列表，等待 layout 流程处理
      _needsLayout = true;
      if (owner != null) {
        owner!._nodesNeedingLayout.add(this);
        owner!.requestVisualUpdate();
      }
    }
  }
  
  @protected
  void markParentNeedsLayout() {
    ...
    _needsLayout = true;
    final RenderObject parent = this.parent! as RenderObject;
    parent.markNeedsLayout();
    ...
  }
}

// lib/src/rendering/binding.dart
	@protected
  void drawFrame() {
    assert(renderView != null);
    pipelineOwner.flushLayout();
    pipelineOwner.flushCompositingBits();
    pipelineOwner.flushPaint();
    if (sendFramesToEngine) {
      renderView.compositeFrame(); // this sends the bits to the GPU
      pipelineOwner.flushSemantics(); // this also sends the semantics to the OS.
      _firstFrameSent = true;
    }
  }

// lib/src/rendering/binding.dart
  void flushLayout() {
    if (!kReleaseMode) {
      //记录Layout过程
      Timeline.startSync('Layout', arguments: timelineArgumentsIndicatingLandmarkEvent);
    }
    try {
      while (_nodesNeedingLayout.isNotEmpty) {
        final List<RenderObject> dirtyNodes = _nodesNeedingLayout;
        _nodesNeedingLayout = <RenderObject>[];
        //广度优先
        for (final RenderObject node in dirtyNodes..sort((RenderObject a, RenderObject b) => a.depth - b.depth)) {
          if (node._needsLayout && node.owner == this)
            node._layoutWithoutResize();
        }
      }
    } finally {
      ...
      if (!kReleaseMode) {
        //结束 Layout 过程记录
        Timeline.finishSync();
      }
    }
  }

// lib/src/rendering/object.dart
  void _layoutWithoutResize() {
    // 只有 _relayoutBoundary 节点才会被加入脏列表
    assert(_relayoutBoundary == this);
		...
    try {
      //具体的布局操作
      performLayout();
      // 辅助信息标脏
      markNeedsSemanticsUpdate();
    }
    ...
    _needsLayout = false;
    //_needsPaint标脏，并记录在_nodesNeedingPaint列表中
    markNeedsPaint();
  }

// lib/src/rendering/view.dart
	@override
  void performLayout() {
    _size = configuration.size;
    if (child != null)
      child.layout(BoxConstraints.tight(_size));
  }

void layout(Constraints constraints, { bool parentUsesSize = false }) {
  RenderObject? relayoutBoundary;
  if (!parentUsesSize || sizedByParent || constraints.isTight || parent is! RenderObject) {
    relayoutBoundary = this;
  } else {
    relayoutBoundary = (parent as RenderObject)._relayoutBoundary;
  }
  if (!_needsLayout && constraints == _constraints && relayoutBoundary == _relayoutBoundary) {
    // 不需要重新布局，直接返回
    return;
  }
  _constraints = constraints;
  if (_relayoutBoundary != null && relayoutBoundary != _relayoutBoundary) {
    // _relayoutBoundary 边界改变，清理所有子节点的边界信息
    visitChildren(_cleanChildRelayoutBoundary);
  }
  _relayoutBoundary = relayoutBoundary;
  if (sizedByParent) {
    ...
    // 依赖父节点传递的约束信息，测量布局大小Size，sizedByParent为true的子节点，需要重写	performResize()
    performResize();
  }
  RenderObject? debugPreviousActiveLayout;
  try {
    // 触发布局
    performLayout();
    markNeedsSemanticsUpdate();
  } catch (e, stack) {
    _debugReportException('performLayout', e, stack);
  }
// 清楚标记
  _needsLayout = false;
  // 绘制标脏
  markNeedsPaint();
}