Changeset 146883 in webkit


Ignore:
Timestamp:
Mar 26, 2013 8:15:06 AM (11 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r146879.
​http://trac.webkit.org/changeset/146879
​https://bugs.webkit.org/show_bug.cgi?id=113312

Multiple layout test crashes in
WebCore::RenderListItem::updateListMarkerNumbers (Requested by
yurys on #webkit).

Patch by Sheriff Bot <​webkit.review.bot@gmail.com> on 2013-03-26

Source/WebCore:

  • dom/Node.cpp:
  • dom/Node.h:

(Node):

  • dom/NodeTraversal.cpp:
  • dom/NodeTraversal.h:

(ElementTraversal):
(NodeTraversal):

  • html/HTMLLIElement.cpp:

(WebCore::HTMLLIElement::attach):

  • html/HTMLOListElement.cpp:

(WebCore::HTMLOListElement::updateItemValues):
(WebCore::HTMLOListElement::recalculateItemCount):

  • rendering/RenderCounter.cpp:

(WebCore::previousInPreOrder):
(WebCore::previousSiblingOrParent):
(WebCore::parentElement):
(WebCore::nextInPreOrder):

  • rendering/RenderListItem.cpp:

(WebCore::enclosingList):
(WebCore::RenderListItem::nextListItem):
(WebCore::previousListItem):
(WebCore::RenderListItem::calcValue):
(WebCore::RenderListItem::explicitValueChanged):
(WebCore::previousOrNextItem):
(WebCore::RenderListItem::updateListMarkerNumbers):

  • rendering/RenderListItem.h:

(RenderListItem):

LayoutTests:

  • fast/dom/shadow/shadow-and-list-elements-expected.html:
  • fast/lists/positioned-count-crash-expected.txt:
Location:
trunk
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r146882 r146883  
     12013-03-26  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r146879.
     4        http://trac.webkit.org/changeset/146879
     5        https://bugs.webkit.org/show_bug.cgi?id=113312
     6
     7        Multiple layout test crashes in
     8        WebCore::RenderListItem::updateListMarkerNumbers (Requested by
     9        yurys on #webkit).
     10
     11        * fast/dom/shadow/shadow-and-list-elements-expected.html:
     12        * fast/lists/positioned-count-crash-expected.txt:
     13
    1142013-03-26  Hajime Morrita  <morrita@google.com>
    215

  • trunk/LayoutTests/fast/dom/shadow/shadow-and-list-elements-expected.html

    r146879 r146883  
    2323// </ol>   
    2424var hostEquivalent = document.getElementById("hostEquivalent");
    25 var shadowListRoot = document.createElement("ol");
    26 shadowListRoot.style.paddingLeft = "0px";
    27 hostEquivalent.appendChild(shadowListRoot);
    2825
    2926var childX = document.createElement("li");
    3027childX.innerHTML = "X";
    31 childX.style.listStylePosition = "inside";
    32 shadowListRoot.appendChild(childX);
     28hostEquivalent.appendChild(childX);
    3329
    3430var childUl = document.createElement("ul");
    3531childUl.innerHTML = "B";
    36 shadowListRoot.appendChild(childUl);
     32hostEquivalent.appendChild(childUl);
    3733
    3834var childY = document.createElement("li");
    3935childY.innerHTML = "Y";
    40 childY.style.listStylePosition = "inside";
    41 shadowListRoot.appendChild(childY);
     36hostEquivalent.appendChild(childY);
    4237</script>
    4338</body>

  • trunk/LayoutTests/fast/lists/positioned-count-crash-expected.txt

    r146879 r146883  
    33
    44For manual test: If you see no crash and "II II", it means this test PASS.
    5 PASS list marker is II.
     5FAIL list marker should be II. Was I.
    66

  • trunk/Source/WebCore/ChangeLog

    r146882 r146883  
     12013-03-26  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r146879.
     4        http://trac.webkit.org/changeset/146879
     5        https://bugs.webkit.org/show_bug.cgi?id=113312
     6
     7        Multiple layout test crashes in
     8        WebCore::RenderListItem::updateListMarkerNumbers (Requested by
     9        yurys on #webkit).
     10
     11        * dom/Node.cpp:
     12        * dom/Node.h:
     13        (Node):
     14        * dom/NodeTraversal.cpp:
     15        * dom/NodeTraversal.h:
     16        (ElementTraversal):
     17        (NodeTraversal):
     18        * html/HTMLLIElement.cpp:
     19        (WebCore::HTMLLIElement::attach):
     20        * html/HTMLOListElement.cpp:
     21        (WebCore::HTMLOListElement::updateItemValues):
     22        (WebCore::HTMLOListElement::recalculateItemCount):
     23        * rendering/RenderCounter.cpp:
     24        (WebCore::previousInPreOrder):
     25        (WebCore::previousSiblingOrParent):
     26        (WebCore::parentElement):
     27        (WebCore::nextInPreOrder):
     28        * rendering/RenderListItem.cpp:
     29        (WebCore::enclosingList):
     30        (WebCore::RenderListItem::nextListItem):
     31        (WebCore::previousListItem):
     32        (WebCore::RenderListItem::calcValue):
     33        (WebCore::RenderListItem::explicitValueChanged):
     34        (WebCore::previousOrNextItem):
     35        (WebCore::RenderListItem::updateListMarkerNumbers):
     36        * rendering/RenderListItem.h:
     37        (RenderListItem):
     38
    1392013-03-26  Hajime Morrita  <morrita@google.com>
    240

  • trunk/Source/WebCore/dom/Node.cpp

    r146879 r146883  
    11351135}
    11361136
    1137 Node* Node::pseudoAwarePreviousSibling() const
    1138 {
    1139     if (parentElement() && !previousSibling()) {
    1140         Element* parent = parentElement();
    1141         if (isAfterPseudoElement() && parent->lastChild())
    1142             return parent->lastChild();
    1143         if (!isBeforePseudoElement())
    1144             return parent->pseudoElement(BEFORE);
    1145     }
    1146     return previousSibling();
    1147 }
    1148 
    1149 Node* Node::pseudoAwareNextSibling() const
    1150 {
    1151     if (parentElement() && !nextSibling()) {
    1152         Element* parent = parentElement();
    1153         if (isBeforePseudoElement() && parent->firstChild())
    1154             return parent->firstChild();
    1155         if (!isAfterPseudoElement())
    1156             return parent->pseudoElement(AFTER);
    1157     }
    1158     return nextSibling();
    1159 }
    1160 
    1161 Node* Node::pseudoAwareFirstChild() const
    1162 {
    1163     if (isElementNode()) {
    1164         const Element* currentElement = toElement(this);
    1165         Node* first = currentElement->pseudoElement(BEFORE);
    1166         if (first)
    1167             return first;
    1168         first = currentElement->firstChild();
    1169         if (!first)
    1170             first = currentElement->pseudoElement(AFTER);
    1171         return first;
    1172     }
    1173 
    1174     return firstChild();
    1175 }
    1176 
    1177 Node* Node::pseudoAwareLastChild() const
    1178 {
    1179     if (isElementNode()) {
    1180         const Element* currentElement = toElement(this);
    1181         Node* last = currentElement->pseudoElement(AFTER);
    1182         if (last)
    1183             return last;
    1184         last = currentElement->lastChild();
    1185         if (!last)
    1186             last = currentElement->pseudoElement(BEFORE);
    1187         return last;
    1188     }
    1189 
    1190     return lastChild();
    1191 }
    1192 
    11931137// FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
    11941138Node *Node::previousNodeConsideringAtomicNodes() const

  • trunk/Source/WebCore/dom/Node.h

    r146879 r146883  
    196196    bool hasAttributes() const;
    197197    NamedNodeMap* attributes() const;
    198     Node* pseudoAwareNextSibling() const;
    199     Node* pseudoAwarePreviousSibling() const;
    200     Node* pseudoAwareFirstChild() const;
    201     Node* pseudoAwareLastChild() const;
    202198
    203199    virtual KURL baseURI() const;

  • trunk/Source/WebCore/dom/NodeTraversal.cpp

    r146879 r146883  
    2727
    2828#include "ContainerNode.h"
    29 #include "PseudoElement.h"
    3029
    3130namespace WebCore {
    32 
    3331namespace NodeTraversal {
    34 
    35 Node* previousIncludingPseudo(const Node* current, const Node* stayWithin)
    36 {
    37     Node* previous;
    38     if (current == stayWithin)
    39         return 0;
    40     if ((previous = current->pseudoAwarePreviousSibling())) {
    41         while (previous->pseudoAwareLastChild())
    42             previous = previous->pseudoAwareLastChild();
    43         return previous;
    44     }
    45     return current->parentNode();
    46 }
    47 
    48 Node* nextIncludingPseudo(const Node* current, const Node* stayWithin)
    49 {
    50     Node* next;
    51     if ((next = current->pseudoAwareFirstChild()))
    52         return next;
    53     if (current == stayWithin)
    54         return 0;
    55     if ((next = current->pseudoAwareNextSibling()))
    56         return next;
    57     for (current = current->parentNode(); current; current = current->parentNode()) {
    58         if (current == stayWithin)
    59             return 0;
    60         if ((next = current->pseudoAwareNextSibling()))
    61             return next;
    62     }
    63     return 0;
    64 }
    65 
    66 Node* nextIncludingPseudoSkippingChildren(const Node* current, const Node* stayWithin)
    67 {
    68     Node* next;
    69     if (current == stayWithin)
    70         return 0;
    71     if ((next = current->pseudoAwareNextSibling()))
    72         return next;
    73     for (current = current->parentNode(); current; current = current->parentNode()) {
    74         if (current == stayWithin)
    75             return 0;
    76         if ((next = current->pseudoAwareNextSibling()))
    77             return next;
    78     }
    79     return 0;
    80 }
    8132
    8233Node* nextAncestorSibling(const Node* current)

  • trunk/Source/WebCore/dom/NodeTraversal.h

    r146879 r146883  
    3535Element* firstWithin(const Node*);
    3636Element* firstWithin(const ContainerNode*);
    37 
    3837// Pre-order traversal skipping non-element nodes.
    3938Element* next(const Node*);
    … …  
    4140Element* next(const ContainerNode*);
    4241Element* next(const ContainerNode*, const Node* stayWithin);
    43 
    4442// Like next, but skips children.
    4543Element* nextSkippingChildren(const Node*);
    … …  
    4745Element* nextSkippingChildren(const ContainerNode*);
    4846Element* nextSkippingChildren(const ContainerNode*, const Node* stayWithin);
    49 
    50 // Pre-order traversal including the pseudo-elements.
    51 Element* previousIncludingPseudo(const Node*, const Node* = 0);
    52 Element* nextIncludingPseudo(const Node*, const Node* = 0);
    53 Element* nextIncludingPseudoSkippingChildren(const Node*, const Node* = 0);
    54 
    55 // Utility function to traverse only the element and pseudo-element siblings of a node.
    56 Element* pseudoAwarePreviousSibling(const Node*);
    5747
    5848}
    … …  
    8777Node* previousPostOrder(const Node*, const Node* stayWithin = 0);
    8878Node* previousSkippingChildrenPostOrder(const Node*, const Node* stayWithin = 0);
    89 
    90 // Pre-order traversal including the pseudo-elements.
    91 Node* previousIncludingPseudo(const Node*, const Node* = 0);
    92 Node* nextIncludingPseudo(const Node*, const Node* = 0);
    93 Node* nextIncludingPseudoSkippingChildren(const Node*, const Node* = 0);
    9479
    9580}
    … …  
    151136inline Element* nextSkippingChildren(const ContainerNode* current, const Node* stayWithin) { return traverseNextElementSkippingChildrenTemplate(current, stayWithin); }
    152137inline Element* nextSkippingChildren(const Node* current, const Node* stayWithin) { return traverseNextElementSkippingChildrenTemplate(current, stayWithin); }
    153 
    154 inline Element* previousIncludingPseudo(const Node* current, const Node* stayWithin)
    155 {
    156     Node* node = NodeTraversal::previousIncludingPseudo(current, stayWithin);
    157     while (node && !node->isElementNode())
    158         node = NodeTraversal::previousIncludingPseudo(node, stayWithin);
    159     return toElement(node);
    160 }
    161 
    162 inline Element* nextIncludingPseudo(const Node* current, const Node* stayWithin)
    163 {
    164     Node* node = NodeTraversal::nextIncludingPseudo(current, stayWithin);
    165     while (node && !node->isElementNode())
    166         node = NodeTraversal::nextIncludingPseudo(node, stayWithin);
    167     return toElement(node);
    168 }
    169 
    170 inline Element* nextIncludingPseudoSkippingChildren(const Node* current, const Node* stayWithin)
    171 {
    172     Node* node = NodeTraversal::nextIncludingPseudoSkippingChildren(current, stayWithin);
    173     while (node && !node->isElementNode())
    174         node = NodeTraversal::nextIncludingPseudoSkippingChildren(node, stayWithin);
    175     return toElement(node);
    176 }
    177 
    178 inline Element* pseudoAwarePreviousSibling(const Node* current)
    179 {
    180     Node* node = current->pseudoAwarePreviousSibling();
    181     while (node && !node->isElementNode())
    182         node = node->pseudoAwarePreviousSibling();
    183     return toElement(node);
    184 }
    185 
    186138}
    187139

  • trunk/Source/WebCore/html/HTMLLIElement.cpp

    r146879 r146883  
    9393
    9494    if (renderer() && renderer()->isListItem()) {
    95         RenderListItem* listItemRenderer = toRenderListItem(renderer());
     95        RenderListItem* render = toRenderListItem(renderer());
    9696
    9797        // Find the enclosing list node.
    98         Element* listNode = 0;
    99         Element* current = this;
     98        Node* listNode = 0;
     99        EventPathWalker walker(this);
    100100        while (!listNode) {
    101             current = current->parentElement();
    102             if (!current)
     101            walker.moveToParent();
     102            if (!walker.node())
    103103                break;
    104             if (current->hasTagName(ulTag) || current->hasTagName(olTag))
    105                 listNode = current;
     104            if (walker.node()->hasTagName(ulTag) || walker.node()->hasTagName(olTag))
     105                listNode = walker.node();
    106106        }
    107107
    … …  
    109109        // We don't want to change our style to say "inside" since that would affect nested nodes.
    110110        if (!listNode)
    111             listItemRenderer->setNotInList(true);
     111            render->setNotInList(true);
    112112
    113113        parseValue(fastGetAttribute(valueAttr));

  • trunk/Source/WebCore/html/HTMLOListElement.cpp

    r146879 r146883  
    107107void HTMLOListElement::updateItemValues()
    108108{
    109     for (RenderListItem* listItem = RenderListItem::nextListItem(this); listItem; listItem = RenderListItem::nextListItem(this, listItem))
     109    for (RenderListItem* listItem = RenderListItem::nextListItem(renderer()); listItem; listItem = RenderListItem::nextListItem(renderer(), listItem))
    110110        listItem->updateValue();
    111111}
    … …  
    115115    m_itemCount = 0;
    116116
    117     for (RenderListItem* listItem = RenderListItem::nextListItem(this); listItem; listItem = RenderListItem::nextListItem(this, listItem))
     117    for (RenderListItem* listItem = RenderListItem::nextListItem(renderer()); listItem; listItem = RenderListItem::nextListItem(renderer(), listItem))
    118118        m_itemCount++;
    119119

  • trunk/Source/WebCore/rendering/RenderCounter.cpp

    r146879 r146883  
    5858static RenderObject* previousInPreOrder(const RenderObject* object)
    5959{
    60     Element* self = toElement(object->node());
    61     Element* previous = ElementTraversal::previousIncludingPseudo(self);
    62     while (previous && !previous->renderer())
    63         previous = ElementTraversal::previousIncludingPseudo(previous);
    64     return previous ? previous->renderer() : 0;
     60    Element* parent;
     61    Element* sibling;
     62    switch (object->style()->styleType()) {
     63    case NOPSEUDO:
     64        ASSERT(!object->isAnonymous());
     65        parent = toElement(object->node());
     66        sibling = parent->previousElementSibling();
     67        parent = parent->parentElement();
     68        break;
     69    case BEFORE:
     70        return object->generatingNode()->renderer(); // It is always the generating node's renderer
     71    case AFTER:
     72        parent = toElement(object->generatingNode());
     73        sibling = parent->lastElementChild();
     74        break;
     75    default:
     76        ASSERT_NOT_REACHED();
     77        return 0;
     78    }
     79    while (sibling) {
     80        if (RenderObject* renderer = sibling->renderer()) {
     81            if (RenderObject* after = sibling->pseudoElementRenderer(AFTER))
     82                return after;
     83            parent = sibling;
     84            sibling = sibling->lastElementChild();
     85            if (!sibling) {
     86                if (RenderObject* before = toElement(renderer->node())->pseudoElementRenderer(BEFORE))
     87                    return before;
     88                return renderer;
     89            }
     90        } else
     91            sibling = sibling->previousElementSibling();
     92    }
     93    if (!parent)
     94        return 0;
     95    if (RenderObject* before = parent->pseudoElementRenderer(BEFORE))
     96        return before;
     97    return parent->renderer();
    6598}
    6699
    … …  
    69102static RenderObject* previousSiblingOrParent(const RenderObject* object)
    70103{
    71     Element* self = toElement(object->node());
    72     Element* previous = ElementTraversal::pseudoAwarePreviousSibling(self);
    73     while (previous && !previous->renderer())
    74         previous = ElementTraversal::pseudoAwarePreviousSibling(previous);
    75     if (previous)
    76         return previous->renderer();
    77     previous = self->parentElement();
    78     return previous ? previous->renderer() : 0;
    79 }
    80 
    81 static inline Element* parentElement(RenderObject* object)
    82 {
    83     return toElement(object->node())->parentElement();
     104    Element* parent;
     105    Element* sibling;
     106    switch (object->style()->styleType()) {
     107    case NOPSEUDO:
     108        ASSERT(!object->isAnonymous());
     109        parent = toElement(object->node());
     110        sibling = parent->previousElementSibling();
     111        parent = parent->parentElement();
     112        break;
     113    case BEFORE:
     114        return object->generatingNode()->renderer(); // It is always the generating node's renderer
     115    case AFTER:
     116        parent = toElement(object->generatingNode());
     117        sibling = parent->lastElementChild();
     118        break;
     119    default:
     120        ASSERT_NOT_REACHED();
     121        return 0;
     122    }
     123    while (sibling) {
     124        if (RenderObject* renderer = sibling->renderer()) // This skips invisible nodes
     125            return renderer;
     126        sibling = sibling->previousElementSibling();
     127    }
     128    if (!parent)
     129        return 0;
     130    if (RenderObject* before = parent->pseudoElementRenderer(BEFORE))
     131        return before;
     132    return parent->renderer();
     133}
     134
     135static Element* parentElement(RenderObject* object)
     136{
     137    switch (object->style()->styleType()) {
     138    case NOPSEUDO:
     139        ASSERT(!object->isAnonymous());
     140        return toElement(object->node())->parentElement();
     141    case BEFORE:
     142    case AFTER:
     143        return toElement(object->generatingNode());
     144    default:
     145        ASSERT_NOT_REACHED();
     146        return 0;
     147    }
    84148}
    85149
    … …  
    93157static RenderObject* nextInPreOrder(const RenderObject* object, const Element* stayWithin, bool skipDescendants = false)
    94158{
    95     Element* self = toElement(object->node());
    96     Element* next = skipDescendants ? ElementTraversal::nextIncludingPseudoSkippingChildren(self, stayWithin) : ElementTraversal::nextIncludingPseudo(self, stayWithin);
    97     while (next && !next->renderer())
    98         next = skipDescendants ? ElementTraversal::nextIncludingPseudoSkippingChildren(next, stayWithin) : ElementTraversal::nextIncludingPseudo(next, stayWithin);
    99     return next ? next->renderer() : 0;
     159    Element* self;
     160    Element* child;
     161    self = toElement(object->generatingNode());
     162    if (skipDescendants)
     163        goto nextsibling;
     164    switch (object->style()->styleType()) {
     165    case NOPSEUDO:
     166        ASSERT(!object->isAnonymous());
     167        if (RenderObject* before = self->pseudoElementRenderer(BEFORE))
     168            return before;
     169        break;
     170    case BEFORE:
     171        break;
     172    case AFTER:
     173        goto nextsibling;
     174    default:
     175        ASSERT_NOT_REACHED();
     176        return 0;
     177    }
     178    child = ElementTraversal::firstWithin(self);
     179    while (true) {
     180        while (child) {
     181            if (RenderObject* renderer = child->renderer())
     182                return renderer;
     183            child = ElementTraversal::nextSkippingChildren(child, self);
     184        }
     185        if (RenderObject* after = self->pseudoElementRenderer(AFTER))
     186            return after;
     187nextsibling:
     188        if (self == stayWithin)
     189            return 0;
     190        child = ElementTraversal::nextSkippingChildren(self);
     191        self = self->parentElement();
     192        if (!self) {
     193            ASSERT(!child); // We can only reach this if we are searching beyond the root element
     194            return 0; //  which cannot have siblings
     195        }
     196    }
    100197}
    101198

  • trunk/Source/WebCore/rendering/RenderListItem.cpp

    r146879 r146883  
    2828#include "HTMLNames.h"
    2929#include "HTMLOListElement.h"
    30 #include "NodeTraversal.h"
    3130#include "RenderListMarker.h"
    3231#include "RenderView.h"
    … …  
    9897}
    9998
    100 // Returns the enclosing list with respect to the DOM order.
    10199static Node* enclosingList(const RenderListItem* listItem)
    102100{
    103     Node* listItemNode = listItem->node();
    104101    Node* firstNode = 0;
    105     // We use parentNode because the enclosing list could be a ShadowRoot that's not Element.
    106     for (Node* parent = listItemNode->parentNode(); parent; parent = parent->parentNode()) {
    107         if (isList(parent))
    108             return parent;
    109         if (!firstNode)
    110             firstNode = parent;
     102
     103    for (const RenderObject* renderer = listItem->parent(); renderer; renderer = renderer->parent()) {
     104        Node* node = renderer->node();
     105        if (node) {
     106            if (isList(node))
     107                return node;
     108            if (!firstNode)
     109                firstNode = node;
     110        }
    111111    }
    112112
    … …  
    117117}
    118118
    119 // Returns the next list item with respect to the DOM order.
    120 RenderListItem* RenderListItem::nextListItem(Node* listNode, const RenderListItem* item)
    121 {
    122     if (!listNode)
     119RenderListItem* RenderListItem::nextListItem(RenderObject* list, const RenderListItem* item)
     120{
     121    if (!list)
    123122        return 0;
    124123
    125     Node* current = item ? item->node() : listNode;
    126     current = ElementTraversal::nextIncludingPseudo(current, listNode);
    127 
    128     while (current) {
    129         if (isList(current)) {
     124    RenderObject* renderer = item ? item->nextInPreOrder(list) : list->nextInPreOrder(list);
     125    while (renderer) {
     126        if (renderer->node() && isList(renderer->node())) {
    130127            // We've found a nested, independent list: nothing to do here.
    131             current = ElementTraversal::nextIncludingPseudoSkippingChildren(current, listNode);
     128            renderer = renderer->nextInPreOrderAfterChildren(list);
    132129            continue;
    133130        }
    134131
    135         RenderObject* renderer = current->renderer();
    136         if (renderer && renderer->isListItem())
     132        if (renderer->isListItem())
    137133            return toRenderListItem(renderer);
    138134
    139         // FIXME: Can this be optimized to skip the children of the elements without a renderer?
    140         current = ElementTraversal::nextIncludingPseudo(current, listNode);
    141     }
    142 
     135        renderer = renderer->nextInPreOrder(list);
     136    }
    143137    return 0;
    144138}
    145139
    146 // Returns the previous list item with respect to the DOM order.
    147 static RenderListItem* previousListItem(Node* listNode, const RenderListItem* item)
    148 {
    149     Node* current = item->node();
    150     for (current = ElementTraversal::previousIncludingPseudo(current, listNode); current; current = ElementTraversal::previousIncludingPseudo(current, listNode)) {
    151         RenderObject* renderer = current->renderer();
    152         if (!renderer || (renderer && !renderer->isListItem()))
     140static RenderListItem* previousListItem(RenderObject* list, const RenderListItem* item)
     141{
     142    for (RenderObject* renderer = item->previousInPreOrder(); renderer && renderer != list; renderer = renderer->previousInPreOrder()) {
     143        if (!renderer->isListItem())
    153144            continue;
    154145        Node* otherList = enclosingList(toRenderListItem(renderer));
    155146        // This item is part of our current list, so it's what we're looking for.
    156         if (listNode == otherList)
     147        if (list->node() == otherList)
    157148            return toRenderListItem(renderer);
    158149        // We found ourself inside another list; lets skip the rest of it.
    159         // Use nextIncludingPseudo() here because the other list itself may actually
     150        // Use nextInPreOrder() here because the other list itself may actually
    160151        // be a list item itself. We need to examine it, so we do this to counteract
    161         // the previousIncludingPseudo() that will be done by the loop.
     152        // the previousInPreOrder() that will be done by the loop.
    162153        if (otherList)
    163             current = ElementTraversal::nextIncludingPseudo(otherList);
     154            renderer = otherList->renderer()->nextInPreOrder();
    164155    }
    165156    return 0;
    … …  
    172163
    173164    Node* list = enclosingList(this);
     165    RenderObject* listRenderer = list ? list->renderer() : 0;
    174166    HTMLOListElement* oListElement = (list && list->hasTagName(olTag)) ? static_cast<HTMLOListElement*>(list) : 0;
    175167    int valueStep = 1;
    … …  
    179171    // FIXME: This recurses to a possible depth of the length of the list.
    180172    // That's not good -- we need to change this to an iterative algorithm.
    181     if (RenderListItem* previousItem = previousListItem(list, this))
     173    if (RenderListItem* previousItem = previousListItem(listRenderer, this))
    182174        return previousItem->value() + valueStep;
    183175
    … …  
    436428        m_marker->setNeedsLayoutAndPrefWidthsRecalc();
    437429    Node* listNode = enclosingList(this);
    438     for (RenderListItem* item = this; item; item = nextListItem(listNode, item))
     430    RenderObject* listRenderer = 0;
     431    if (listNode)
     432        listRenderer = listNode->renderer();
     433    for (RenderListItem* item = this; item; item = nextListItem(listRenderer, item))
    439434        item->updateValue();
    440435}
    … …  
    463458}
    464459
    465 static RenderListItem* previousOrNextItem(bool isListReversed, Node* list, RenderListItem* item)
     460static RenderListItem* previousOrNextItem(bool isListReversed, RenderObject* list, RenderListItem* item)
    466461{
    467462    return isListReversed ? previousListItem(list, item) : RenderListItem::nextListItem(list, item);
    … …  
    471466{
    472467    Node* listNode = enclosingList(this);
    473     // The list node can be the shadow root which has no renderer.
    474     ASSERT(listNode);
    475     if (!listNode)
     468    ASSERT(listNode && listNode->renderer());
     469    if (!listNode || !listNode->renderer())
    476470        return;
    477471
    478472    bool isListReversed = false;
     473    RenderObject* list = listNode->renderer();
    479474    HTMLOListElement* oListElement = (listNode && listNode->hasTagName(olTag)) ? static_cast<HTMLOListElement*>(listNode) : 0;
    480475    if (oListElement) {
    … …  
    482477        isListReversed = oListElement->isReversed();
    483478    }
    484     for (RenderListItem* item = previousOrNextItem(isListReversed, listNode, this); item; item = previousOrNextItem(isListReversed, listNode, item)) {
     479    for (RenderListItem* item = previousOrNextItem(isListReversed, list, this); item; item = previousOrNextItem(isListReversed, list, item)) {
    485480        if (!item->m_isValueUpToDate) {
    486481            // If an item has been marked for update before, we can safely

  • trunk/Source/WebCore/rendering/RenderListItem.h

    r146879 r146883  
    5050    void updateListMarkerNumbers();
    5151
    52     static RenderListItem* nextListItem(Node*, const RenderListItem* = 0);
     52    static RenderListItem* nextListItem(RenderObject* listRenderer, const RenderListItem* = 0);
    5353
    5454private:
Note: See TracChangeset for help on using the changeset viewer.