Changeset 162602 in webkit


Ignore:
Timestamp:
Jan 23, 2014 2:02:11 AM (10 years ago)
Author:
abucur@adobe.com
Message:

[CSS Regions] Convert regions iterator loops to range-based loops
​https://bugs.webkit.org/show_bug.cgi?id=127464

Reviewed by Antti Koivisto.

Replace most of the iterator loops in the region implementation with
range based for loops. The for loops that iterate only over subsets
of collections have not been changed.

Tests: no new tests, this is a refactoring patch.

  • dom/WebKitNamedFlow.cpp:

(WebCore::WebKitNamedFlow::firstEmptyRegionIndex):
(WebCore::WebKitNamedFlow::getRegionsByContent):
(WebCore::WebKitNamedFlow::getRegions):
(WebCore::WebKitNamedFlow::getContent):

  • inspector/InspectorOverlay.cpp:

(WebCore::buildObjectForCSSRegionsHighlight):

  • rendering/RenderFlowThread.cpp:

(WebCore::RenderFlowThread::validateRegions):
(WebCore::RenderFlowThread::updateLogicalWidth):
(WebCore::RenderFlowThread::computeLogicalHeight):
(WebCore::RenderFlowThread::repaintRectangleInRegions):
(WebCore::RenderFlowThread::removeRenderBoxRegionInfo):
(WebCore::RenderFlowThread::logicalWidthChangedInRegionsForBlock):
(WebCore::RenderFlowThread::clearRenderBoxRegionInfoAndCustomStyle):
(WebCore::RenderFlowThread::isAutoLogicalHeightRegionsCountConsistent):
(WebCore::RenderFlowThread::markAutoLogicalHeightRegionsForLayout):
(WebCore::RenderFlowThread::markRegionsForOverflowLayoutIfNeeded):
(WebCore::RenderFlowThread::updateRegionsFlowThreadPortionRect):
(WebCore::RenderFlowThread::collectLayerFragments):
(WebCore::RenderFlowThread::fragmentsBoundingBox):

  • rendering/RenderNamedFlowFragment.cpp:

(WebCore::RenderNamedFlowFragment::setRegionObjectsRegionStyle):
(WebCore::RenderNamedFlowFragment::restoreRegionObjectsOriginalStyle):

  • rendering/RenderNamedFlowThread.cpp:

(WebCore::RenderNamedFlowThread::clearContentElements):
(WebCore::RenderNamedFlowThread::nextRendererForNode):
(WebCore::RenderNamedFlowThread::dependsOn):
(WebCore::RenderNamedFlowThread::computeOversetStateForRegions):
(WebCore::RenderNamedFlowThread::checkInvalidRegions):
(WebCore::RenderNamedFlowThread::pushDependencies):
(WebCore::RenderNamedFlowThread::registerNamedFlowContentElement):
(WebCore::isContainedInElements):
(WebCore::RenderNamedFlowThread::getRanges):
(WebCore::RenderNamedFlowThread::checkRegionsWithStyling):
(WebCore::RenderNamedFlowThread::clearRenderObjectCustomStyle):

  • rendering/RenderTreeAsText.cpp:

(WebCore::writeRenderRegionList):

