Changeset 109704 in webkit


Ignore:
Timestamp:
Mar 4, 2012 10:30:22 PM (12 years ago)
Author:
shinyak@chromium.org
Message:

Source/WebCore: Methods like firstRendererOf of NodeRenderingContext should be extracted.
​https://bugs.webkit.org/show_bug.cgi?id=79902

Reviewed by Hajime Morita.

firstRendererOfInsertionPoint should return the first renderer of its child, however
it returns next renderer of parent. The same thing happens lastRendererOfInsertionPoint.

Test: content-element-move.html has another test case.

  • dom/NodeRenderingContext.cpp:

(WebCore):
(WebCore::nextRendererOfInsertionPoint):
(WebCore::previousRendererOfInsertionPoint):
(WebCore::firstRendererOfInsertionPoint):
(WebCore::lastRendererOfInsertionPoint):
(WebCore::firstRendererOf):
(WebCore::lastRendererOf):
(WebCore::NodeRenderingContext::nextRenderer):
(WebCore::NodeRenderingContext::previousRenderer):

LayoutTests: Refactoring: Methods like firstRendererOf of NodeRenderingContext should be extracted.
​https://bugs.webkit.org/show_bug.cgi?id=79902

Reviewed by Hajime Morita.

Added a new test case.

  • fast/dom/shadow/content-element-move-expected.txt:
  • fast/dom/shadow/content-element-move.html:
Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r109692 r109704  
     12012-03-04  Shinya Kawanaka  <shinyak@chromium.org>
     2
     3        Refactoring: Methods like firstRendererOf of NodeRenderingContext should be extracted.
     4        https://bugs.webkit.org/show_bug.cgi?id=79902
     5
     6        Reviewed by Hajime Morita.
     7
     8        Added a new test case.
     9
     10        * fast/dom/shadow/content-element-move-expected.txt:
     11        * fast/dom/shadow/content-element-move.html:
     12
    1132012-03-04  Kent Tamura  <tkent@chromium.org>
    214

  • trunk/LayoutTests/fast/dom/shadow/content-element-move-expected.txt

    r106465 r109704  
    2121testMoveLightChildOut
    2222PASS
     23testInsertBeforeFallback
     24PASS
    2325TEST COMPLETED
    2426

  • trunk/LayoutTests/fast/dom/shadow/content-element-move.html

    r109321 r109704  
    355355        };
    356356    })(root, n2, callIfDone);
     357
     358    setTimeout(f, 0);
     359}
     360
     361function testInsertBeforeFallback(callIfDone) {
     362    document.getElementById('expect-container').innerHTML =
     363        "<div><span>BEFORE</span><span>HOGE</span><span>FALLBACK</span><span>AFTER</span></div>";
     364
     365    var target = document.createElement('div');
     366    document.getElementById('actual-container').appendChild(target);
     367
     368    var span1 = document.createElement('span');
     369    var root = new WebKitShadowRoot(span1);
     370    root.innerHTML = "<content>FALLBACK</content>";
     371
     372    target.appendChild(createSpanWithText('BEFORE'));
     373    target.appendChild(span1);
     374    target.appendChild(createSpanWithText('AFTER'));
     375
     376    var f = (function(target, span1, callIfDone) { return function() {
     377        target.insertBefore(createSpanWithText('HOGE'), span1);
     378        callIfDone();
     379    };})(target, span1, callIfDone);
    357380
    358381    setTimeout(f, 0);
    … …  
    370393    testAppendContent3,
    371394    testChangeOrderOfContent,
    372     testMoveLightChildOut
     395    testMoveLightChildOut,
     396    testInsertBeforeFallback
    373397];
    374398

  • trunk/Source/WebCore/ChangeLog

    r109703 r109704  
     12012-03-04  Shinya Kawanaka  <shinyak@chromium.org>
     2
     3        Methods like firstRendererOf of NodeRenderingContext should be extracted.
     4        https://bugs.webkit.org/show_bug.cgi?id=79902
     5
     6        Reviewed by Hajime Morita.
     7
     8        firstRendererOfInsertionPoint should return the first renderer of its child, however
     9        it returns next renderer of parent. The same thing happens lastRendererOfInsertionPoint.
     10
     11        Test: content-element-move.html has another test case.
     12
     13        * dom/NodeRenderingContext.cpp:
     14        (WebCore):
     15        (WebCore::nextRendererOfInsertionPoint):
     16        (WebCore::previousRendererOfInsertionPoint):
     17        (WebCore::firstRendererOfInsertionPoint):
     18        (WebCore::lastRendererOfInsertionPoint):
     19        (WebCore::firstRendererOf):
     20        (WebCore::lastRendererOf):
     21        (WebCore::NodeRenderingContext::nextRenderer):
     22        (WebCore::NodeRenderingContext::previousRenderer):
     23
    1242012-03-04  MORITA Hajime <morrita@google.com>
    225

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

    r109321 r109704  
    4444namespace WebCore {
    4545
     46static RenderObject* firstRendererOf(Node*);
     47static RenderObject* lastRendererOf(Node*);
     48
    4649NodeRenderingContext::NodeRenderingContext(Node* node)
    4750    : m_phase(AttachingNotInTree)
    … …  
    136139}
    137140
    138 static RenderObject* nextRendererOf(InsertionPoint* parent, Node* current)
     141static inline RenderObject* nextRendererOfInsertionPoint(InsertionPoint* parent, Node* current)
    139142{
    140143    HTMLContentSelection* currentSelection = parent->selections()->find(current);
    … …  
    150153}
    151154
    152 static RenderObject* previousRendererOf(InsertionPoint* parent, Node* current)
     155static inline RenderObject* previousRendererOfInsertionPoint(InsertionPoint* parent, Node* current)
    153156{
    154157    RenderObject* lastRenderer = 0;
    … …  
    164167}
    165168
    166 static RenderObject* firstRendererOf(InsertionPoint* parent)
     169static inline RenderObject* firstRendererOfInsertionPoint(InsertionPoint* parent)
    167170{
    168171    if (parent->hasSelection()) {
    … …  
    175178    }
    176179
    177     return NodeRenderingContext(parent).nextRenderer();
    178 }
    179 
    180 static RenderObject* lastRendererOf(InsertionPoint* parent)
     180    return firstRendererOf(parent->firstChild());
     181}
     182
     183static inline RenderObject* lastRendererOfInsertionPoint(InsertionPoint* parent)
    181184{
    182185    if (parent->hasSelection()) {
    … …  
    189192    }
    190193
    191     return NodeRenderingContext(parent).previousRenderer();
    192 }
    193 
    194 RenderObject* NodeRenderingContext::nextRenderer() const
    195 {
    196     ASSERT(m_node->renderer() || m_phase != Calculating);
    197     if (RenderObject* renderer = m_node->renderer())
    198         return renderer->nextSibling();
    199 
    200     if (m_parentFlowRenderer)
    201         return m_parentFlowRenderer->nextRendererForNode(m_node);
    202 
    203     if (m_phase == AttachingDistributed) {
    204         if (RenderObject* found = nextRendererOf(m_insertionPoint, m_node))
    205             return found;
    206         return NodeRenderingContext(m_insertionPoint).nextRenderer();
    207     }
    208 
    209     // Avoid an O(N^2) problem with this function by not checking for
    210     // nextRenderer() when the parent element hasn't attached yet.
    211     if (m_node->parentOrHostNode() && !m_node->parentOrHostNode()->attached())
    212         return 0;
    213 
    214     for (Node* node = m_node->nextSibling(); node; node = node->nextSibling()) {
     194    return lastRendererOf(parent->lastChild());
     195}
     196
     197static inline RenderObject* firstRendererOf(Node* node)
     198{
     199    for (; node; node = node->nextSibling()) {
    215200        if (node->renderer()) {
    216201            // Do not return elements that are attached to a different flow-thread.
    … …  
    221206
    222207        if (isInsertionPoint(node)) {
    223             if (RenderObject* first = firstRendererOf(toInsertionPoint(node)))
     208            if (RenderObject* first = firstRendererOfInsertionPoint(toInsertionPoint(node)))
    224209                return first;
    225210        }
    … …  
    229214}
    230215
    231 RenderObject* NodeRenderingContext::previousRenderer() const
    232 {
    233     ASSERT(m_node->renderer() || m_phase != Calculating);
    234 
    235     if (RenderObject* renderer = m_node->renderer())
    236         return renderer->previousSibling();
    237 
    238     if (m_parentFlowRenderer)
    239         return m_parentFlowRenderer->previousRendererForNode(m_node);
    240 
    241     if (m_phase == AttachingDistributed) {
    242         if (RenderObject* found = previousRendererOf(m_insertionPoint, m_node))
    243             return found;
    244         return NodeRenderingContext(m_insertionPoint).previousRenderer();
    245     }
    246 
    247     // FIXME: We should have the same O(N^2) avoidance as nextRenderer does
    248     // however, when I tried adding it, several tests failed.
    249     for (Node* node = m_node->previousSibling(); node; node = node->previousSibling()) {
     216static inline RenderObject* lastRendererOf(Node* node)
     217{
     218    for (; node; node = node->previousSibling()) {
    250219        if (node->renderer()) {
    251220            // Do not return elements that are attached to a different flow-thread.
    … …  
    255224        }
    256225        if (isInsertionPoint(node)) {
    257             if (RenderObject* last = lastRendererOf(toInsertionPoint(node)))
     226            if (RenderObject* last = lastRendererOfInsertionPoint(toInsertionPoint(node)))
    258227                return last;
    259228        }
    … …  
    261230
    262231    return 0;
     232}
     233
     234RenderObject* NodeRenderingContext::nextRenderer() const
     235{
     236    ASSERT(m_node->renderer() || m_phase != Calculating);
     237    if (RenderObject* renderer = m_node->renderer())
     238        return renderer->nextSibling();
     239
     240    if (m_parentFlowRenderer)
     241        return m_parentFlowRenderer->nextRendererForNode(m_node);
     242
     243    if (m_phase == AttachingDistributed) {
     244        if (RenderObject* found = nextRendererOfInsertionPoint(m_insertionPoint, m_node))
     245            return found;
     246        return NodeRenderingContext(m_insertionPoint).nextRenderer();
     247    }
     248
     249    // Avoid an O(N^2) problem with this function by not checking for
     250    // nextRenderer() when the parent element hasn't attached yet.
     251    if (m_node->parentOrHostNode() && !m_node->parentOrHostNode()->attached())
     252        return 0;
     253
     254    return firstRendererOf(m_node->nextSibling());
     255}
     256
     257RenderObject* NodeRenderingContext::previousRenderer() const
     258{
     259    ASSERT(m_node->renderer() || m_phase != Calculating);
     260
     261    if (RenderObject* renderer = m_node->renderer())
     262        return renderer->previousSibling();
     263
     264    if (m_parentFlowRenderer)
     265        return m_parentFlowRenderer->previousRendererForNode(m_node);
     266
     267    if (m_phase == AttachingDistributed) {
     268        if (RenderObject* found = previousRendererOfInsertionPoint(m_insertionPoint, m_node))
     269            return found;
     270        return NodeRenderingContext(m_insertionPoint).previousRenderer();
     271    }
     272
     273    // FIXME: We should have the same O(N^2) avoidance as nextRenderer does
     274    // however, when I tried adding it, several tests failed.
     275    return lastRendererOf(m_node->previousSibling());
    263276}
    264277
Note: See TracChangeset for help on using the changeset viewer.