自学教程：C++ toShadowRoot函数代码示例

EventPath::EventPath(Node& targetNode, Event& event){    bool inDocument = targetNode.inDocument();    bool isSVGElement = targetNode.isSVGElement();    bool isMouseOrFocusEvent = event.isMouseEvent() || event.isFocusEvent();#if ENABLE(TOUCH_EVENTS)    bool isTouchEvent = event.isTouchEvent();#endif    EventTarget* target = 0;    Node* node = nodeOrHostIfPseudoElement(&targetNode);    while (node) {        if (!target || !isSVGElement) // FIXME: This code doesn't make sense once we've climbed out of the SVG subtree in a HTML document.            target = &eventTargetRespectingTargetRules(*node);        for (; node; node = node->parentNode()) {            EventTarget& currentTarget = eventTargetRespectingTargetRules(*node);            if (isMouseOrFocusEvent)                m_path.append(std::make_unique<MouseOrFocusEventContext>(node, &currentTarget, target));#if ENABLE(TOUCH_EVENTS)            else if (isTouchEvent)                m_path.append(std::make_unique<TouchEventContext>(node, &currentTarget, target));#endif            else                m_path.append(std::make_unique<EventContext>(node, &currentTarget, target));            if (!inDocument)                return;            if (node->isShadowRoot())                break;        }        if (!node || !shouldEventCrossShadowBoundary(event, *toShadowRoot(node), *target))            return;        node = toShadowRoot(node)->hostElement();    }}

inline void TreeScopeAdopter::moveNodeToNewDocument(    Node& node,    Document& oldDocument,    Document& newDocument) const {  DCHECK_NE(oldDocument, newDocument);  if (node.hasRareData()) {    NodeRareData* rareData = node.rareData();    if (rareData->nodeLists())      rareData->nodeLists()->adoptDocument(oldDocument, newDocument);  }  oldDocument.moveNodeIteratorsToNewDocument(node, newDocument);  if (node.getCustomElementState() == CustomElementState::Custom) {    Element& element = toElement(node);    CustomElement::enqueueAdoptedCallback(&element, &oldDocument, &newDocument);  }  if (node.isShadowRoot())    toShadowRoot(node).setDocument(newDocument);#if DCHECK_IS_ON()  didMoveToNewDocumentWasCalled = false;  oldDocumentDidMoveToNewDocumentWasCalledWith = &oldDocument;#endif  node.didMoveToNewDocument(oldDocument);#if DCHECK_IS_ON()  DCHECK(didMoveToNewDocumentWasCalled);#endif}

static ContainerNode* traverseParent(const Node* node, ShadowRootCrossing shadowRootCrossing){    if (node->isPseudoElement())        return toPseudoElement(node)->hostElement();    if (shadowRootCrossing == DontCrossShadowRoot  && node->isShadowRoot())        return 0;    if (nodeCanBeDistributed(node)) {        if (InsertionPoint* insertionPoint = findInsertionPointOf(node))            return traverseParent(insertionPoint, shadowRootCrossing);        return nullptr;    }    ContainerNode* parent = node->parentNode();    if (!parent)        return nullptr;    if (parent->isShadowRoot())        return shadowRootCrossing == CrossShadowRoot ? toShadowRoot(parent)->hostElement() : parent;    if (parent->isInsertionPoint()) {        const InsertionPoint* insertionPoint = toInsertionPoint(parent);        if (insertionPoint->hasDistribution())            return nullptr;        if (insertionPoint->isActive())            return traverseParent(parent, shadowRootCrossing);    }    return parent;}

void EventRetargeter::calculateEventPath(Node* targetNode, Event* event, EventPath& eventPath){    bool inDocument = targetNode->inDocument();    bool isSVGElement = targetNode->isSVGElement();    bool isMouseOrFocusEvent = event->isMouseEvent() || event->isFocusEvent();#if ENABLE(TOUCH_EVENTS)    bool isTouchEvent = event->isTouchEvent();#endif    Vector<EventTarget*, 32> targetStack;    for (Node* node = nodeOrHostIfPseudoElement(targetNode); node; node = node->parentOrShadowHostNode()) {        if (targetStack.isEmpty())            targetStack.append(eventTargetRespectingTargetRules(node));        if (isMouseOrFocusEvent)            eventPath.append(adoptPtr(new MouseOrFocusEventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));#if ENABLE(TOUCH_EVENTS)        else if (isTouchEvent)            eventPath.append(adoptPtr(new TouchEventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));#endif        else            eventPath.append(adoptPtr(new EventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));        if (!inDocument)            return;        if (!node->isShadowRoot())            continue;        if (determineDispatchBehavior(event, toShadowRoot(node), targetStack.last()) == StayInsideShadowDOM)            return;        if (!isSVGElement) {            ASSERT(!targetStack.isEmpty());            targetStack.removeLast();        }    }}

void EventRetargeter::calculateEventPath(Node* node, Event* event){    EventPath& eventPath = event->eventPath();    eventPath.clear();    bool inDocument = node->inDocument();    bool isSVGElement = node->isSVGElement();    bool isMouseOrFocusEvent = event->isMouseEvent() || event->isFocusEvent();    bool isTouchEvent = event->isTouchEvent();    Vector<EventTarget*, 32> targetStack;    for (EventPathWalker walker(node); walker.node(); walker.moveToParent()) {        Node* node = walker.node();        if (targetStack.isEmpty())            targetStack.append(eventTargetRespectingTargetRules(node));        else if (walker.isVisitingInsertionPointInReprojection())            targetStack.append(targetStack.last());        if (isMouseOrFocusEvent)            eventPath.append(adoptPtr(new MouseOrFocusEventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));        else if (isTouchEvent)            eventPath.append(adoptPtr(new TouchEventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));        else            eventPath.append(adoptPtr(new EventContext(node, eventTargetRespectingTargetRules(node), targetStack.last())));        if (!inDocument)            return;        if (!node->isShadowRoot())            continue;        if (determineDispatchBehavior(event, toShadowRoot(node), targetStack.last()) == StayInsideShadowDOM)            return;        if (!isSVGElement) {            ASSERT(!targetStack.isEmpty());            targetStack.removeLast();        }    }}

inline EventTarget& eventTargetRespectingTargetRules(Node& referenceNode){    if (referenceNode.isPseudoElement()) {        EventTarget* hostElement = toPseudoElement(referenceNode).hostElement();        ASSERT(hostElement);        return *hostElement;    }#if ENABLE(SVG)    if (!referenceNode.isSVGElement() || !referenceNode.isInShadowTree())        return referenceNode;    // Spec: The event handling for the non-exposed tree works as if the referenced element had been textually included    // as a deeply cloned child of the 'use' element, except that events are dispatched to the SVGElementInstance objects    Node* rootNode = referenceNode.treeScope().rootNode();    Element* shadowHostElement = rootNode->isShadowRoot() ? toShadowRoot(rootNode)->hostElement() : 0;    // At this time, SVG nodes are not supported in non-<use> shadow trees.    if (!shadowHostElement || !shadowHostElement->hasTagName(SVGNames::useTag))        return referenceNode;    SVGUseElement* useElement = toSVGUseElement(shadowHostElement);    if (SVGElementInstance* instance = useElement->instanceForShadowTreeElement(&referenceNode))        return *instance;#endif    return referenceNode;}

void AncestorChainWalker::parent(){    ASSERT(m_node);    ASSERT(m_distributedNode);    if (ElementShadow* shadow = shadowOfParent(m_node)) {        if (InsertionPoint* insertionPoint = shadow->insertionPointFor(m_distributedNode)) {            m_node = insertionPoint;            m_isCrossingInsertionPoint = true;            return;        }    }    if (!m_node->isShadowRoot()) {        m_node = m_node->parentNode();        m_distributedNode = m_node;        m_isCrossingInsertionPoint = false;        return;    }    const ShadowRoot* shadowRoot = toShadowRoot(m_node);    if (InsertionPoint* insertionPoint = shadowRoot->assignedTo()) {        m_node = insertionPoint;        m_isCrossingInsertionPoint = true;        return;    }    m_node = shadowRoot->host();    m_distributedNode = m_node;    m_isCrossingInsertionPoint = false;}

// TODO(hayato): This may return a wrong result for a node which is not in a// document flat tree.  See FlatTreeTraversalTest's redistribution test for details.Node* FlatTreeTraversal::traverseSiblings(const Node& node, TraversalDirection direction){    if (node.isChildOfV1ShadowHost())        return traverseSiblingsForV1HostChild(node, direction);    if (shadowWhereNodeCanBeDistributed(node))        return traverseSiblingsForV0Distribution(node, direction);    if (Node* found = resolveDistributionStartingAt(direction == TraversalDirectionForward ? node.nextSibling() : node.previousSibling(), direction))        return found;    if (!node.isInV0ShadowTree())        return nullptr;    // For v0 older shadow tree    if (node.parentNode() && node.parentNode()->isShadowRoot()) {        ShadowRoot* parentShadowRoot = toShadowRoot(node.parentNode());        if (!parentShadowRoot->isYoungest()) {            HTMLShadowElement* assignedInsertionPoint = parentShadowRoot->shadowInsertionPointOfYoungerShadowRoot();            DCHECK(assignedInsertionPoint);            return traverseSiblings(*assignedInsertionPoint, direction);        }    }    return nullptr;}

TreeScope* TreeScope::olderShadowRootOrParentTreeScope() const{    if (rootNode().isShadowRoot()) {        if (ShadowRoot* olderShadowRoot = toShadowRoot(rootNode()).olderShadowRoot())            return olderShadowRoot;    }    return parentTreeScope();}

void EventPath::calculatePath(){    ASSERT(m_node);    ASSERT(m_nodeEventContexts.isEmpty());    m_node->updateDistribution();    // For performance and memory usage reasons we want to store the    // path using as few bytes as possible and with as few allocations    // as possible which is why we gather the data on the stack before    // storing it in a perfectly sized m_nodeEventContexts Vector.    WillBeHeapVector<RawPtrWillBeMember<Node>, 64> nodesInPath;    Node* current = m_node;    nodesInPath.append(current);    while (current) {        if (m_event && current->keepEventInNode(m_event))            break;        WillBeHeapVector<RawPtrWillBeMember<InsertionPoint>, 8> insertionPoints;        collectDestinationInsertionPoints(*current, insertionPoints);        if (!insertionPoints.isEmpty()) {            for (const auto& insertionPoint : insertionPoints) {                if (insertionPoint->isShadowInsertionPoint()) {                    ShadowRoot* containingShadowRoot = insertionPoint->containingShadowRoot();                    ASSERT(containingShadowRoot);                    if (!containingShadowRoot->isOldest())                        nodesInPath.append(containingShadowRoot->olderShadowRoot());                }                nodesInPath.append(insertionPoint);            }            current = insertionPoints.last();            continue;        }        if (current->isShadowRoot()) {            if (m_event && shouldStopAtShadowRoot(*m_event, *toShadowRoot(current), *m_node))                break;            current = current->shadowHost();#if !ENABLE(OILPAN)            // TODO(kochi): crbug.com/507413 This check is necessary when some asynchronous event            // is queued while its shadow host is removed and the shadow root gets the event            // immediately after it.  When Oilpan is enabled, this situation does not happen.            // Except this case, shadow root's host is assumed to be non-null.            if (current)                nodesInPath.append(current);#else            nodesInPath.append(current);#endif        } else {            current = current->parentNode();            if (current)                nodesInPath.append(current);        }    }    m_nodeEventContexts.reserveCapacity(nodesInPath.size());    for (Node* nodeInPath : nodesInPath) {        m_nodeEventContexts.append(NodeEventContext(nodeInPath, eventTargetRespectingTargetRules(*nodeInPath)));    }}

Element* FocusNavigationScope::owner() const{    Node* root = rootNode();    if (root->isShadowRoot()) {        ShadowRoot* shadowRoot = toShadowRoot(root);        return shadowRoot->host();    }    return 0;}

TreeScopeStyleSheetCollection* StyleEngine::ensureStyleSheetCollectionFor(TreeScope& treeScope){    if (treeScope == m_document)        return documentStyleSheetCollection();    StyleSheetCollectionMap::AddResult result = m_styleSheetCollectionMap.add(&treeScope, nullptr);    if (result.isNewEntry)        result.storedValue->value = adoptPtr(new ShadowTreeStyleSheetCollection(toShadowRoot(treeScope)));    return result.storedValue->value.get();}

int TreeScopeEventContext::calculateTreeOrderAndSetNearestAncestorClosedTree(int orderNumber, TreeScopeEventContext* nearestAncestorClosedTreeScopeEventContext){    m_preOrder = orderNumber;    m_containingClosedShadowTree = (rootNode().isShadowRoot() && !toShadowRoot(rootNode()).isOpenOrV0()) ? this : nearestAncestorClosedTreeScopeEventContext;    for (size_t i = 0; i < m_children.size(); ++i)        orderNumber = m_children[i]->calculateTreeOrderAndSetNearestAncestorClosedTree(orderNumber + 1, containingClosedShadowTree());    m_postOrder = orderNumber + 1;    return orderNumber + 1;}

ShadowRoot* InsertionPoint::assignedFrom() const{    Node* treeScopeRoot = treeScope()->rootNode();    if (!treeScopeRoot->isShadowRoot())        return 0;    ShadowRoot* olderShadowRoot = toShadowRoot(treeScopeRoot)->olderShadowRoot();    if (olderShadowRoot && olderShadowRoot->assignedTo() == this)        return olderShadowRoot;    return 0;}

inline Node* ComposedTreeWalker::traverseParentOrHost(const Node* node) const{    Node* parent = node->parentNode();    if (!parent)        return 0;    if (!parent->isShadowRoot())        return parent;    ShadowRoot* shadowRoot = toShadowRoot(parent);    ASSERT(!shadowRoot->shadowInsertionPointOfYoungerShadowRoot());    if (!shadowRoot->isYoungest())        return 0;    return shadowRoot->host();}

Node* ComposedShadowTreeWalker::traverseBackToYoungerShadowRoot(const Node* node, TraversalDirection direction){    ASSERT(node);    if (node->parentNode() && node->parentNode()->isShadowRoot()) {        ShadowRoot* parentShadowRoot = toShadowRoot(node->parentNode());        if (!parentShadowRoot->isYoungest()) {            InsertionPoint* assignedInsertionPoint = parentShadowRoot->insertionPoint();            ASSERT(assignedInsertionPoint);            return traverseSiblingInCurrentTree(assignedInsertionPoint, direction);        }    }    return 0;}

ContainerNode* FlatTreeTraversal::traverseParentOrHost(const Node& node){    ContainerNode* parent = node.parentNode();    if (!parent)        return nullptr;    if (!parent->isShadowRoot())        return parent;    ShadowRoot* shadowRoot = toShadowRoot(parent);    DCHECK(!shadowRoot->shadowInsertionPointOfYoungerShadowRoot());    if (!shadowRoot->isYoungest())        return nullptr;    return &shadowRoot->host();}

inline void TreeScopeAdopter::moveNodeToNewDocument(Node& node, Document& oldDocument, Document& newDocument) const{    ASSERT(oldDocument != newDocument);    if (node.isShadowRoot())        toShadowRoot(node).setDocument(newDocument);#if ENABLE(ASSERT)    didMoveToNewDocumentWasCalled = false;    oldDocumentDidMoveToNewDocumentWasCalledWith = &oldDocument;#endif    node.didMoveToNewDocument(oldDocument);    ASSERT(didMoveToNewDocumentWasCalled);}