Location:
trunk/Source/WebCore
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r162601 r162602  
     12014-01-23  Andrei Bucur  <abucur@adobe.com>
     2
     3        [CSS Regions] Convert regions iterator loops to range-based loops
     4        https://bugs.webkit.org/show_bug.cgi?id=127464
     5
     6        Reviewed by Antti Koivisto.
     7
     8        Replace most of the iterator loops in the region implementation with
     9        range based for loops. The for loops that iterate only over subsets
     10        of collections have not been changed.
     11
     12        Tests: no new tests, this is a refactoring patch.
     13
     14        * dom/WebKitNamedFlow.cpp:
     15        (WebCore::WebKitNamedFlow::firstEmptyRegionIndex):
     16        (WebCore::WebKitNamedFlow::getRegionsByContent):
     17        (WebCore::WebKitNamedFlow::getRegions):
     18        (WebCore::WebKitNamedFlow::getContent):
     19        * inspector/InspectorOverlay.cpp:
     20        (WebCore::buildObjectForCSSRegionsHighlight):
     21        * rendering/RenderFlowThread.cpp:
     22        (WebCore::RenderFlowThread::validateRegions):
     23        (WebCore::RenderFlowThread::updateLogicalWidth):
     24        (WebCore::RenderFlowThread::computeLogicalHeight):
     25        (WebCore::RenderFlowThread::repaintRectangleInRegions):
     26        (WebCore::RenderFlowThread::removeRenderBoxRegionInfo):
     27        (WebCore::RenderFlowThread::logicalWidthChangedInRegionsForBlock):
     28        (WebCore::RenderFlowThread::clearRenderBoxRegionInfoAndCustomStyle):
     29        (WebCore::RenderFlowThread::isAutoLogicalHeightRegionsCountConsistent):
     30        (WebCore::RenderFlowThread::markAutoLogicalHeightRegionsForLayout):
     31        (WebCore::RenderFlowThread::markRegionsForOverflowLayoutIfNeeded):
     32        (WebCore::RenderFlowThread::updateRegionsFlowThreadPortionRect):
     33        (WebCore::RenderFlowThread::collectLayerFragments):
     34        (WebCore::RenderFlowThread::fragmentsBoundingBox):
     35        * rendering/RenderNamedFlowFragment.cpp:
     36        (WebCore::RenderNamedFlowFragment::setRegionObjectsRegionStyle):
     37        (WebCore::RenderNamedFlowFragment::restoreRegionObjectsOriginalStyle):
     38        * rendering/RenderNamedFlowThread.cpp:
     39        (WebCore::RenderNamedFlowThread::clearContentElements):
     40        (WebCore::RenderNamedFlowThread::nextRendererForNode):
     41        (WebCore::RenderNamedFlowThread::dependsOn):
     42        (WebCore::RenderNamedFlowThread::computeOversetStateForRegions):
     43        (WebCore::RenderNamedFlowThread::checkInvalidRegions):
     44        (WebCore::RenderNamedFlowThread::pushDependencies):
     45        (WebCore::RenderNamedFlowThread::registerNamedFlowContentElement):
     46        (WebCore::isContainedInElements):
     47        (WebCore::RenderNamedFlowThread::getRanges):
     48        (WebCore::RenderNamedFlowThread::checkRegionsWithStyling):
     49        (WebCore::RenderNamedFlowThread::clearRenderObjectCustomStyle):
     50        * rendering/RenderTreeAsText.cpp:
     51        (WebCore::writeRenderRegionList):
     52
    1532014-01-23  László Langó  <llango.u-szeged@partner.samsung.com>
    254

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

    r161097 r162602  
    100100
    101101    int countNonPseudoRegions = -1;
    102     auto iter = regionList.begin();
    103     for (int index = 0; iter != regionList.end(); ++index, ++iter) {
     102    for (const auto& renderRegion : regionList) {
     103        const RenderNamedFlowFragment* namedFlowFragment = toRenderNamedFlowFragment(renderRegion);
    104104        // FIXME: Pseudo-elements are not included in the list.
    105105        // They will be included when we will properly support the Region interface
    106106        // http://dev.w3.org/csswg/css-regions/#the-region-interface
    107         const RenderNamedFlowFragment* renderRegion = toRenderNamedFlowFragment(*iter);
    108         if (renderRegion->isPseudoElementRegion())
     107        if (namedFlowFragment->isPseudoElementRegion())
    109108            continue;
    110109        countNonPseudoRegions++;
    111         if (renderRegion->regionOversetState() == RegionEmpty)
     110        if (namedFlowFragment->regionOversetState() == RegionEmpty)
    112111            return countNonPseudoRegions;
    113112    }
    … …  
    132131    if (inFlowThread(contentNode->renderer(), m_parentFlowThread)) {
    133132        const RenderRegionList& regionList = m_parentFlowThread->renderRegionList();
    134         for (auto iter = regionList.begin(), end = regionList.end(); iter != end; ++iter) {
     133        for (const auto& renderRegion : regionList) {
     134            const RenderNamedFlowFragment* namedFlowFragment = toRenderNamedFlowFragment(renderRegion);
    135135            // FIXME: Pseudo-elements are not included in the list.
    136136            // They will be included when we will properly support the Region interface
    137137            // http://dev.w3.org/csswg/css-regions/#the-region-interface
    138             const RenderNamedFlowFragment* renderRegion = toRenderNamedFlowFragment(*iter);
    139             if (renderRegion->isPseudoElementRegion())
     138            if (namedFlowFragment->isPseudoElementRegion())
    140139                continue;
    141             if (m_parentFlowThread->objectInFlowRegion(contentNode->renderer(), renderRegion)) {
    142                 ASSERT(renderRegion->generatingElement());
    143                 regionElements.append(*renderRegion->generatingElement());
     140            if (m_parentFlowThread->objectInFlowRegion(contentNode->renderer(), namedFlowFragment)) {
     141                ASSERT(namedFlowFragment->generatingElement());
     142                regionElements.append(*namedFlowFragment->generatingElement());
    144143            }
    145144        }
    … …  
    162161
    163162    const RenderRegionList& regionList = m_parentFlowThread->renderRegionList();
    164     for (auto iter = regionList.begin(), end = regionList.end(); iter != end; ++iter) {
     163    for (const auto& renderRegion : regionList) {
     164        const RenderNamedFlowFragment* namedFlowFragment = toRenderNamedFlowFragment(renderRegion);
    165165        // FIXME: Pseudo-elements are not included in the list.
    166166        // They will be included when we will properly support the Region interface
    167167        // http://dev.w3.org/csswg/css-regions/#the-region-interface
    168         const RenderNamedFlowFragment* renderRegion = toRenderNamedFlowFragment(*iter);
    169         if (renderRegion->isPseudoElementRegion())
     168        if (namedFlowFragment->isPseudoElementRegion())
    170169            continue;
    171         ASSERT(renderRegion->generatingElement());
    172         regionElements.append(*renderRegion->generatingElement());
     170        ASSERT(namedFlowFragment->generatingElement());
     171        regionElements.append(*namedFlowFragment->generatingElement());
    173172    }
    174173
    … …  
    189188
    190189    const NamedFlowContentElements& contentElementsList = m_parentFlowThread->contentElements();
    191     for (auto it = contentElementsList.begin(), end = contentElementsList.end(); it != end; ++it) {
    192         Element* element = *it;
     190    for (auto& element : contentElementsList) {
    193191        ASSERT(element->computedStyle()->flowThread() == m_parentFlowThread->flowThreadName());
    194192        contentElements.append(*element);

  • trunk/Source/WebCore/inspector/InspectorOverlay.cpp

    r162374 r162602  
    435435
    436436    const RenderRegionList& regionList = flowThread->renderRegionList();
    437     for (RenderRegionList::const_iterator iter = regionList.begin(); iter != regionList.end(); ++iter) {
    438         RenderRegion* iterRegion = *iter;
     437    for (auto& iterRegion : regionList) {
    439438        if (!iterRegion->isValid())
    440439            continue;

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

    r162523 r162602  
    162162            bool firstRegionVisited = false;
    163163           
    164             for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    165                 RenderRegion* region = *iter;
     164            for (auto& region : m_regionList) {
    166165                ASSERT(!region->needsLayout() || region->isRenderRegionSet());
    167166
    … …  
    366365{
    367366    LayoutUnit logicalWidth = initialLogicalWidth();
    368     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    369         RenderRegion* region = *iter;
     367    for (auto& region : m_regionList) {
    370368        ASSERT(!region->needsLayout() || region->isRenderRegionSet());
    371369        logicalWidth = std::max(region->pageLogicalWidth(), logicalWidth);
    … …  
    374372
    375373    // If the regions have non-uniform logical widths, then insert inset information for the RenderFlowThread.
    376     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    377         RenderRegion* region = *iter;
     374    for (auto& region : m_regionList) {
    378375        LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
    379376        LayoutUnit logicalLeft = style().direction() == LTR ? LayoutUnit() : logicalWidth - regionLogicalWidth;
    … …  
    388385
    389386    const LayoutUnit maxFlowSize = RenderFlowThread::maxLogicalHeight();
    390     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    391         RenderRegion* region = *iter;
     387    for (auto& region : m_regionList) {
    392388        ASSERT(!region->needsLayout() || region->isRenderRegionSet());
    393389
    … …  
    435431    CurrentRenderFlowThreadDisabler disabler(&view());
    436432   
    437     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    438         RenderRegion* region = *iter;
    439 
     433    for (auto& region : m_regionList)
    440434        region->repaintFlowThreadContent(repaintRect, immediate);
    441     }
    442435}
    443436
    … …  
    630623    getRegionRangeForBox(box, startRegion, endRegion);
    631624
    632     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
    633         RenderRegion* region = *iter;
     625    for (auto& region : m_regionList) {
    634626        region->removeRenderBoxRegionInfo(box);
    635627        if (region == endRegion)
    … …  
    639631#ifndef NDEBUG
    640632    // We have to make sure we did not leave any RenderBoxRegionInfo attached.
    641     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    642         RenderRegion* region = *iter;
     633    for (auto& region : m_regionList)
    643634        ASSERT(!region->renderBoxRegionInfo(box));
    644     }
    645635#endif
    646636
    … …  
    677667    }
    678668
    679     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
    680         RenderRegion* region = *iter;
     669    for (auto& region : m_regionList) {
    681670        ASSERT(!region->needsLayout() || region->isRenderRegionSet());
    682671
    … …  
    746735    bool insideOldRegionRange = false;
    747736    bool insideNewRegionRange = false;
    748     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    749         RenderRegion* region = *iter;
    750 
     737    for (auto& region : m_regionList) {
    751738        if (oldStartRegion == region)
    752739            insideOldRegionRange = true;
    … …  
    897884{
    898885    unsigned autoLogicalHeightRegions = 0;
    899     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    900         const RenderRegion* region = *iter;
     886    for (const auto& region : m_regionList) {
    901887        if (region->hasAutoLogicalHeight())
    902888            autoLogicalHeightRegions++;
    … …  
    930916    ASSERT(hasAutoLogicalHeightRegions());
    931917
    932     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    933         RenderRegion* region = *iter;
     918    for (auto& region : m_regionList) {
    934919        if (!region->hasAutoLogicalHeight())
    935920            continue;
    … …  
    946931        return;
    947932
    948     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    949         RenderRegion* region = *iter;
     933    for (auto& region : m_regionList)
    950934        region->setNeedsSimplifiedNormalFlowLayout();
    951     }
    952935}
    953936
    … …  
    960943    m_regionIntervalTree.clear();
    961944    m_regionIntervalTree.initIfNeeded();
    962     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    963         RenderRegion* region = *iter;
    964 
     945    for (auto& region : m_regionList) {
    965946        // If we find an empty auto-height region, clear the computedAutoHeight value.
    966947        if (emptyRegionsSegment && region->hasAutoLogicalHeight())
    … …  
    10821063    ASSERT(!m_regionsInvalidated);
    10831064   
    1084     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    1085         RenderRegion* region = *iter;
     1065    for (auto& region : m_regionList)
    10861066        region->collectLayerFragments(layerFragments, layerBoundingBox, dirtyRect);
    1087     }
    10881067}
    10891068
    … …  
    10931072   
    10941073    LayoutRect result;
    1095     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    1096         RenderRegion* region = *iter;
     1074    for (auto& region : m_regionList) {
    10971075        LayerFragments fragments;
    10981076        region->collectLayerFragments(fragments, layerBoundingBox, LayoutRect::infiniteRect());
    1099         for (size_t i = 0; i < fragments.size(); ++i) {
    1100             const LayerFragment& fragment = fragments.at(i);
     1077        for (const auto& fragment : fragments) {
    11011078            LayoutRect fragmentRect(layerBoundingBox);
    11021079            fragmentRect.intersect(fragment.paginationClip);

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

    r161553 r162602  
    309309    const NamedFlowContentElements& contentElements = namedFlow.contentElements();
    310310
    311     for (auto iter = contentElements.begin(), end = contentElements.end(); iter != end; ++iter) {
    312         const Element* element = *iter;
     311    for (const auto& element : contentElements) {
    313312        // The list of content nodes contains also the nodes with display:none.
    314313        if (!element->renderer())
    … …  
    344343
    345344    RenderObjectRegionStyleMap temp;
    346     for (auto iter = m_renderObjectRegionStyle.begin(), end = m_renderObjectRegionStyle.end(); iter != end; ++iter) {
    347         RenderObject* object = const_cast<RenderObject*>(iter->key);
     345    for (auto& objectPair : m_renderObjectRegionStyle) {
     346        RenderObject* object = const_cast<RenderObject*>(objectPair.key);
    348347        RefPtr<RenderStyle> objectRegionStyle = &object->style();
    349         RefPtr<RenderStyle> objectOriginalStyle = iter->value.style;
     348        RefPtr<RenderStyle> objectOriginalStyle = objectPair.value.style;
    350349        if (object->isRenderElement())
    351350            toRenderElement(object)->setStyleInternal(*objectOriginalStyle);
    352351
    353         bool shouldCacheRegionStyle = iter->value.cached;
     352        bool shouldCacheRegionStyle = objectPair.value.cached;
    354353        if (!shouldCacheRegionStyle) {
    355354            // Check whether we should cache the computed style in region.

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

    r161768 r162602  
    7474void RenderNamedFlowThread::clearContentElements()
    7575{
    76     for (auto it = m_contentElements.begin(), end = m_contentElements.end(); it != end; ++it) {
    77         Element* contentElement = *it;
    78        
     76    for (auto& contentElement : m_contentElements) {
    7977        ASSERT(contentElement);
    8078        ASSERT(contentElement->inNamedFlow());
    … …  
    103101RenderObject* RenderNamedFlowThread::nextRendererForNode(Node* node) const
    104102{
    105     for (auto it = m_flowThreadChildList->begin(), end = m_flowThreadChildList->end(); it != end; ++it) {
    106         RenderObject* child = *it;
     103    const FlowThreadChildList& childList = *(m_flowThreadChildList.get());
     104    for (auto& child : childList) {
    107105        ASSERT(child->node());
    108106        unsigned short position = node->compareDocumentPosition(child->node());
    … …  
    166164
    167165    // Recursively traverse the m_layoutBeforeThreadsSet.
    168     for (auto iterator = m_layoutBeforeThreadsSet.begin(), end = m_layoutBeforeThreadsSet.end(); iterator != end; ++iterator) {
    169         const RenderNamedFlowThread* beforeFlowThread = (*iterator).key;
     166    for (const auto& beforeFlowThreadPair : m_layoutBeforeThreadsSet) {
     167        const auto& beforeFlowThread = beforeFlowThreadPair.key;
    170168        if (beforeFlowThread->dependsOn(otherRenderFlowThread))
    171169            return true;
    … …  
    327325
    328326    RenderRegion* lastReg = lastRegion();
    329     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    330         RenderRegion* region = *iter;
     327    for (auto& region : m_regionList) {
    331328        LayoutUnit flowMin = height - (isHorizontalWritingMode() ? region->flowThreadPortionRect().y() : region->flowThreadPortionRect().x());
    332329        LayoutUnit flowMax = height - (isHorizontalWritingMode() ? region->flowThreadPortionRect().maxY() : region->flowThreadPortionRect().maxX());
    … …  
    364361{
    365362    Vector<RenderRegion*> newValidRegions;
    366     for (auto iter = m_invalidRegionList.begin(), end = m_invalidRegionList.end(); iter != end; ++iter) {
    367         RenderRegion* region = *iter;
     363    for (auto& region : m_invalidRegionList) {
    368364        // The only reason a region would be invalid is because it has a parent flow thread.
    369365        ASSERT(!region->isValid() && region->parentNamedFlowThread());
    … …  
    374370    }
    375371
    376     for (auto iter = newValidRegions.begin(), end = newValidRegions.end(); iter != end; ++iter) {
    377         RenderRegion* region = *iter;
     372    for (auto& region : newValidRegions) {
    378373        m_invalidRegionList.remove(region);
    379374        region->parentNamedFlowThread()->m_observerThreadsSet.remove(this);
    … …  
    393388    copyToVector(m_observerThreadsSet, observers);
    394389
    395     for (size_t i = 0; i < observers.size(); ++i) {
    396         RenderNamedFlowThread* flowThread = observers.at(i);
     390    for (auto& flowThread : observers)
    397391        flowThread->checkInvalidRegions();
    398     }
    399392}
    400393
    … …  
    419412void RenderNamedFlowThread::pushDependencies(RenderNamedFlowThreadList& list)
    420413{
    421     for (auto iter = m_layoutBeforeThreadsSet.begin(), end = m_layoutBeforeThreadsSet.end(); iter != end; ++iter) {
    422         RenderNamedFlowThread* flowThread = (*iter).key;
     414    for (auto& flowThreadPair : m_layoutBeforeThreadsSet) {
     415        auto& flowThread = flowThreadPair.key;
    423416        if (list.contains(flowThread))
    424417            continue;
    … …  
    440433
    441434    // Find the first content node following the new content node.
    442     for (auto it = m_contentElements.begin(), end = m_contentElements.end(); it != end; ++it) {
    443         Element* element = *it;
     435    for (auto& element : m_contentElements) {
    444436        unsigned short position = contentElement.compareDocumentPosition(element);
    445437        if (position & Node::DOCUMENT_POSITION_FOLLOWING) {
    … …  
    551543static bool isContainedInElements(const Vector<Element*>& others, Element* element)
    552544{
    553     for (size_t i = 0; i < others.size(); i++) {
    554         Element* other = others.at(i);
     545    for (auto& other : others) {
    555546        if (other->contains(element))
    556547            return true;
    … …  
    600591    Vector<Element*> elements;
    601592    // eliminate the contentElements that are descendants of other contentElements
    602     for (auto it = contentElements().begin(), end = contentElements().end(); it != end; ++it) {
    603         Element* element = *it;
     593    for (auto& element : contentElements()) {
    604594        if (!isContainedInElements(elements, element))
    605595            elements.append(element);
    606596    }
    607597
    608     for (size_t i = 0; i < elements.size(); i++) {
    609         Element* contentElement = elements.at(i);
     598    for (auto& contentElement : elements) {
    610599        if (!contentElement->renderer())
    611600            continue;
    … …  
    745734{
    746735    bool hasRegionsWithStyling = false;
    747     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    748         RenderNamedFlowFragment* region = toRenderNamedFlowFragment(*iter);
    749         if (region->hasCustomRegionStyle()) {
     736    for (const auto& region : m_regionList) {
     737        const RenderNamedFlowFragment* namedFlowFragment = toRenderNamedFlowFragment(region);
     738        if (namedFlowFragment->hasCustomRegionStyle()) {
    750739            hasRegionsWithStyling = true;
    751740            break;
    … …  
    759748    // Clear the styles for the object in the regions.
    760749    // FIXME: Region styling is not computed only for the region range of the object so this is why we need to walk the whole chain.
    761     for (auto iter = m_regionList.begin(), end = m_regionList.end(); iter != end; ++iter) {
    762         RenderNamedFlowFragment* region = toRenderNamedFlowFragment(*iter);
    763         region->clearObjectStyleInRegion(object);
     750    for (auto& region : m_regionList) {
     751        RenderNamedFlowFragment* namedFlowFragment = toRenderNamedFlowFragment(region);
     752        namedFlowFragment->clearObjectStyleInRegion(object);
    764753    }
    765754}

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

    r160598 r162602  
    658658static void writeRenderRegionList(const RenderRegionList& flowThreadRegionList, TextStream& ts, int indent)
    659659{
    660     for (RenderRegionList::const_iterator itRR = flowThreadRegionList.begin(); itRR != flowThreadRegionList.end(); ++itRR) {
    661         RenderRegion* renderRegion = *itRR;
    662 
     660    for (const auto& renderRegion : flowThreadRegionList) {
    663661        writeIndent(ts, indent);
    664662        ts << static_cast<const RenderObject*>(renderRegion)->renderName();
Note: See TracChangeset for help on using the changeset viewer.