Changeset 87885 in webkit


Ignore:
Timestamp:
Jun 2, 2011 2:14:26 AM (13 years ago)
Author:
morrita@google.com
Message:

2011-06-02 MORITA Hajime <morrita@google.com>

Reviewed by Kent Tamura.

[Refactoring] Node::nextRenderer() and previousRenderer() should be part of NodeRenderingContext
https://bugs.webkit.org/show_bug.cgi?id=61912

Inlined Node::nextRenderer() and previousRenderer() into NodeRenderingContext and
removed original definitions.

No test, no behavioral change.

  • dom/Node.cpp:
  • dom/Node.h:
  • dom/NodeRenderingContext.cpp: (WebCore::NodeRenderingContext::nextRenderer): (WebCore::NodeRenderingContext::previousRenderer):
Location:
trunk/Source/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r87884 r87885  
     12011-06-02  MORITA Hajime  <morrita@google.com>
     2
     3        Reviewed by Kent Tamura.
     4
     5        [Refactoring] Node::nextRenderer() and previousRenderer() should be part of NodeRenderingContext
     6        https://bugs.webkit.org/show_bug.cgi?id=61912
     7
     8        Inlined Node::nextRenderer() and previousRenderer() into NodeRenderingContext and
     9        removed original definitions.
     10
     11        No test, no behavioral change.
     12       
     13        * dom/Node.cpp:
     14        * dom/Node.h:
     15        * dom/NodeRenderingContext.cpp:
     16        (WebCore::NodeRenderingContext::nextRenderer):
     17        (WebCore::NodeRenderingContext::previousRenderer):
     18
    1192011-06-02  Piroska András  <Piroska.Andras@stud.u-szeged.hu>
    220
  • trunk/Source/WebCore/dom/Node.cpp

    r87716 r87885  
    13821382}
    13831383
    1384 RenderObject* Node::previousRenderer()
    1385 {
    1386     // FIXME: We should have the same O(N^2) avoidance as nextRenderer does
    1387     // however, when I tried adding it, several tests failed.
    1388     for (Node* n = previousSibling(); n; n = n->previousSibling()) {
    1389         if (n->renderer())
    1390             return n->renderer();
    1391     }
    1392     return 0;
    1393 }
    1394 
    1395 RenderObject* Node::nextRenderer()
    1396 {
    1397     // Avoid an O(n^2) problem with this function by not checking for
    1398     // nextRenderer() when the parent element hasn't attached yet.
    1399     if (parentOrHostNode() && !parentOrHostNode()->attached())
    1400         return 0;
    1401 
    1402     for (Node* n = nextSibling(); n; n = n->nextSibling()) {
    1403         if (n->renderer())
    1404             return n->renderer();
    1405     }
    1406     return 0;
    1407 }
    1408 
    14091384// FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
    14101385Node *Node::previousNodeConsideringAtomicNodes() const
  • trunk/Source/WebCore/dom/Node.h

    r87867 r87885  
    435435
    436436    RenderObject* renderer() const { return m_renderer; }
    437     RenderObject* nextRenderer();
    438     RenderObject* previousRenderer();
    439437    void setRenderer(RenderObject* renderer) { m_renderer = renderer; }
    440438   
  • trunk/Source/WebCore/dom/NodeRenderingContext.cpp

    r87351 r87885  
    100100RenderObject* NodeRenderingContext::nextRenderer() const
    101101{
    102     if (RenderObject* renderer = m_node->renderer()) {
    103         ASSERT(m_location == LocationUndetermined);
     102    ASSERT(m_node->renderer() || m_location != LocationUndetermined);
     103    if (RenderObject* renderer = m_node->renderer())
    104104        return renderer->nextSibling();
    105     }
    106 
    107     ASSERT(m_location != LocationUndetermined);
    108 
    109     if (m_phase != AttachContentForwarded)
    110         return m_node->nextRenderer();
    111     // Returns 0 here to insert renderer at the end of child list.
    112     // We assume content children are always attached in tree order and
    113     // there is no partial render tree creation.
     105
     106    if (m_phase == AttachContentForwarded) {
     107        // Returns 0 here to insert renderer at the end of child list.
     108        // We assume content children are always attached in tree order and
     109        // there is no partial render tree creation.
     110        return 0;
     111    }
     112
     113    // Avoid an O(n^2) problem with this function by not checking for
     114    // nextRenderer() when the parent element hasn't attached yet.
     115    if (m_node->parentOrHostNode() && !m_node->parentOrHostNode()->attached())
     116        return 0;
     117
     118    for (Node* node = m_node->nextSibling(); node; node = node->nextSibling()) {
     119        if (node->renderer())
     120            return node->renderer();
     121    }
     122
    114123    return 0;
    115124}
     
    117126RenderObject* NodeRenderingContext::previousRenderer() const
    118127{
    119     if (RenderObject* renderer = m_node->renderer()) {
    120         ASSERT(m_location == LocationUndetermined);
     128    ASSERT(m_node->renderer() || m_location != LocationUndetermined);
     129    if (RenderObject* renderer = m_node->renderer())
    121130        return renderer->previousSibling();
    122     }
    123 
    124     ASSERT(m_location != LocationUndetermined);
    125 
    126     if (m_phase != AttachContentForwarded)
    127         return m_node->previousRenderer();
    128     // Returns lastChild() here to insert renderer at the end of child list.
    129     // We assume content children are always attached in tree order and
    130     // there is no partial render tree creation.
    131     if (RenderObject* parent = parentRenderer())
    132         return parent->lastChild();
     131
     132    if (m_phase == AttachContentForwarded) {
     133        // Returns lastChild() here to insert renderer at the end of child list.
     134        // We assume content children are always attached in tree order and
     135        // there is no partial render tree creation.
     136        if (RenderObject* parent = parentRenderer())
     137            return parent->lastChild();
     138        return 0;
     139    }
     140
     141    // FIXME: We should have the same O(N^2) avoidance as nextRenderer does
     142    // however, when I tried adding it, several tests failed.
     143    for (Node* node = m_node->previousSibling(); node; node = node->previousSibling()) {
     144        if (node->renderer())
     145            return node->renderer();
     146    }
     147
    133148    return 0;
    134149}
Note: See TracChangeset for help on using the changeset viewer.