Use C++11 range-based loop for core/layout

Source/core/layout/LayoutBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 144 matching lines @@
     , m_hasOnlySelfCollapsingChildren(false)
     , m_descendantsWithFloatsMarkedForLayout(false)
 {
     // LayoutBlockFlow calls setChildrenInline(true).
     // By default, subclasses do not have inline children.
 }
 
 static void removeBlockFromDescendantAndContainerMaps(LayoutBlock* block, TrackedDescendantsMap*& descendantMap, TrackedContainerMap*& containerMap)
 {
     if (OwnPtr<TrackedRendererListHashSet> descendantSet = descendantMap->take(block)) {
-        TrackedRendererListHashSet::iterator end = descendantSet->end();
-        for (TrackedRendererListHashSet::iterator descendant = descendantSet->begin(); descendant != end; ++descendant) {
-            TrackedContainerMap::iterator it = containerMap->find(*descendant);
+        for (auto& descendant : *descendantSet) {
+            TrackedContainerMap::iterator it = containerMap->find(descendant);
             ASSERT(it != containerMap->end());
             if (it == containerMap->end())
                 continue;
             HashSet<LayoutBlock*>* containerSet = it->value.get();
             ASSERT(containerSet->contains(block));
             containerSet->remove(block);
             if (containerSet->isEmpty())
                 containerMap->remove(it);
         }
     }
@@ skipping 184 matching lines @@
     else
         ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->addLayoutObject(this);
 }
 
 void LayoutBlock::invalidatePaintOfSubtreesIfNeeded(PaintInvalidationState& childPaintInvalidationState)
 {
     LayoutBox::invalidatePaintOfSubtreesIfNeeded(childPaintInvalidationState);
 
     // Take care of positioned objects. This is required as PaintInvalidationState keeps a single clip rect.
     if (TrackedRendererListHashSet* positionedObjects = this->positionedObjects()) {
-        TrackedRendererListHashSet::iterator end = positionedObjects->end();
-        for (TrackedRendererListHashSet::iterator it = positionedObjects->begin(); it != end; ++it) {
-            LayoutBox* box = *it;
+        for (auto* box : *positionedObjects) {
 
             // One of the renderers we're skipping over here may be the child's paint invalidation container,
             // so we can't pass our own paint invalidation container along.
             const LayoutBoxModelObject& paintInvalidationContainerForChild = *box->containerForPaintInvalidation();
 
             // If it's a new paint invalidation container, we won't have properly accumulated the offset into the
             // PaintInvalidationState.
             // FIXME: Teach PaintInvalidationState to handle this case. crbug.com/371485
             if (paintInvalidationContainerForChild != childPaintInvalidationState.paintInvalidationContainer()) {
                 ForceHorriblySlowRectMapping slowRectMapping(&childPaintInvalidationState);
@@ skipping 947 matching lines @@
 void LayoutBlock::finishDelayUpdateScrollInfo()
 {
     --gDelayUpdateScrollInfo;
     ASSERT(gDelayUpdateScrollInfo >= 0);
     if (gDelayUpdateScrollInfo == 0) {
         ASSERT(gDelayedUpdateScrollInfoSet);
 
         OwnPtr<DelayedUpdateScrollInfoSet> infoSet(adoptPtr(gDelayedUpdateScrollInfoSet));
         gDelayedUpdateScrollInfoSet = 0;
 
-        for (DelayedUpdateScrollInfoSet::iterator it = infoSet->begin(); it != infoSet->end(); ++it) {
-            LayoutBlock* block = *it;
+        for (auto* block : *infoSet) {
             if (block->hasOverflowClip()) {
                 block->layer()->scrollableArea()->updateAfterLayout();
             }
         }
     }
 }
 
 void LayoutBlock::updateScrollInfoAfterLayout()
 {
     if (hasOverflowClip()) {
@@ skipping 50 matching lines @@
 
     ResourceLoadPriorityOptimizer::VisibilityStatus status = isVisible ?
         ResourceLoadPriorityOptimizer::Visible : ResourceLoadPriorityOptimizer::NotVisible;
 
     LayoutRect screenArea;
     if (!objectBounds.isEmpty()) {
         screenArea = viewBounds;
         screenArea.intersect(objectBounds);
     }
 
-    for (Vector<ImageResource*>::iterator it = images.begin(), end = images.end(); it != end; ++it)
-        ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->notifyImageResourceVisibility(*it, status, screenArea);
+    for (auto* imageResource : images)
+        ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->notifyImageResourceVisibility(imageResource, status, screenArea);
 
     return true;
 }
 
 bool LayoutBlock::widthAvailableToChildrenHasChanged()
 {
     bool widthAvailableToChildrenHasChanged = m_widthAvailableToChildrenChanged;
     m_widthAvailableToChildrenChanged = false;
 
     // If we use border-box sizing, have percentage padding, and our parent has changed width then the width available to our children has changed even
@@ skipping 74 matching lines @@
             addOverflowFromChild(child);
     }
 }
 
 void LayoutBlock::addOverflowFromPositionedObjects()
 {
     TrackedRendererListHashSet* positionedDescendants = positionedObjects();
     if (!positionedDescendants)
         return;
 
-    LayoutBox* positionedObject;
-    TrackedRendererListHashSet::iterator end = positionedDescendants->end();
-    for (TrackedRendererListHashSet::iterator it = positionedDescendants->begin(); it != end; ++it) {
-        positionedObject = *it;
-
+    for (auto* positionedObject : *positionedDescendants) {
         // Fixed positioned elements don't contribute to layout overflow, since they don't scroll with the content.
         if (positionedObject->style()->position() != FixedPosition)
             addOverflowFromChild(positionedObject, toLayoutSize(positionedObject->location()));
     }
 }
 
 void LayoutBlock::addVisualOverflowFromTheme()
 {
     if (!style()->hasAppearance())
         return;
@@ skipping 159 matching lines @@
 
 void LayoutBlock::layoutPositionedObjects(bool relayoutChildren, PositionedLayoutBehavior info)
 {
     TrackedRendererListHashSet* positionedDescendants = positionedObjects();
     if (!positionedDescendants)
         return;
 
     if (hasColumns())
         view()->layoutState()->clearPaginationInformation(); // Positioned objects are not part of the column flow, so they don't paginate with the columns.
 
-    LayoutBox* r;
-    TrackedRendererListHashSet::iterator end = positionedDescendants->end();
-    for (TrackedRendererListHashSet::iterator it = positionedDescendants->begin(); it != end; ++it) {
-        r = *it;
+    for (auto* positionedObject : *positionedDescendants) {
+        positionedObject->setMayNeedPaintInvalidation();
 
-        r->setMayNeedPaintInvalidation();
-
-        SubtreeLayoutScope layoutScope(*r);
+        SubtreeLayoutScope layoutScope(*positionedObject);
         // A fixed position element with an absolute positioned ancestor has no way of knowing if the latter has changed position. So
         // if this is a fixed position element, mark it for layout if it has an abspos ancestor and needs to move with that ancestor, i.e.
         // it has static position.
-        markFixedPositionObjectForLayoutIfNeeded(r, layoutScope);
+        markFixedPositionObjectForLayoutIfNeeded(positionedObject, layoutScope);
         if (info == LayoutOnlyFixedPositionedObjects) {
-            r->layoutIfNeeded();
+            positionedObject->layoutIfNeeded();
             continue;
         }
 
         // When a non-positioned block element moves, it may have positioned children that are implicitly positioned relative to the
         // non-positioned block.  Rather than trying to detect all of these movement cases, we just always lay out positioned
         // objects that are positioned implicitly like this.  Such objects are rare, and so in typical DHTML menu usage (where everything is
         // positioned explicitly) this should not incur a performance penalty.
-        if (relayoutChildren || (r->style()->hasStaticBlockPosition(isHorizontalWritingMode()) && r->parent() != this))
-            layoutScope.setChildNeedsLayout(r);
+        if (relayoutChildren || (positionedObject->style()->hasStaticBlockPosition(isHorizontalWritingMode()) && positionedObject->parent() != this))
+            layoutScope.setChildNeedsLayout(positionedObject);
 
         // If relayoutChildren is set and the child has percentage padding or an embedded content box, we also need to invalidate the childs pref widths.
-        if (relayoutChildren && r->needsPreferredWidthsRecalculation())
-            r->setPreferredLogicalWidthsDirty(MarkOnlyThis);
+        if (relayoutChildren && positionedObject->needsPreferredWidthsRecalculation())
+            positionedObject->setPreferredLogicalWidthsDirty(MarkOnlyThis);
 
-        if (!r->needsLayout())
-            r->markForPaginationRelayoutIfNeeded(layoutScope);
+        if (!positionedObject->needsLayout())
+            positionedObject->markForPaginationRelayoutIfNeeded(layoutScope);
 
         // If we are paginated or in a line grid, go ahead and compute a vertical position for our object now.
         // If it's wrong we'll lay out again.
         LayoutUnit oldLogicalTop = 0;
-        bool needsBlockDirectionLocationSetBeforeLayout = r->needsLayout() && view()->layoutState()->needsBlockDirectionLocationSetBeforeLayout();
+        bool needsBlockDirectionLocationSetBeforeLayout = positionedObject->needsLayout() && view()->layoutState()->needsBlockDirectionLocationSetBeforeLayout();
         if (needsBlockDirectionLocationSetBeforeLayout) {
-            if (isHorizontalWritingMode() == r->isHorizontalWritingMode())
-                r->updateLogicalHeight();
+            if (isHorizontalWritingMode() == positionedObject->isHorizontalWritingMode())
+                positionedObject->updateLogicalHeight();
             else
-                r->updateLogicalWidth();
-            oldLogicalTop = logicalTopForChild(*r);
+                positionedObject->updateLogicalWidth();
+            oldLogicalTop = logicalTopForChild(*positionedObject);
         }
 
         // FIXME: We should be able to do a r->setNeedsPositionedMovementLayout() here instead of a full layout. Need
         // to investigate why it does not trigger the correct invalidations in that case. crbug.com/350756
         if (info == ForcedLayoutAfterContainingBlockMoved)
-            r->setNeedsLayout(LayoutInvalidationReason::AncestorMoved, MarkOnlyThis);
+            positionedObject->setNeedsLayout(LayoutInvalidationReason::AncestorMoved, MarkOnlyThis);
 
-        r->layoutIfNeeded();
+        positionedObject->layoutIfNeeded();
 
         // Lay out again if our estimate was wrong.
-        if (needsBlockDirectionLocationSetBeforeLayout && logicalTopForChild(*r) != oldLogicalTop)
-            r->forceChildLayout();
+        if (needsBlockDirectionLocationSetBeforeLayout && logicalTopForChild(*positionedObject) != oldLogicalTop)
+            positionedObject->forceChildLayout();
     }
 
     if (hasColumns())
         view()->layoutState()->setColumnInfo(columnInfo()); // FIXME: Kind of gross. We just put this back into the layout state so that pop() will work.
 }
 
 void LayoutBlock::markPositionedObjectsForLayout()
 {
     if (TrackedRendererListHashSet* positionedDescendants = positionedObjects()) {
-        TrackedRendererListHashSet::iterator end = positionedDescendants->end();
-        for (TrackedRendererListHashSet::iterator it = positionedDescendants->begin(); it != end; ++it)
-            (*it)->setChildNeedsLayout();
+        for (auto* descendant : *positionedDescendants)
+            descendant->setChildNeedsLayout();
     }
 }
 
 void LayoutBlock::markForPaginationRelayoutIfNeeded(SubtreeLayoutScope& layoutScope)
 {
     ASSERT(!needsLayout());
     if (needsLayout())
         return;
 
     if (view()->layoutState()->pageLogicalHeightChanged() || (view()->layoutState()->pageLogicalHeight() && view()->layoutState()->pageLogicalOffset(*this, logicalTop()) != pageLogicalOffset()))
@@ skipping 188 matching lines @@
 
 void LayoutBlock::removeFromTrackedRendererMaps(LayoutBox* descendant, TrackedDescendantsMap*& descendantsMap, TrackedContainerMap*& containerMap)
 {
     if (!descendantsMap)
         return;
 
     OwnPtr<HashSet<LayoutBlock*>> containerSet = containerMap->take(descendant);
     if (!containerSet)
         return;
 
-    HashSet<LayoutBlock*>::iterator end = containerSet->end();
-    for (HashSet<LayoutBlock*>::iterator it = containerSet->begin(); it != end; ++it) {
-        LayoutBlock* container = *it;
-
+    for (auto* container : *containerSet) {
         // FIXME: Disabling this assert temporarily until we fix the layout
         // bugs associated with positioned objects not properly cleared from
         // their ancestor chain before being moved. See webkit bug 93766.
         // ASSERT(descendant->isDescendantOf(container));
 
         TrackedDescendantsMap::iterator descendantsMapIterator = descendantsMap->find(container);
         ASSERT(descendantsMapIterator != descendantsMap->end());
         if (descendantsMapIterator == descendantsMap->end())
             continue;
         TrackedRendererListHashSet* descendantSet = descendantsMapIterator->value.get();
@@ skipping 21 matching lines @@
 {
     removeFromTrackedRendererMaps(o, gPositionedDescendantsMap, gPositionedContainerMap);
 }
 
 void LayoutBlock::removePositionedObjects(LayoutBlock* o, ContainingBlockState containingBlockState)
 {
     TrackedRendererListHashSet* positionedDescendants = positionedObjects();
     if (!positionedDescendants)
         return;
 
-    LayoutBox* r;
-
-    TrackedRendererListHashSet::iterator end = positionedDescendants->end();
-
     Vector<LayoutBox*, 16> deadObjects;
-
-    for (TrackedRendererListHashSet::iterator it = positionedDescendants->begin(); it != end; ++it) {
-        r = *it;
-        if (!o || r->isDescendantOf(o)) {
+    for (auto* positionedObject : *positionedDescendants) {
+        if (!o || positionedObject->isDescendantOf(o)) {
             if (containingBlockState == NewContainingBlock) {
-                r->setChildNeedsLayout(MarkOnlyThis);
-                if (r->needsPreferredWidthsRecalculation())
-                    r->setPreferredLogicalWidthsDirty(MarkOnlyThis);
+                positionedObject->setChildNeedsLayout(MarkOnlyThis);
+                if (positionedObject->needsPreferredWidthsRecalculation())
+                    positionedObject->setPreferredLogicalWidthsDirty(MarkOnlyThis);
             }
 
             // It is parent blocks job to add positioned child to positioned objects list of its containing block
             // Parent layout needs to be invalidated to ensure this happens.
-            LayoutObject* p = r->parent();
+            LayoutObject* p = positionedObject->parent();
             while (p && !p->isLayoutBlock())
                 p = p->parent();
             if (p)
                 p->setChildNeedsLayout();
 
-            deadObjects.append(r);
+            deadObjects.append(positionedObject);
         }
     }
 
     for (unsigned i = 0; i < deadObjects.size(); i++)
         removePositionedObject(deadObjects.at(i));
 }
 
 void LayoutBlock::addPercentHeightDescendant(LayoutBox* descendant)
 {
     insertIntoTrackedRendererMaps(descendant, gPercentHeightDescendantsMap, gPercentHeightContainerMap);
@@ skipping 25 matching lines @@
 
 void LayoutBlock::dirtyForLayoutFromPercentageHeightDescendants(SubtreeLayoutScope& layoutScope)
 {
     if (!gPercentHeightDescendantsMap)
         return;
 
     TrackedRendererListHashSet* descendants = gPercentHeightDescendantsMap->get(this);
     if (!descendants)
         return;
 
-    TrackedRendererListHashSet::iterator end = descendants->end();
-    for (TrackedRendererListHashSet::iterator it = descendants->begin(); it != end; ++it) {
-        LayoutBox* box = *it;
+    for (auto* box : *descendants) {
         while (box != this) {
             if (box->normalChildNeedsLayout())
                 break;
             layoutScope.setChildNeedsLayout(box);
             box = box->containingBlock();
             ASSERT(box);
             if (!box)
                 break;
         }
     }
@@ skipping 1732 matching lines @@
         for (LayoutBox* box = firstChildBox(); box; box = box->nextSiblingBox()) {
             if (recalcNormalFlowChildOverflowIfNeeded(box))
                 childrenOverflowChanged = true;
         }
     }
 
     TrackedRendererListHashSet* positionedDescendants = positionedObjects();
     if (!positionedDescendants)
         return childrenOverflowChanged;
 
-    TrackedRendererListHashSet::iterator end = positionedDescendants->end();
-    for (TrackedRendererListHashSet::iterator it = positionedDescendants->begin(); it != end; ++it) {
-        LayoutBox* box = *it;
-
+    for (auto* box : *positionedDescendants) {
         if (!box->needsOverflowRecalcAfterStyleChange())
             continue;
         LayoutBlock* block = toLayoutBlock(box);
         if (!block->recalcOverflowAfterStyleChange() || box->style()->position() == FixedPosition)
             continue;
 
         childrenOverflowChanged = true;
     }
     return childrenOverflowChanged;
 }
@@ skipping 93 matching lines @@
 void LayoutBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const LayoutObject* obj) const
 {
     showLayoutObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink