webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 0 insertions, 310 deletions

diff --git a/Source/WebCore/dom/NodeRenderingTraversal.cpp b/Source/WebCore/dom/NodeRenderingTraversal.cpp
deleted file mode 100644
index d94d7be73..000000000
--- a/Source/WebCore/dom/NodeRenderingTraversal.cpp
+++ /dev/null
@@ -1,310 +0,0 @@
-/*
- * Copyright (C) 2012 Google Inc. All rights reserved.
- * Copyright (C) 2013 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include "NodeRenderingTraversal.h"
-
-#include "InsertionPoint.h"
-#include "PseudoElement.h"
-#include "ShadowRoot.h"
-
-namespace WebCore {
-
-namespace NodeRenderingTraversal {
-
-static Node* findFirstSiblingEnteringInsertionPoints(const Node*);
-static Node* findFirstEnteringInsertionPoints(const Node*);
-static Node* findFirstFromDistributedNode(const Node*, const InsertionPoint*);
-static Node* findLastSiblingEnteringInsertionPoints(const Node*);
-static Node* findLastEnteringInsertionPoints(const Node*);
-static Node* findLastFromDistributedNode(const Node*, const InsertionPoint*);
-
-static inline bool nodeCanBeDistributed(const Node* node)
-{
-    ASSERT(node);
-    Node* parent = parentNodeForDistribution(node);
-    if (!parent)
-        return false;
-
-    if (parent->isShadowRoot())
-        return false;
-
-    if (parent->isElementNode() && toElement(parent)->shadowRoot())
-        return true;
-    
-    return false;
-}
-
-static Node* findFirstSiblingEnteringInsertionPoints(const Node* node)
-{
-    for (const Node* sibling = node; sibling; sibling = sibling->nextSibling()) {
-        if (Node* found = findFirstEnteringInsertionPoints(sibling))
-            return found;
-    }
-    return nullptr;
-}
-
-static Node* findFirstEnteringInsertionPoints(const Node* node)
-{
-    ASSERT(node);
-    if (!isActiveInsertionPoint(node))
-        return const_cast<Node*>(node);
-    const InsertionPoint* insertionPoint = toInsertionPoint(node);
-    if (Node* found = findFirstFromDistributedNode(insertionPoint->firstDistributed(), insertionPoint))
-        return found;
-    return findFirstSiblingEnteringInsertionPoints(node->firstChild());
-}
-
-static Node* findFirstFromDistributedNode(const Node* node, const InsertionPoint* insertionPoint)
-{
-    for (const Node* next = node; next; next = insertionPoint->nextDistributedTo(next)) {
-        if (Node* found = findFirstEnteringInsertionPoints(next))
-            return found;
-    }
-    return nullptr;
-}
-
-static Node* findLastSiblingEnteringInsertionPoints(const Node* node)
-{
-    for (const Node* sibling = node; sibling; sibling = sibling->previousSibling()) {
-        if (Node* found = findLastEnteringInsertionPoints(sibling))
-            return found;
-    }
-    return nullptr;
-}
-
-static Node* findLastEnteringInsertionPoints(const Node* node)
-{
-    ASSERT(node);
-    if (!isActiveInsertionPoint(node))
-        return const_cast<Node*>(node);
-    const InsertionPoint* insertionPoint = toInsertionPoint(node);
-    if (Node* found = findLastFromDistributedNode(insertionPoint->lastDistributed(), insertionPoint))
-        return found;
-    return findLastSiblingEnteringInsertionPoints(node->lastChild());
-}
-
-static Node* findLastFromDistributedNode(const Node* node, const InsertionPoint* insertionPoint)
-{
-    for (const Node* next = node; next; next = insertionPoint->previousDistributedTo(next)) {
-        if (Node* found = findLastEnteringInsertionPoints(next))
-            return found;
-    }
-    return nullptr;
-}
-
-enum ShadowRootCrossing { CrossShadowRoot, DontCrossShadowRoot };
-
-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;
-}
-
-static Node* traverseFirstChild(const Node* node, ShadowRootCrossing shadowRootCrossing)
-{
-    ASSERT(node);
-    if (node->shadowRoot()) {
-        if (shadowRootCrossing == DontCrossShadowRoot)
-            return nullptr;
-        node = node->shadowRoot();
-    }
-    return findFirstSiblingEnteringInsertionPoints(node->firstChild());
-}
-
-static Node* traverseLastChild(const Node* node, ShadowRootCrossing shadowRootCrossing)
-{
-    ASSERT(node);
-    if (node->shadowRoot()) {
-        if (shadowRootCrossing == DontCrossShadowRoot)
-            return nullptr;
-        node = node->shadowRoot();
-    }
-    return findLastSiblingEnteringInsertionPoints(node->lastChild());
-}
-
-static Node* traverseNextSibling(const Node* node)
-{
-    ASSERT(node);
-
-    InsertionPoint* insertionPoint;
-    if (nodeCanBeDistributed(node) && (insertionPoint = findInsertionPointOf(node))) {
-        Node* found = findFirstFromDistributedNode(insertionPoint->nextDistributedTo(node), insertionPoint);
-        if (found)
-            return found;
-        return traverseNextSibling(insertionPoint);
-    }
-
-    for (const Node* sibling = node->nextSibling(); sibling; sibling = sibling->nextSibling()) {
-        if (Node* found = findFirstEnteringInsertionPoints(sibling))
-            return found;
-    }
-    if (node->parentNode() && isActiveInsertionPoint(node->parentNode()))
-        return traverseNextSibling(node->parentNode());
-
-    return nullptr;
-}
-
-static Node* traversePreviousSibling(const Node* node)
-{
-    ASSERT(node);
-
-    InsertionPoint* insertionPoint;
-    if (nodeCanBeDistributed(node) && (insertionPoint = findInsertionPointOf(node))) {
-        Node* found = findLastFromDistributedNode(insertionPoint->previousDistributedTo(node), insertionPoint);
-        if (found)
-            return found;
-        return traversePreviousSibling(insertionPoint);
-    }
-
-    for (const Node* sibling = node->previousSibling(); sibling; sibling = sibling->previousSibling()) {
-        if (Node* found = findLastEnteringInsertionPoints(sibling))
-            return found;
-    }
-    if (node->parentNode() && isActiveInsertionPoint(node->parentNode()))
-        return traversePreviousSibling(node->parentNode());
-
-    return nullptr;
-}
-
-ContainerNode* parentSlow(const Node* node)
-{
-    ASSERT(!node->isShadowRoot());
-
-    return traverseParent(node, CrossShadowRoot);
-}
-
-Node* nextSiblingSlow(const Node* node)
-{
-    ASSERT(!node->isShadowRoot());
-
-    // FIXME: Why do these functions deal with before/after when other code here doesn't?
-    Node* nextSibling = 0;
-    if (node->isBeforePseudoElement()) {
-        nextSibling = traverseParent(node, CrossShadowRoot);
-        nextSibling = traverseFirstChild(nextSibling, CrossShadowRoot);
-    } else
-        nextSibling = traverseNextSibling(node);
-
-    if (nextSibling || node->isAfterPseudoElement())
-        return nextSibling;
-
-    Node* parent = traverseParent(node, CrossShadowRoot);
-    if (parent && parent->isElementNode())
-        return toElement(parent)->afterPseudoElement();
-
-    return 0;
-}
-
-Node* previousSiblingSlow(const Node* node)
-{
-    ASSERT(!node->isShadowRoot());
-
-    Node* previousSibling = 0;
-    if (node->isAfterPseudoElement()) {
-        ContainerNode* parent = traverseParent(node, CrossShadowRoot);
-        previousSibling = traverseLastChild(parent, CrossShadowRoot);
-    } else
-        previousSibling = traversePreviousSibling(node);
-
-    if (previousSibling || node->isBeforePseudoElement())
-        return previousSibling;
-
-    ContainerNode* parent = traverseParent(node, CrossShadowRoot);
-    if (parent && parent->isElementNode())
-        return toElement(parent)->beforePseudoElement();
-
-    return 0;
-}
-
-Node* nextInScope(const Node* node)
-{
-    ASSERT(!isActiveInsertionPoint(node));
-
-    if (Node* next = traverseFirstChild(node, DontCrossShadowRoot))
-        return next;
-    if (Node* next = traverseNextSibling(node))
-        return next;
-    const Node* current = node;
-    while (current && !traverseNextSibling(current))
-        current = traverseParent(current, DontCrossShadowRoot);
-    return current ? traverseNextSibling(current) : 0;
-}
-
-Node* previousInScope(const Node* node)
-{
-    ASSERT(!isActiveInsertionPoint(node));
-
-    if (Node* current = traversePreviousSibling(node)) {
-        while (Node* child = traverseLastChild(current, DontCrossShadowRoot))
-            current = child;
-        return current;
-    }
-    return traverseParent(node, DontCrossShadowRoot);
-}
-
-Node* parentInScope(const Node* node)
-{
-    ASSERT(!isActiveInsertionPoint(node));
-
-    return traverseParent(node, DontCrossShadowRoot);
-}
-
-Node* lastChildInScope(const Node* node)
-{
-    ASSERT(!isActiveInsertionPoint(node));
-
-    return traverseLastChild(node, DontCrossShadowRoot);
-}
-
-}
-
-} // namespace