<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[185517] trunk/Source/WebCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/185517">185517</a></dd>
<dt>Author</dt> <dd>commit-queue@webkit.org</dd>
<dt>Date</dt> <dd>2015-06-12 11:43:01 -0700 (Fri, 12 Jun 2015)</dd>
</dl>
<h3>Log Message</h3>
<pre>Unreviewed, rolling out <a href="http://trac.webkit.org/projects/webkit/changeset/185512">r185512</a>.
https://bugs.webkit.org/show_bug.cgi?id=145932
Many asserts on layout tests and on API tests (Requested by
ap_ on #webkit).
Reverted changeset:
"Use modern for-loops in WebCore/rendering - 1"
https://bugs.webkit.org/show_bug.cgi?id=145831
http://trac.webkit.org/changeset/185512</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorerenderingAutoTableLayoutcpp">trunk/Source/WebCore/rendering/AutoTableLayout.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingFilterEffectRenderercpp">trunk/Source/WebCore/rendering/FilterEffectRenderer.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingFilterEffectRendererh">trunk/Source/WebCore/rendering/FilterEffectRenderer.h</a></li>
<li><a href="#trunkSourceWebCorerenderingFloatingObjectscpp">trunk/Source/WebCore/rendering/FloatingObjects.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingFlowThreadControllercpp">trunk/Source/WebCore/rendering/FlowThreadController.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingHitTestResultcpp">trunk/Source/WebCore/rendering/HitTestResult.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingImageQualityControllercpp">trunk/Source/WebCore/rendering/ImageQualityController.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingInlineTextBoxcpp">trunk/Source/WebCore/rendering/InlineTextBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockcpp">trunk/Source/WebCore/rendering/RenderBlock.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockFlowcpp">trunk/Source/WebCore/rendering/RenderBlockFlow.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockLineLayoutcpp">trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderCountercpp">trunk/Source/WebCore/rendering/RenderCounter.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderFlexibleBoxcpp">trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderFlowThreadcpp">trunk/Source/WebCore/rendering/RenderFlowThread.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderInlinecpp">trunk/Source/WebCore/rendering/RenderInline.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayercpp">trunk/Source/WebCore/rendering/RenderLayer.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayerBackingcpp">trunk/Source/WebCore/rendering/RenderLayerBacking.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLineBoxListcpp">trunk/Source/WebCore/rendering/RenderLineBoxList.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderListBoxcpp">trunk/Source/WebCore/rendering/RenderListBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderMenuListcpp">trunk/Source/WebCore/rendering/RenderMenuList.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderMultiColumnSetcpp">trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/ChangeLog 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -1,3 +1,17 @@
</span><ins>+2015-06-12 Commit Queue <commit-queue@webkit.org>
+
+ Unreviewed, rolling out r185512.
+ https://bugs.webkit.org/show_bug.cgi?id=145932
+
+ Many asserts on layout tests and on API tests (Requested by
+ ap_ on #webkit).
+
+ Reverted changeset:
+
+ "Use modern for-loops in WebCore/rendering - 1"
+ https://bugs.webkit.org/show_bug.cgi?id=145831
+ http://trac.webkit.org/changeset/185512
+
</ins><span class="cx"> 2015-06-12 Simon Fraser <simon.fraser@apple.com>
</span><span class="cx">
</span><span class="cx"> OpenGLESSPI.h doesn't need to include UIKit.h
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingAutoTableLayoutcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/AutoTableLayout.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/AutoTableLayout.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/AutoTableLayout.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -226,17 +226,17 @@
</span><span class="cx"> const float epsilon = 1 / 128.0f;
</span><span class="cx">
</span><span class="cx"> float remainingPercent = 100;
</span><del>- for (auto& layout : m_layoutStruct) {
- minWidth += layout.effectiveMinLogicalWidth;
- maxWidth += layout.effectiveMaxLogicalWidth;
</del><ins>+ for (size_t i = 0; i < m_layoutStruct.size(); ++i) {
+ minWidth += m_layoutStruct[i].effectiveMinLogicalWidth;
+ maxWidth += m_layoutStruct[i].effectiveMaxLogicalWidth;
</ins><span class="cx"> if (scaleColumns) {
</span><del>- if (layout.effectiveLogicalWidth.isPercent()) {
- float percent = std::min(layout.effectiveLogicalWidth.percent(), remainingPercent);
- float logicalWidth = static_cast<float>(layout.effectiveMaxLogicalWidth) * 100 / std::max(percent, epsilon);
</del><ins>+ if (m_layoutStruct[i].effectiveLogicalWidth.isPercent()) {
+ float percent = std::min(m_layoutStruct[i].effectiveLogicalWidth.percent(), remainingPercent);
+ float logicalWidth = static_cast<float>(m_layoutStruct[i].effectiveMaxLogicalWidth) * 100 / std::max(percent, epsilon);
</ins><span class="cx"> maxPercent = std::max(logicalWidth, maxPercent);
</span><span class="cx"> remainingPercent -= percent;
</span><span class="cx"> } else
</span><del>- maxNonPercent += layout.effectiveMaxLogicalWidth;
</del><ins>+ maxNonPercent += m_layoutStruct[i].effectiveMaxLogicalWidth;
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -264,15 +264,17 @@
</span><span class="cx"> {
</span><span class="cx"> int maxLogicalWidth = 0;
</span><span class="cx">
</span><ins>+ size_t nEffCols = m_layoutStruct.size();
</ins><span class="cx"> int spacingInRowDirection = m_table->hBorderSpacing();
</span><span class="cx">
</span><del>- for (auto& layout : m_layoutStruct) {
- layout.effectiveLogicalWidth = layout.logicalWidth;
- layout.effectiveMinLogicalWidth = layout.minLogicalWidth;
- layout.effectiveMaxLogicalWidth = layout.maxLogicalWidth;
</del><ins>+ for (size_t i = 0; i < nEffCols; ++i) {
+ m_layoutStruct[i].effectiveLogicalWidth = m_layoutStruct[i].logicalWidth;
+ m_layoutStruct[i].effectiveMinLogicalWidth = m_layoutStruct[i].minLogicalWidth;
+ m_layoutStruct[i].effectiveMaxLogicalWidth = m_layoutStruct[i].maxLogicalWidth;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- for (auto& cell : m_spanCells) {
</del><ins>+ for (size_t i = 0; i < m_spanCells.size(); ++i) {
+ RenderTableCell* cell = m_spanCells[i];
</ins><span class="cx"> if (!cell)
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="lines">@@ -294,7 +296,7 @@
</span><span class="cx"> bool haveAuto = false;
</span><span class="cx"> bool spanHasEmptyCellsOnly = true;
</span><span class="cx"> int fixedWidth = 0;
</span><del>- while (lastCol < m_layoutStruct.size() && span > 0) {
</del><ins>+ while (lastCol < nEffCols && span > 0) {
</ins><span class="cx"> Layout& columnLayout = m_layoutStruct[lastCol];
</span><span class="cx"> switch (columnLayout.logicalWidth.type()) {
</span><span class="cx"> case Percent:
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingFilterEffectRenderercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/FilterEffectRenderer.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/FilterEffectRenderer.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/FilterEffectRenderer.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -135,17 +135,18 @@
</span><span class="cx"> m_effects.clear();
</span><span class="cx">
</span><span class="cx"> RefPtr<FilterEffect> previousEffect = m_sourceGraphic;
</span><del>- for (auto& filterOperation : operations.operations()) {
</del><ins>+ for (size_t i = 0; i < operations.operations().size(); ++i) {
</ins><span class="cx"> RefPtr<FilterEffect> effect;
</span><del>- switch (filterOperation->type()) {
</del><ins>+ FilterOperation& filterOperation = *operations.operations().at(i);
+ switch (filterOperation.type()) {
</ins><span class="cx"> case FilterOperation::REFERENCE: {
</span><del>- ReferenceFilterOperation& referenceOperation = downcast<ReferenceFilterOperation>(*filterOperation);
</del><ins>+ ReferenceFilterOperation& referenceOperation = downcast<ReferenceFilterOperation>(filterOperation);
</ins><span class="cx"> effect = buildReferenceFilter(renderer, previousEffect, &referenceOperation);
</span><span class="cx"> referenceOperation.setFilterEffect(effect);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case FilterOperation::GRAYSCALE: {
</span><del>- BasicColorMatrixFilterOperation& colorMatrixOperation = downcast<BasicColorMatrixFilterOperation>(*filterOperation);
</del><ins>+ BasicColorMatrixFilterOperation& colorMatrixOperation = downcast<BasicColorMatrixFilterOperation>(filterOperation);
</ins><span class="cx"> Vector<float> inputParameters;
</span><span class="cx"> double oneMinusAmount = clampTo(1 - colorMatrixOperation.amount(), 0.0, 1.0);
</span><span class="cx">
</span><span class="lines">@@ -173,7 +174,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case FilterOperation::SEPIA: {
</span><del>- BasicColorMatrixFilterOperation& colorMatrixOperation = downcast<BasicColorMatrixFilterOperation>(*filterOperation);
</del><ins>+ BasicColorMatrixFilterOperation& colorMatrixOperation = downcast<BasicColorMatrixFilterOperation>(filterOperation);
</ins><span class="cx"> Vector<float> inputParameters;
</span><span class="cx"> double oneMinusAmount = clampTo(1 - colorMatrixOperation.amount(), 0.0, 1.0);
</span><span class="cx">
</span><span class="lines">@@ -201,21 +202,21 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case FilterOperation::SATURATE: {
</span><del>- BasicColorMatrixFilterOperation& colorMatrixOperation = downcast<BasicColorMatrixFilterOperation>(*filterOperation);
</del><ins>+ BasicColorMatrixFilterOperation& colorMatrixOperation = downcast<BasicColorMatrixFilterOperation>(filterOperation);
</ins><span class="cx"> Vector<float> inputParameters;
</span><span class="cx"> inputParameters.append(narrowPrecisionToFloat(colorMatrixOperation.amount()));
</span><span class="cx"> effect = FEColorMatrix::create(*this, FECOLORMATRIX_TYPE_SATURATE, inputParameters);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case FilterOperation::HUE_ROTATE: {
</span><del>- BasicColorMatrixFilterOperation& colorMatrixOperation = downcast<BasicColorMatrixFilterOperation>(*filterOperation);
</del><ins>+ BasicColorMatrixFilterOperation& colorMatrixOperation = downcast<BasicColorMatrixFilterOperation>(filterOperation);
</ins><span class="cx"> Vector<float> inputParameters;
</span><span class="cx"> inputParameters.append(narrowPrecisionToFloat(colorMatrixOperation.amount()));
</span><span class="cx"> effect = FEColorMatrix::create(*this, FECOLORMATRIX_TYPE_HUEROTATE, inputParameters);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case FilterOperation::INVERT: {
</span><del>- BasicComponentTransferFilterOperation& componentTransferOperation = downcast<BasicComponentTransferFilterOperation>(*filterOperation);
</del><ins>+ BasicComponentTransferFilterOperation& componentTransferOperation = downcast<BasicComponentTransferFilterOperation>(filterOperation);
</ins><span class="cx"> ComponentTransferFunction transferFunction;
</span><span class="cx"> transferFunction.type = FECOMPONENTTRANSFER_TYPE_TABLE;
</span><span class="cx"> Vector<float> transferParameters;
</span><span class="lines">@@ -228,7 +229,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case FilterOperation::OPACITY: {
</span><del>- BasicComponentTransferFilterOperation& componentTransferOperation = downcast<BasicComponentTransferFilterOperation>(*filterOperation);
</del><ins>+ BasicComponentTransferFilterOperation& componentTransferOperation = downcast<BasicComponentTransferFilterOperation>(filterOperation);
</ins><span class="cx"> ComponentTransferFunction transferFunction;
</span><span class="cx"> transferFunction.type = FECOMPONENTTRANSFER_TYPE_TABLE;
</span><span class="cx"> Vector<float> transferParameters;
</span><span class="lines">@@ -241,7 +242,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case FilterOperation::BRIGHTNESS: {
</span><del>- BasicComponentTransferFilterOperation& componentTransferOperation = downcast<BasicComponentTransferFilterOperation>(*filterOperation);
</del><ins>+ BasicComponentTransferFilterOperation& componentTransferOperation = downcast<BasicComponentTransferFilterOperation>(filterOperation);
</ins><span class="cx"> ComponentTransferFunction transferFunction;
</span><span class="cx"> transferFunction.type = FECOMPONENTTRANSFER_TYPE_LINEAR;
</span><span class="cx"> transferFunction.slope = narrowPrecisionToFloat(componentTransferOperation.amount());
</span><span class="lines">@@ -252,7 +253,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case FilterOperation::CONTRAST: {
</span><del>- BasicComponentTransferFilterOperation& componentTransferOperation = downcast<BasicComponentTransferFilterOperation>(*filterOperation);
</del><ins>+ BasicComponentTransferFilterOperation& componentTransferOperation = downcast<BasicComponentTransferFilterOperation>(filterOperation);
</ins><span class="cx"> ComponentTransferFunction transferFunction;
</span><span class="cx"> transferFunction.type = FECOMPONENTTRANSFER_TYPE_LINEAR;
</span><span class="cx"> float amount = narrowPrecisionToFloat(componentTransferOperation.amount());
</span><span class="lines">@@ -264,13 +265,13 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case FilterOperation::BLUR: {
</span><del>- BlurFilterOperation& blurOperation = downcast<BlurFilterOperation>(*filterOperation);
</del><ins>+ BlurFilterOperation& blurOperation = downcast<BlurFilterOperation>(filterOperation);
</ins><span class="cx"> float stdDeviation = floatValueForLength(blurOperation.stdDeviation(), 0);
</span><span class="cx"> effect = FEGaussianBlur::create(*this, stdDeviation, stdDeviation, consumer == FilterProperty ? EDGEMODE_NONE : EDGEMODE_DUPLICATE);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case FilterOperation::DROP_SHADOW: {
</span><del>- DropShadowFilterOperation& dropShadowOperation = downcast<DropShadowFilterOperation>(*filterOperation);
</del><ins>+ DropShadowFilterOperation& dropShadowOperation = downcast<DropShadowFilterOperation>(filterOperation);
</ins><span class="cx"> effect = FEDropShadow::create(*this, dropShadowOperation.stdDeviation(), dropShadowOperation.stdDeviation(),
</span><span class="cx"> dropShadowOperation.x(), dropShadowOperation.y(), dropShadowOperation.color(), 1);
</span><span class="cx"> break;
</span><span class="lines">@@ -285,7 +286,7 @@
</span><span class="cx"> effect->setClipsToBounds(consumer == FilterFunction);
</span><span class="cx"> effect->setOperatingColorSpace(ColorSpaceDeviceRGB);
</span><span class="cx">
</span><del>- if (filterOperation->type() != FilterOperation::REFERENCE) {
</del><ins>+ if (filterOperation.type() != FilterOperation::REFERENCE) {
</ins><span class="cx"> effect->inputEffects().append(previousEffect);
</span><span class="cx"> m_effects.append(effect);
</span><span class="cx"> }
</span><span class="lines">@@ -330,8 +331,8 @@
</span><span class="cx"> void FilterEffectRenderer::clearIntermediateResults()
</span><span class="cx"> {
</span><span class="cx"> m_sourceGraphic->clearResult();
</span><del>- for (auto& effect : m_effects)
- effect->clearResult();
</del><ins>+ for (size_t i = 0; i < m_effects.size(); ++i)
+ m_effects[i]->clearResult();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void FilterEffectRenderer::apply()
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingFilterEffectRendererh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/FilterEffectRenderer.h (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/FilterEffectRenderer.h 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/FilterEffectRenderer.h 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -120,8 +120,10 @@
</span><span class="cx"> private:
</span><span class="cx"> void setMaxEffectRects(const FloatRect& effectRect)
</span><span class="cx"> {
</span><del>- for (auto& effect : m_effects)
</del><ins>+ for (size_t i = 0; i < m_effects.size(); ++i) {
+ RefPtr<FilterEffect> effect = m_effects.at(i);
</ins><span class="cx"> effect->setMaxEffectRect(effectRect);
</span><ins>+ }
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> FilterEffect* lastEffect() const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingFloatingObjectscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/FloatingObjects.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/FloatingObjects.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/FloatingObjects.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -266,9 +266,9 @@
</span><span class="cx"> void FloatingObjects::clearLineBoxTreePointers()
</span><span class="cx"> {
</span><span class="cx"> // Clear references to originating lines, since the lines are being deleted
</span><del>- for (auto& floatingObject : m_set) {
- ASSERT(!floatingObject->originatingLine() || &floatingObject->originatingLine()->renderer() == &m_renderer);
- floatingObject->setOriginatingLine(nullptr);
</del><ins>+ for (auto it = m_set.begin(), end = m_set.end(); it != end; ++it) {
+ ASSERT(!((*it)->originatingLine()) || &((*it)->originatingLine()->renderer()) == &m_renderer);
+ (*it)->setOriginatingLine(0);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -282,12 +282,12 @@
</span><span class="cx">
</span><span class="cx"> void FloatingObjects::moveAllToFloatInfoMap(RendererToFloatInfoMap& map)
</span><span class="cx"> {
</span><del>- for (auto& floatingObject : m_set) {
- auto& renderer = floatingObject->renderer();
</del><ins>+ for (auto it = m_set.begin(), end = m_set.end(); it != end; ++it) {
+ auto& renderer = it->get()->renderer();
</ins><span class="cx"> // FIXME: The only reason it is safe to move these out of the set is that
</span><span class="cx"> // we are about to clear it. Otherwise it would break the hash table invariant.
</span><span class="cx"> // A clean way to do this would be to add a takeAll function to HashSet.
</span><del>- map.add(&renderer, WTF::move(floatingObject));
</del><ins>+ map.add(&renderer, WTF::move(*it));
</ins><span class="cx"> }
</span><span class="cx"> clear();
</span><span class="cx"> }
</span><span class="lines">@@ -374,9 +374,10 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> m_placedFloatsTree = std::make_unique<FloatingObjectTree>();
</span><del>- for (auto& floatingObject : m_set) {
</del><ins>+ for (auto it = m_set.begin(), end = m_set.end(); it != end; ++it) {
+ FloatingObject* floatingObject = it->get();
</ins><span class="cx"> if (floatingObject->isPlaced())
</span><del>- m_placedFloatsTree->add(intervalForFloatingObject(floatingObject.get()));
</del><ins>+ m_placedFloatsTree->add(intervalForFloatingObject(floatingObject));
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingFlowThreadControllercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/FlowThreadController.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/FlowThreadController.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/FlowThreadController.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -274,7 +274,8 @@
</span><span class="cx">
</span><span class="cx"> RenderLayer* flowThreadLayer = flowRenderer->layer();
</span><span class="cx"> if (Vector<RenderLayer*>* negZOrderList = flowThreadLayer->negZOrderList()) {
</span><del>- for (auto& currLayer : *negZOrderList) {
</del><ins>+ for (size_t i = 0, size = negZOrderList->size(); i < size; ++i) {
+ RenderLayer* currLayer = negZOrderList->at(i);
</ins><span class="cx"> if (currLayer->renderer().style().position() != FixedPosition)
</span><span class="cx"> continue;
</span><span class="cx"> fixedPosLayers.append(currLayer);
</span><span class="lines">@@ -282,7 +283,8 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (Vector<RenderLayer*>* posZOrderList = flowThreadLayer->posZOrderList()) {
</span><del>- for (auto& currLayer : *posZOrderList) {
</del><ins>+ for (size_t i = 0, size = posZOrderList->size(); i < size; ++i) {
+ RenderLayer* currLayer = posZOrderList->at(i);
</ins><span class="cx"> if (currLayer->renderer().style().position() != FixedPosition)
</span><span class="cx"> continue;
</span><span class="cx"> fixedPosLayers.append(currLayer);
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingHitTestResultcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/HitTestResult.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/HitTestResult.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/HitTestResult.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -702,8 +702,8 @@
</span><span class="cx">
</span><span class="cx"> if (other.m_rectBasedTestResult) {
</span><span class="cx"> NodeSet& set = mutableRectBasedTestResult();
</span><del>- for (auto& result : *other.m_rectBasedTestResult)
- set.add(result);
</del><ins>+ for (NodeSet::const_iterator it = other.m_rectBasedTestResult->begin(), last = other.m_rectBasedTestResult->end(); it != last; ++it)
+ set.add(it->get());
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingImageQualityControllercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/ImageQualityController.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/ImageQualityController.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/ImageQualityController.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -88,8 +88,8 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- for (auto& object : m_objectLayerSizeMap.keys())
- object->repaint();
</del><ins>+ for (auto it = m_objectLayerSizeMap.begin(), end = m_objectLayerSizeMap.end(); it != end; ++it)
+ it->key->repaint();
</ins><span class="cx">
</span><span class="cx"> m_liveResizeOptimizationIsActive = false;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingInlineTextBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/InlineTextBox.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/InlineTextBox.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/InlineTextBox.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -630,7 +630,12 @@
</span><span class="cx"> paintDocumentMarkers(context, boxOrigin, lineStyle, font, false);
</span><span class="cx">
</span><span class="cx"> if (useCustomUnderlines) {
</span><del>- for (auto& underline : renderer().frame().editor().customCompositionUnderlines()) {
</del><ins>+ const Vector<CompositionUnderline>& underlines = renderer().frame().editor().customCompositionUnderlines();
+ size_t numUnderlines = underlines.size();
+
+ for (size_t index = 0; index < numUnderlines; ++index) {
+ const CompositionUnderline& underline = underlines[index];
+
</ins><span class="cx"> if (underline.endOffset <= start())
</span><span class="cx"> // underline is completely before this run. This might be an underline that sits
</span><span class="cx"> // before the first run we draw, or underlines that were within runs we skipped
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlock.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlock.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderBlock.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -193,9 +193,10 @@
</span><span class="cx">
</span><span class="cx"> static void removeBlockFromDescendantAndContainerMaps(RenderBlock* block, TrackedDescendantsMap*& descendantMap, TrackedContainerMap*& containerMap)
</span><span class="cx"> {
</span><del>- if (auto descendantSet = descendantMap->take(block)) {
- for (auto& box : *descendantSet) {
- auto it = containerMap->find(box);
</del><ins>+ if (std::unique_ptr<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);
</ins><span class="cx"> ASSERT(it != containerMap->end());
</span><span class="cx"> if (it == containerMap->end())
</span><span class="cx"> continue;
</span><span class="lines">@@ -1050,7 +1051,9 @@
</span><span class="cx"> if (!positionedDescendants)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- for (auto& positionedObject : *positionedDescendants) {
</del><ins>+ for (auto it = positionedDescendants->begin(), end = positionedDescendants->end(); it != end; ++it) {
+ RenderBox* positionedObject = *it;
+
</ins><span class="cx"> // Fixed positioned elements don't contribute to layout overflow, since they don't scroll with the content.
</span><span class="cx"> if (positionedObject->style().position() != FixedPosition) {
</span><span class="cx"> LayoutUnit x = positionedObject->x();
</span><span class="lines">@@ -1145,7 +1148,8 @@
</span><span class="cx"> if (!descendants)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- for (auto& box : *descendants) {
</del><ins>+ for (auto it = descendants->begin(), end = descendants->end(); it != end; ++it) {
+ RenderBox* box = *it;
</ins><span class="cx"> while (box != this) {
</span><span class="cx"> if (box->normalChildNeedsLayout())
</span><span class="cx"> break;
</span><span class="lines">@@ -1182,9 +1186,11 @@
</span><span class="cx">
</span><span class="cx"> // FIXME: Glyph overflow will get lost in this case, but not really a big deal.
</span><span class="cx"> // FIXME: Find a way to invalidate the knownToHaveNoOverflow flag on the InlineBoxes.
</span><del>- GlyphOverflowAndFallbackFontsMap textBoxDataMap;
- for (auto& box : lineBoxes)
</del><ins>+ GlyphOverflowAndFallbackFontsMap textBoxDataMap;
+ for (auto it = lineBoxes.begin(), end = lineBoxes.end(); it != end; ++it) {
+ RootInlineBox* box = *it;
</ins><span class="cx"> box->computeOverflow(box->lineTop(), box->lineBottom(), textBoxDataMap);
</span><ins>+ }
</ins><span class="cx"> } else {
</span><span class="cx"> for (auto box = firstChildBox(); box; box = box->nextSiblingBox()) {
</span><span class="cx"> if (!box->isOutOfFlowPositioned())
</span><span class="lines">@@ -1293,15 +1299,17 @@
</span><span class="cx"> if (!positionedDescendants)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- for (auto& box : *positionedDescendants) {
- estimateRegionRangeForBoxChild(*box);
</del><ins>+ for (auto it = positionedDescendants->begin(), end = positionedDescendants->end(); it != end; ++it) {
+ RenderBox& r = **it;
+
+ estimateRegionRangeForBoxChild(r);
</ins><span class="cx">
</span><span class="cx"> // A fixed position element with an absolute positioned ancestor has no way of knowing if the latter has changed position. So
</span><span class="cx"> // 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.
</span><span class="cx"> // it has static position.
</span><del>- markFixedPositionObjectForLayoutIfNeeded(*box);
</del><ins>+ markFixedPositionObjectForLayoutIfNeeded(r);
</ins><span class="cx"> if (fixedPositionObjectsOnly) {
</span><del>- box->layoutIfNeeded();
</del><ins>+ r.layoutIfNeeded();
</ins><span class="cx"> continue;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1309,43 +1317,43 @@
</span><span class="cx"> // non-positioned block. Rather than trying to detect all of these movement cases, we just always lay out positioned
</span><span class="cx"> // objects that are positioned implicitly like this. Such objects are rare, and so in typical DHTML menu usage (where everything is
</span><span class="cx"> // positioned explicitly) this should not incur a performance penalty.
</span><del>- if (relayoutChildren || (box->style().hasStaticBlockPosition(isHorizontalWritingMode()) && box->parent() != this))
- box->setChildNeedsLayout(MarkOnlyThis);
</del><ins>+ if (relayoutChildren || (r.style().hasStaticBlockPosition(isHorizontalWritingMode()) && r.parent() != this))
+ r.setChildNeedsLayout(MarkOnlyThis);
</ins><span class="cx">
</span><span class="cx"> // If relayoutChildren is set and the child has percentage padding or an embedded content box, we also need to invalidate the childs pref widths.
</span><del>- if (relayoutChildren && box->needsPreferredWidthsRecalculation())
- box->setPreferredLogicalWidthsDirty(true, MarkOnlyThis);
</del><ins>+ if (relayoutChildren && r.needsPreferredWidthsRecalculation())
+ r.setPreferredLogicalWidthsDirty(true, MarkOnlyThis);
</ins><span class="cx">
</span><del>- box->markForPaginationRelayoutIfNeeded();
</del><ins>+ r.markForPaginationRelayoutIfNeeded();
</ins><span class="cx">
</span><span class="cx"> // We don't have to do a full layout. We just have to update our position. Try that first. If we have shrink-to-fit width
</span><span class="cx"> // and we hit the available width constraint, the layoutIfNeeded() will catch it and do a full layout.
</span><del>- if (box->needsPositionedMovementLayoutOnly() && box->tryLayoutDoingPositionedMovementOnly())
- box->clearNeedsLayout();
</del><ins>+ if (r.needsPositionedMovementLayoutOnly() && r.tryLayoutDoingPositionedMovementOnly())
+ r.clearNeedsLayout();
</ins><span class="cx">
</span><span class="cx"> // If we are paginated or in a line grid, compute a vertical position for our object now.
</span><span class="cx"> // If it's wrong we'll lay out again.
</span><span class="cx"> LayoutUnit oldLogicalTop = 0;
</span><del>- bool needsBlockDirectionLocationSetBeforeLayout = box->needsLayout() && view().layoutState()->needsBlockDirectionLocationSetBeforeLayout();
</del><ins>+ bool needsBlockDirectionLocationSetBeforeLayout = r.needsLayout() && view().layoutState()->needsBlockDirectionLocationSetBeforeLayout();
</ins><span class="cx"> if (needsBlockDirectionLocationSetBeforeLayout) {
</span><del>- if (isHorizontalWritingMode() == box->isHorizontalWritingMode())
- box->updateLogicalHeight();
</del><ins>+ if (isHorizontalWritingMode() == r.isHorizontalWritingMode())
+ r.updateLogicalHeight();
</ins><span class="cx"> else
</span><del>- box->updateLogicalWidth();
- oldLogicalTop = logicalTopForChild(*box);
</del><ins>+ r.updateLogicalWidth();
+ oldLogicalTop = logicalTopForChild(r);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- box->layoutIfNeeded();
</del><ins>+ r.layoutIfNeeded();
</ins><span class="cx">
</span><span class="cx"> // Lay out again if our estimate was wrong.
</span><del>- if (needsBlockDirectionLocationSetBeforeLayout && logicalTopForChild(*box) != oldLogicalTop) {
- box->setChildNeedsLayout(MarkOnlyThis);
- box->layoutIfNeeded();
</del><ins>+ if (needsBlockDirectionLocationSetBeforeLayout && logicalTopForChild(r) != oldLogicalTop) {
+ r.setChildNeedsLayout(MarkOnlyThis);
+ r.layoutIfNeeded();
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- if (updateRegionRangeForBoxChild(*box)) {
- box->setNeedsLayout(MarkOnlyThis);
- box->layoutIfNeeded();
</del><ins>+ if (updateRegionRangeForBoxChild(r)) {
+ r.setNeedsLayout(MarkOnlyThis);
+ r.layoutIfNeeded();
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -1356,8 +1364,10 @@
</span><span class="cx"> if (!positionedDescendants)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- for (auto& box : *positionedDescendants)
- box->setChildNeedsLayout();
</del><ins>+ for (auto it = positionedDescendants->begin(), end = positionedDescendants->end(); it != end; ++it) {
+ RenderBox* r = *it;
+ r->setChildNeedsLayout();
+ }
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderBlock::markForPaginationRelayoutIfNeeded()
</span><span class="lines">@@ -1681,8 +1691,10 @@
</span><span class="cx">
</span><span class="cx"> LayoutPoint accumulatedPaintOffset = paintOffset;
</span><span class="cx"> // Paint each continuation outline.
</span><del>- for (auto& flow : *continuations) {
</del><ins>+ ListHashSet<RenderInline*>::iterator end = continuations->end();
+ for (ListHashSet<RenderInline*>::iterator it = continuations->begin(); it != end; ++it) {
</ins><span class="cx"> // Need to add in the coordinates of the intervening blocks.
</span><ins>+ RenderInline* flow = *it;
</ins><span class="cx"> RenderBlock* block = flow->containingBlock();
</span><span class="cx"> for ( ; block && block != this; block = block->containingBlock())
</span><span class="cx"> accumulatedPaintOffset.moveBy(block->location());
</span><span class="lines">@@ -1776,8 +1788,11 @@
</span><span class="cx"> if (!positionedObjects)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- for (auto& object : *positionedObjects)
- paintInfo->context->clipOut(IntRect(offset.x() + object->x(), offset.y() + object->y(), object->width(), object->height()));
</del><ins>+ TrackedRendererListHashSet::const_iterator end = positionedObjects->end();
+ for (TrackedRendererListHashSet::const_iterator it = positionedObjects->begin(); it != end; ++it) {
+ RenderBox* r = *it;
+ paintInfo->context->clipOut(IntRect(offset.x() + r->x(), offset.y() + r->y(), r->width(), r->height()));
+ }
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LayoutUnit blockDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock)
</span><span class="lines">@@ -2108,7 +2123,9 @@
</span><span class="cx"> if (!containerSet)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- for (auto& container : *containerSet) {
</del><ins>+ for (auto it = containerSet->begin(), end = containerSet->end(); it != end; ++it) {
+ RenderBlock* container = *it;
+
</ins><span class="cx"> // FIXME: Disabling this assert temporarily until we fix the layout
</span><span class="cx"> // bugs associated with positioned objects not properly cleared from
</span><span class="cx"> // their ancestor chain before being moved. See webkit bug 93766.
</span><span class="lines">@@ -2156,25 +2173,26 @@
</span><span class="cx">
</span><span class="cx"> Vector<RenderBox*, 16> deadObjects;
</span><span class="cx">
</span><del>- for (auto& box : *positionedDescendants) {
- if (!o || box->isDescendantOf(o)) {
</del><ins>+ for (auto it = positionedDescendants->begin(), end = positionedDescendants->end(); it != end; ++it) {
+ RenderBox* r = *it;
+ if (!o || r->isDescendantOf(o)) {
</ins><span class="cx"> if (containingBlockState == NewContainingBlock)
</span><del>- box->setChildNeedsLayout(MarkOnlyThis);
</del><ins>+ r->setChildNeedsLayout(MarkOnlyThis);
</ins><span class="cx">
</span><span class="cx"> // It is parent blocks job to add positioned child to positioned objects list of its containing block
</span><span class="cx"> // Parent layout needs to be invalidated to ensure this happens.
</span><del>- RenderElement* p = box->parent();
</del><ins>+ RenderElement* p = r->parent();
</ins><span class="cx"> while (p && !p->isRenderBlock())
</span><span class="cx"> p = p->parent();
</span><span class="cx"> if (p)
</span><span class="cx"> p->setChildNeedsLayout();
</span><span class="cx">
</span><del>- deadObjects.append(box);
</del><ins>+ deadObjects.append(r);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- for (auto& object : deadObjects)
- removePositionedObject(*object);
</del><ins>+ for (unsigned i = 0; i < deadObjects.size(); i++)
+ removePositionedObject(*deadObjects.at(i));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderBlock::addPercentHeightDescendant(RenderBox& descendant)
</span><span class="lines">@@ -3725,8 +3743,10 @@
</span><span class="cx"> if (!positionedDescendantSet)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- for (auto& box : *positionedDescendantSet)
- ASSERT(!box->needsLayout());
</del><ins>+ for (auto it = positionedDescendantSet->begin(), end = positionedDescendantSet->end(); it != end; ++it) {
+ RenderBox* currBox = *it;
+ ASSERT(!currBox->needsLayout());
+ }
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #endif
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockFlowcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlockFlow.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlockFlow.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderBlockFlow.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -203,7 +203,10 @@
</span><span class="cx">
</span><span class="cx"> HashSet<RenderBox*> oldIntrudingFloatSet;
</span><span class="cx"> if (!childrenInline() && m_floatingObjects) {
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* floatingObject = it->get();
</ins><span class="cx"> if (!floatingObject->isDescendant())
</span><span class="cx"> oldIntrudingFloatSet.add(&floatingObject->renderer());
</span><span class="cx"> }
</span><span class="lines">@@ -261,12 +264,15 @@
</span><span class="cx"> LayoutUnit changeLogicalTop = LayoutUnit::max();
</span><span class="cx"> LayoutUnit changeLogicalBottom = LayoutUnit::min();
</span><span class="cx"> if (m_floatingObjects) {
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* floatingObject = it->get();
</ins><span class="cx"> std::unique_ptr<FloatingObject> oldFloatingObject = floatMap.take(&floatingObject->renderer());
</span><del>- LayoutUnit logicalBottom = logicalBottomForFloat(floatingObject.get());
</del><ins>+ LayoutUnit logicalBottom = logicalBottomForFloat(floatingObject);
</ins><span class="cx"> if (oldFloatingObject) {
</span><span class="cx"> LayoutUnit oldLogicalBottom = logicalBottomForFloat(oldFloatingObject.get());
</span><del>- if (logicalWidthForFloat(floatingObject.get()) != logicalWidthForFloat(oldFloatingObject.get()) || logicalLeftForFloat(floatingObject.get()) != logicalLeftForFloat(oldFloatingObject.get())) {
</del><ins>+ if (logicalWidthForFloat(floatingObject) != logicalWidthForFloat(oldFloatingObject.get()) || logicalLeftForFloat(floatingObject) != logicalLeftForFloat(oldFloatingObject.get())) {
</ins><span class="cx"> changeLogicalTop = 0;
</span><span class="cx"> changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalBottom, oldLogicalBottom));
</span><span class="cx"> } else {
</span><span class="lines">@@ -274,7 +280,7 @@
</span><span class="cx"> changeLogicalTop = std::min(changeLogicalTop, std::min(logicalBottom, oldLogicalBottom));
</span><span class="cx"> changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalBottom, oldLogicalBottom));
</span><span class="cx"> }
</span><del>- LayoutUnit logicalTop = logicalTopForFloat(floatingObject.get());
</del><ins>+ LayoutUnit logicalTop = logicalTopForFloat(floatingObject);
</ins><span class="cx"> LayoutUnit oldLogicalTop = logicalTopForFloat(oldFloatingObject.get());
</span><span class="cx"> if (logicalTop != oldLogicalTop) {
</span><span class="cx"> changeLogicalTop = std::min(changeLogicalTop, std::min(logicalTop, oldLogicalTop));
</span><span class="lines">@@ -293,10 +299,12 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- for (auto& floatingObject : floatMap.values()) {
</del><ins>+ auto end = floatMap.end();
+ for (auto it = floatMap.begin(); it != end; ++it) {
+ FloatingObject* floatingObject = it->value.get();
</ins><span class="cx"> if (!floatingObject->isDescendant()) {
</span><span class="cx"> changeLogicalTop = 0;
</span><del>- changeLogicalBottom = std::max(changeLogicalBottom, logicalBottomForFloat(floatingObject.get()));
</del><ins>+ changeLogicalBottom = std::max(changeLogicalBottom, logicalBottomForFloat(floatingObject));
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -307,8 +315,10 @@
</span><span class="cx"> if (m_floatingObjects->set().size() < oldIntrudingFloatSet.size())
</span><span class="cx"> markAllDescendantsWithFloatsForLayout();
</span><span class="cx"> else {
</span><del>- for (auto& floatingObject : m_floatingObjects->set())
- oldIntrudingFloatSet.remove(&floatingObject->renderer());
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end && !oldIntrudingFloatSet.isEmpty(); ++it)
+ oldIntrudingFloatSet.remove(&(*it)->renderer());
</ins><span class="cx"> if (!oldIntrudingFloatSet.isEmpty())
</span><span class="cx"> markAllDescendantsWithFloatsForLayout();
</span><span class="cx"> }
</span><span class="lines">@@ -1972,8 +1982,8 @@
</span><span class="cx"> if (ancestor.isRenderView())
</span><span class="cx"> break;
</span><span class="cx"> if (ancestor.hasOverhangingFloats()) {
</span><del>- for (auto& floatingObject : floatingObjectSet) {
- RenderBox& renderer = floatingObject->renderer();
</del><ins>+ for (auto it = floatingObjectSet.begin(), end = floatingObjectSet.end(); it != end; ++it) {
+ RenderBox& renderer = (*it)->renderer();
</ins><span class="cx"> if (ancestor.hasOverhangingFloat(renderer)) {
</span><span class="cx"> parentBlock = &ancestor;
</span><span class="cx"> break;
</span><span class="lines">@@ -2060,7 +2070,12 @@
</span><span class="cx"> if (!toBlockFlow->m_floatingObjects)
</span><span class="cx"> toBlockFlow->createFloatingObjects();
</span><span class="cx">
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
</del><ins>+ const FloatingObjectSet& fromFloatingObjectSet = m_floatingObjects->set();
+ auto end = fromFloatingObjectSet.end();
+
+ for (auto it = fromFloatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* floatingObject = it->get();
+
</ins><span class="cx"> // Don't insert the object again if it's already in the list
</span><span class="cx"> if (toBlockFlow->containsFloat(floatingObject->renderer()))
</span><span class="cx"> continue;
</span><span class="lines">@@ -2082,9 +2097,12 @@
</span><span class="cx"> if (!m_floatingObjects)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
- if (floatingObject->isDescendant())
- addOverflowFromChild(&floatingObject->renderer(), IntSize(xPositionForFloatIncludingMargin(floatingObject.get()), yPositionForFloatIncludingMargin(floatingObject.get())));
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* r = it->get();
+ if (r->isDescendant())
+ addOverflowFromChild(&r->renderer(), IntSize(xPositionForFloatIncludingMargin(r), yPositionForFloatIncludingMargin(r)));
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2106,11 +2124,14 @@
</span><span class="cx"> // FIXME: Avoid disabling LayoutState. At the very least, don't disable it for floats originating
</span><span class="cx"> // in this block. Better yet would be to push extra state for the containers of other floats.
</span><span class="cx"> LayoutStateDisabler layoutStateDisabler(&view());
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* floatingObject = it->get();
</ins><span class="cx"> // Only repaint the object if it is overhanging, is not in its own layer, and
</span><span class="cx"> // is our responsibility to paint (m_shouldPaint is set). When paintAllDescendants is true, the latter
</span><span class="cx"> // condition is replaced with being a descendant of us.
</span><del>- if (logicalBottomForFloat(floatingObject.get()) > logicalHeight()
</del><ins>+ if (logicalBottomForFloat(floatingObject) > logicalHeight()
</ins><span class="cx"> && !floatingObject->renderer().hasSelfPaintingLayer()
</span><span class="cx"> && (floatingObject->shouldPaint() || (paintAllDescendants && floatingObject->renderer().isDescendantOf(this)))) {
</span><span class="cx"> floatingObject->renderer().repaint();
</span><span class="lines">@@ -2138,23 +2159,26 @@
</span><span class="cx"> if (!m_floatingObjects)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* r = it->get();
</ins><span class="cx"> // Only paint the object if our m_shouldPaint flag is set.
</span><del>- if (floatingObject->shouldPaint() && !floatingObject->renderer().hasSelfPaintingLayer()) {
</del><ins>+ if (r->shouldPaint() && !r->renderer().hasSelfPaintingLayer()) {
</ins><span class="cx"> PaintInfo currentPaintInfo(paintInfo);
</span><span class="cx"> currentPaintInfo.phase = preservePhase ? paintInfo.phase : PaintPhaseBlockBackground;
</span><span class="cx"> // FIXME: LayoutPoint version of xPositionForFloatIncludingMargin would make this much cleaner.
</span><del>- LayoutPoint childPoint = flipFloatForWritingModeForChild(floatingObject.get(), LayoutPoint(paintOffset.x() + xPositionForFloatIncludingMargin(floatingObject.get()) - floatingObject->renderer().x(), paintOffset.y() + yPositionForFloatIncludingMargin(floatingObject.get()) - floatingObject->renderer().y()));
- floatingObject->renderer().paint(currentPaintInfo, childPoint);
</del><ins>+ LayoutPoint childPoint = flipFloatForWritingModeForChild(r, LayoutPoint(paintOffset.x() + xPositionForFloatIncludingMargin(r) - r->renderer().x(), paintOffset.y() + yPositionForFloatIncludingMargin(r) - r->renderer().y()));
+ r->renderer().paint(currentPaintInfo, childPoint);
</ins><span class="cx"> if (!preservePhase) {
</span><span class="cx"> currentPaintInfo.phase = PaintPhaseChildBlockBackgrounds;
</span><del>- floatingObject->renderer().paint(currentPaintInfo, childPoint);
</del><ins>+ r->renderer().paint(currentPaintInfo, childPoint);
</ins><span class="cx"> currentPaintInfo.phase = PaintPhaseFloat;
</span><del>- floatingObject->renderer().paint(currentPaintInfo, childPoint);
</del><ins>+ r->renderer().paint(currentPaintInfo, childPoint);
</ins><span class="cx"> currentPaintInfo.phase = PaintPhaseForeground;
</span><del>- floatingObject->renderer().paint(currentPaintInfo, childPoint);
</del><ins>+ r->renderer().paint(currentPaintInfo, childPoint);
</ins><span class="cx"> currentPaintInfo.phase = PaintPhaseOutline;
</span><del>- floatingObject->renderer().paint(currentPaintInfo, childPoint);
</del><ins>+ r->renderer().paint(currentPaintInfo, childPoint);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -2163,9 +2187,12 @@
</span><span class="cx"> void RenderBlockFlow::clipOutFloatingObjects(RenderBlock& rootBlock, const PaintInfo* paintInfo, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock)
</span><span class="cx"> {
</span><span class="cx"> if (m_floatingObjects) {
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
- LayoutRect floatBox(offsetFromRootBlock.width() + xPositionForFloatIncludingMargin(floatingObject.get()),
- offsetFromRootBlock.height() + yPositionForFloatIncludingMargin(floatingObject.get()),
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* floatingObject = it->get();
+ LayoutRect floatBox(offsetFromRootBlock.width() + xPositionForFloatIncludingMargin(floatingObject),
+ offsetFromRootBlock.height() + yPositionForFloatIncludingMargin(floatingObject),
</ins><span class="cx"> floatingObject->renderer().width(), floatingObject->renderer().height());
</span><span class="cx"> rootBlock.flipForWritingMode(floatBox);
</span><span class="cx"> floatBox.move(rootBlockPhysicalPosition.x(), rootBlockPhysicalPosition.y());
</span><span class="lines">@@ -2563,9 +2590,12 @@
</span><span class="cx"> if (!m_floatingObjects)
</span><span class="cx"> return 0;
</span><span class="cx"> LayoutUnit lowestFloatBottom = 0;
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* floatingObject = it->get();
</ins><span class="cx"> if (floatingObject->isPlaced() && floatingObject->type() & floatType)
</span><del>- lowestFloatBottom = std::max(lowestFloatBottom, logicalBottomForFloat(floatingObject.get()));
</del><ins>+ lowestFloatBottom = std::max(lowestFloatBottom, logicalBottomForFloat(floatingObject));
</ins><span class="cx"> }
</span><span class="cx"> return lowestFloatBottom;
</span><span class="cx"> }
</span><span class="lines">@@ -2575,9 +2605,12 @@
</span><span class="cx"> if (!m_floatingObjects)
</span><span class="cx"> return 0;
</span><span class="cx"> LayoutUnit lowestFloatBottom = 0;
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* floatingObject = it->get();
</ins><span class="cx"> if (floatingObject->isPlaced() && floatingObject->renderer().style().styleType() == FIRST_LETTER && floatingObject->renderer().style().initialLetterDrop() > 0)
</span><del>- lowestFloatBottom = std::max(lowestFloatBottom, logicalBottomForFloat(floatingObject.get()));
</del><ins>+ lowestFloatBottom = std::max(lowestFloatBottom, logicalBottomForFloat(floatingObject));
</ins><span class="cx"> }
</span><span class="cx"> return lowestFloatBottom;
</span><span class="cx"> }
</span><span class="lines">@@ -2594,8 +2627,10 @@
</span><span class="cx">
</span><span class="cx"> // Floats that will remain the child's responsibility to paint should factor into its
</span><span class="cx"> // overflow.
</span><del>- for (auto& floatingObject : child.m_floatingObjects->set()) {
- LayoutUnit floatLogicalBottom = std::min(logicalBottomForFloat(floatingObject.get()), LayoutUnit::max() - childLogicalTop);
</del><ins>+ auto childEnd = child.m_floatingObjects->set().end();
+ for (auto childIt = child.m_floatingObjects->set().begin(); childIt != childEnd; ++childIt) {
+ FloatingObject* floatingObject = childIt->get();
+ LayoutUnit floatLogicalBottom = std::min(logicalBottomForFloat(floatingObject), LayoutUnit::max() - childLogicalTop);
</ins><span class="cx"> LayoutUnit logicalBottom = childLogicalTop + floatLogicalBottom;
</span><span class="cx"> lowestFloatLogicalBottom = std::max(lowestFloatLogicalBottom, logicalBottom);
</span><span class="cx">
</span><span class="lines">@@ -2632,7 +2667,7 @@
</span><span class="cx">
</span><span class="cx"> // Since the float doesn't overhang, it didn't get put into our list. We need to add its overflow in to the child now.
</span><span class="cx"> if (floatingObject->isDescendant())
</span><del>- child.addOverflowFromChild(&floatingObject->renderer(), LayoutSize(xPositionForFloatIncludingMargin(floatingObject.get()), yPositionForFloatIncludingMargin(floatingObject.get())));
</del><ins>+ child.addOverflowFromChild(&floatingObject->renderer(), LayoutSize(xPositionForFloatIncludingMargin(floatingObject), yPositionForFloatIncludingMargin(floatingObject)));
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> return lowestFloatLogicalBottom;
</span><span class="lines">@@ -2665,8 +2700,11 @@
</span><span class="cx">
</span><span class="cx"> logicalLeftOffset += marginLogicalLeft();
</span><span class="cx">
</span><del>- for (auto& floatingObject : prev->m_floatingObjects->set()) {
- if (logicalBottomForFloat(floatingObject.get()) > logicalTopOffset) {
</del><ins>+ const FloatingObjectSet& prevSet = prev->m_floatingObjects->set();
+ auto prevEnd = prevSet.end();
+ for (auto prevIt = prevSet.begin(); prevIt != prevEnd; ++prevIt) {
+ FloatingObject* floatingObject = prevIt->get();
+ if (logicalBottomForFloat(floatingObject) > logicalTopOffset) {
</ins><span class="cx"> if (!m_floatingObjects || !m_floatingObjects->set().contains<FloatingObject&, FloatingObjectHashTranslator>(*floatingObject)) {
</span><span class="cx"> // We create the floating object list lazily.
</span><span class="cx"> if (!m_floatingObjects)
</span><span class="lines">@@ -2718,13 +2756,16 @@
</span><span class="cx"> if (!m_floatingObjects)
</span><span class="cx"> return;
</span><span class="cx">
</span><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+
</ins><span class="cx"> for (RenderObject* next = nextSibling(); next; next = next->nextSibling()) {
</span><span class="cx"> if (!is<RenderBlockFlow>(*next) || next->isFloatingOrOutOfFlowPositioned())
</span><span class="cx"> continue;
</span><span class="cx">
</span><span class="cx"> RenderBlockFlow& nextBlock = downcast<RenderBlockFlow>(*next);
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
- RenderBox& floatingBox = floatingObject->renderer();
</del><ins>+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ RenderBox& floatingBox = (*it)->renderer();
</ins><span class="cx"> if (floatToRemove && &floatingBox != floatToRemove)
</span><span class="cx"> continue;
</span><span class="cx"> if (nextBlock.containsFloat(floatingBox))
</span><span class="lines">@@ -2887,11 +2928,14 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (m_floatingObjects) {
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* r = it->get();
</ins><span class="cx"> // Only examine the object if our m_shouldPaint flag is set.
</span><del>- if (floatingObject->shouldPaint()) {
- LayoutUnit floatLeft = xPositionForFloatIncludingMargin(floatingObject.get()) - floatingObject->renderer().x();
- LayoutUnit floatRight = floatLeft + floatingObject->renderer().width();
</del><ins>+ if (r->shouldPaint()) {
+ LayoutUnit floatLeft = xPositionForFloatIncludingMargin(r) - r->renderer().x();
+ LayoutUnit floatRight = floatLeft + r->renderer().width();
</ins><span class="cx"> left = std::min(left, floatLeft);
</span><span class="cx"> right = std::max(right, floatRight);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockLineLayoutcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -512,8 +512,9 @@
</span><span class="cx"> } else
</span><span class="cx"> measuredWidth += wordMeasurement.width;
</span><span class="cx"> if (!wordMeasurement.fallbackFonts.isEmpty()) {
</span><del>- for (auto& font : wordMeasurement.fallbackFonts)
- fallbackFonts.add(font);
</del><ins>+ HashSet<const Font*>::const_iterator end = wordMeasurement.fallbackFonts.end();
+ for (HashSet<const Font*>::const_iterator it = wordMeasurement.fallbackFonts.begin(); it != end; ++it)
+ fallbackFonts.add(*it);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> if (measuredWidth && lastEndOffset != run->m_stop) {
</span><span class="lines">@@ -1335,8 +1336,8 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- for (auto& positionedObject : lineBreaker.positionedObjects())
- setStaticPositions(*this, *positionedObject);
</del><ins>+ for (size_t i = 0; i < lineBreaker.positionedObjects().size(); ++i)
+ setStaticPositions(*this, *lineBreaker.positionedObjects()[i]);
</ins><span class="cx">
</span><span class="cx"> if (!layoutState.lineInfo().isEmpty()) {
</span><span class="cx"> layoutState.lineInfo().setFirstLine(false);
</span><span class="lines">@@ -1453,7 +1454,8 @@
</span><span class="cx"> if (layoutState.flowThread())
</span><span class="cx"> updateRegionForLine(line);
</span><span class="cx"> if (Vector<RenderBox*>* cleanLineFloats = line->floatsPtr()) {
</span><del>- for (auto& floatingBox : *cleanLineFloats) {
</del><ins>+ for (auto it = cleanLineFloats->begin(), end = cleanLineFloats->end(); it != end; ++it) {
+ RenderBox* floatingBox = *it;
</ins><span class="cx"> FloatingObject* floatingObject = insertFloatingObject(*floatingBox);
</span><span class="cx"> ASSERT(!floatingObject->originatingLine());
</span><span class="cx"> floatingObject->setOriginatingLine(line);
</span><span class="lines">@@ -1510,12 +1512,13 @@
</span><span class="cx">
</span><span class="cx"> void RenderBlockFlow::repaintDirtyFloats(Vector<FloatWithRect>& floats)
</span><span class="cx"> {
</span><ins>+ size_t floatCount = floats.size();
</ins><span class="cx"> // Floats that did not have layout did not repaint when we laid them out. They would have
</span><span class="cx"> // painted by now if they had moved, but if they stayed at (0, 0), they still need to be
</span><span class="cx"> // painted.
</span><del>- for (auto& floatWithRect : floats) {
- if (!floatWithRect.everHadLayout) {
- RenderBox& box = floatWithRect.object;
</del><ins>+ for (size_t i = 0; i < floatCount; ++i) {
+ if (!floats[i].everHadLayout) {
+ RenderBox& box = floats[i].object;
</ins><span class="cx"> if (!box.x() && !box.y() && box.checkForRepaintDuringLayout())
</span><span class="cx"> box.repaint();
</span><span class="cx"> }
</span><span class="lines">@@ -1603,8 +1606,8 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- for (auto& child : replacedChildren)
- child->layoutIfNeeded();
</del><ins>+ for (size_t i = 0; i < replacedChildren.size(); i++)
+ replacedChildren[i]->layoutIfNeeded();
</ins><span class="cx">
</span><span class="cx"> layoutRunsAndFloats(layoutState, hasInlineChild);
</span><span class="cx"> }
</span><span class="lines">@@ -1642,7 +1645,8 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- for (auto& floatingBox : *cleanLineFloats) {
</del><ins>+ for (auto it = cleanLineFloats->begin(), end = cleanLineFloats->end(); it != end; ++it) {
+ RenderBox* floatingBox = *it;
</ins><span class="cx"> floatingBox->layoutIfNeeded();
</span><span class="cx"> LayoutSize newSize(floatingBox->width() + floatingBox->horizontalMarginExtent(), floatingBox->height() + floatingBox->verticalMarginExtent());
</span><span class="cx"> ASSERT_WITH_SECURITY_IMPLICATION(floatIndex < floats.size());
</span><span class="lines">@@ -1743,7 +1747,8 @@
</span><span class="cx"> RootInlineBox* line = firstRootBox();
</span><span class="cx"> while (line != curr) {
</span><span class="cx"> if (Vector<RenderBox*>* cleanLineFloats = line->floatsPtr()) {
</span><del>- for (auto& floatingBox : *cleanLineFloats) {
</del><ins>+ for (auto it = cleanLineFloats->begin(), end = cleanLineFloats->end(); it != end; ++it) {
+ RenderBox* floatingBox = *it;
</ins><span class="cx"> FloatingObject* floatingObject = insertFloatingObject(*floatingBox);
</span><span class="cx"> ASSERT(!floatingObject->originatingLine());
</span><span class="cx"> floatingObject->setOriginatingLine(line);
</span><span class="lines">@@ -1850,8 +1855,11 @@
</span><span class="cx">
</span><span class="cx"> LayoutUnit logicalBottom = lastLine->lineBottomWithLeading() + absoluteValue(lineDelta);
</span><span class="cx">
</span><del>- for (auto& floatingObject : m_floatingObjects->set()) {
- if (logicalBottomForFloat(floatingObject.get()) >= logicalTop && logicalBottomForFloat(floatingObject.get()) < logicalBottom)
</del><ins>+ const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
+ auto end = floatingObjectSet.end();
+ for (auto it = floatingObjectSet.begin(); it != end; ++it) {
+ FloatingObject* floatingObject = it->get();
+ if (logicalBottomForFloat(floatingObject) >= logicalTop && logicalBottomForFloat(floatingObject) < logicalBottom)
</ins><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderCountercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderCounter.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderCounter.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderCounter.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -455,8 +455,11 @@
</span><span class="cx"> CounterMaps::iterator mapsIterator = maps.find(&owner);
</span><span class="cx"> if (mapsIterator == maps.end())
</span><span class="cx"> return;
</span><del>- for (auto& counter : *mapsIterator->value.get())
- destroyCounterNodeWithoutMapRemoval(counter.key, counter.value.get());
</del><ins>+ CounterMap* map = mapsIterator->value.get();
+ CounterMap::const_iterator end = map->end();
+ for (CounterMap::const_iterator it = map->begin(); it != end; ++it) {
+ destroyCounterNodeWithoutMapRemoval(it->key, it->value.get());
+ }
</ins><span class="cx"> maps.remove(mapsIterator);
</span><span class="cx"> owner.setHasCounterNodeMap(false);
</span><span class="cx"> }
</span><span class="lines">@@ -505,24 +508,25 @@
</span><span class="cx"> const CounterDirectiveMap* directiveMap = renderer.style().counterDirectives();
</span><span class="cx"> if (!directiveMap)
</span><span class="cx"> return;
</span><ins>+ CounterDirectiveMap::const_iterator end = directiveMap->end();
</ins><span class="cx"> if (!renderer.hasCounterNodeMap()) {
</span><del>- for (auto& key : directiveMap->keys())
- makeCounterNode(renderer, key, false);
</del><ins>+ for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it)
+ makeCounterNode(renderer, it->key, false);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> CounterMap* counterMap = counterMaps().get(&renderer);
</span><span class="cx"> ASSERT(counterMap);
</span><del>- for (auto& key : directiveMap->keys()) {
- RefPtr<CounterNode> node = counterMap->get(key);
</del><ins>+ for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it) {
+ RefPtr<CounterNode> node = counterMap->get(it->key);
</ins><span class="cx"> if (!node) {
</span><del>- makeCounterNode(renderer, key, false);
</del><ins>+ makeCounterNode(renderer, it->key, false);
</ins><span class="cx"> continue;
</span><span class="cx"> }
</span><span class="cx"> RefPtr<CounterNode> newParent = 0;
</span><span class="cx"> RefPtr<CounterNode> newPreviousSibling = 0;
</span><span class="cx">
</span><del>- findPlaceForCounter(renderer, key, node->hasResetType(), newParent, newPreviousSibling);
- if (node != counterMap->get(key))
</del><ins>+ findPlaceForCounter(renderer, it->key, node->hasResetType(), newParent, newPreviousSibling);
+ if (node != counterMap->get(it->key))
</ins><span class="cx"> continue;
</span><span class="cx"> CounterNode* parent = node->parent();
</span><span class="cx"> if (newParent == parent && newPreviousSibling == node->previousSibling())
</span><span class="lines">@@ -530,7 +534,7 @@
</span><span class="cx"> if (parent)
</span><span class="cx"> parent->removeChild(node.get());
</span><span class="cx"> if (newParent)
</span><del>- newParent->insertAfter(node.get(), newPreviousSibling.get(), key);
</del><ins>+ newParent->insertAfter(node.get(), newPreviousSibling.get(), it->key);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -560,33 +564,36 @@
</span><span class="cx"> const CounterDirectiveMap* oldCounterDirectives;
</span><span class="cx"> if (oldStyle && (oldCounterDirectives = oldStyle->counterDirectives())) {
</span><span class="cx"> if (newStyle && (newCounterDirectives = newStyle->counterDirectives())) {
</span><del>- for (auto& directive : *newCounterDirectives) {
- auto oldMapIt = oldCounterDirectives->find(directive.key);
- if (oldMapIt != oldCounterDirectives->end()) {
- if (oldMapIt->value == directive.value)
</del><ins>+ CounterDirectiveMap::const_iterator newMapEnd = newCounterDirectives->end();
+ CounterDirectiveMap::const_iterator oldMapEnd = oldCounterDirectives->end();
+ for (CounterDirectiveMap::const_iterator it = newCounterDirectives->begin(); it != newMapEnd; ++it) {
+ CounterDirectiveMap::const_iterator oldMapIt = oldCounterDirectives->find(it->key);
+ if (oldMapIt != oldMapEnd) {
+ if (oldMapIt->value == it->value)
</ins><span class="cx"> continue;
</span><del>- RenderCounter::destroyCounterNode(renderer, directive.key);
</del><ins>+ RenderCounter::destroyCounterNode(renderer, it->key);
</ins><span class="cx"> }
</span><span class="cx"> // We must create this node here, because the changed node may be a node with no display such as
</span><span class="cx"> // as those created by the increment or reset directives and the re-layout that will happen will
</span><span class="cx"> // not catch the change if the node had no children.
</span><del>- makeCounterNode(renderer, directive.key, false);
</del><ins>+ makeCounterNode(renderer, it->key, false);
</ins><span class="cx"> }
</span><span class="cx"> // Destroying old counters that do not exist in the new counterDirective map.
</span><del>- for (auto& key : oldCounterDirectives->keys()) {
- if (!newCounterDirectives->contains(key))
- RenderCounter::destroyCounterNode(renderer, key);
</del><ins>+ for (CounterDirectiveMap::const_iterator it = oldCounterDirectives->begin(); it !=oldMapEnd; ++it) {
+ if (!newCounterDirectives->contains(it->key))
+ RenderCounter::destroyCounterNode(renderer, it->key);
</ins><span class="cx"> }
</span><span class="cx"> } else {
</span><span class="cx"> if (renderer.hasCounterNodeMap())
</span><span class="cx"> RenderCounter::destroyCounterNodes(renderer);
</span><span class="cx"> }
</span><span class="cx"> } else if (newStyle && (newCounterDirectives = newStyle->counterDirectives())) {
</span><del>- for (auto& key : newCounterDirectives->keys()) {
</del><ins>+ CounterDirectiveMap::const_iterator newMapEnd = newCounterDirectives->end();
+ for (CounterDirectiveMap::const_iterator it = newCounterDirectives->begin(); it != newMapEnd; ++it) {
</ins><span class="cx"> // We must create this node here, because the added node may be a node with no display such as
</span><span class="cx"> // as those created by the increment or reset directives and the re-layout that will happen will
</span><span class="cx"> // not catch the change if the node had no children.
</span><del>- makeCounterNode(renderer, key, false);
</del><ins>+ makeCounterNode(renderer, it->key, false);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderFlexibleBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -713,7 +713,8 @@
</span><span class="cx">
</span><span class="cx"> int numberOfAutoMargins = 0;
</span><span class="cx"> bool isHorizontal = isHorizontalFlow();
</span><del>- for (auto& child : children) {
</del><ins>+ for (size_t i = 0; i < children.size(); ++i) {
+ RenderBox* child = children[i];
</ins><span class="cx"> if (child->isOutOfFlowPositioned())
</span><span class="cx"> continue;
</span><span class="cx"> if (isHorizontal) {
</span><span class="lines">@@ -897,9 +898,9 @@
</span><span class="cx">
</span><span class="cx"> void RenderFlexibleBox::freezeViolations(const Vector<Violation>& violations, LayoutUnit& availableFreeSpace, double& totalFlexGrow, double& totalWeightedFlexShrink, InflexibleFlexItemSize& inflexibleItems, bool hasInfiniteLineLength)
</span><span class="cx"> {
</span><del>- for (auto& violation : violations) {
- RenderBox& child = violation.child;
- LayoutUnit childSize = violation.childSize;
</del><ins>+ for (size_t i = 0; i < violations.size(); ++i) {
+ RenderBox& child = violations[i].child;
+ LayoutUnit childSize = violations[i].childSize;
</ins><span class="cx"> LayoutUnit preferredChildSize = preferredMainAxisContentExtentForChild(child, hasInfiniteLineLength);
</span><span class="cx"> availableFreeSpace -= childSize - preferredChildSize;
</span><span class="cx"> totalFlexGrow -= child.style().flexGrow();
</span><span class="lines">@@ -916,34 +917,35 @@
</span><span class="cx"> LayoutUnit usedFreeSpace = 0;
</span><span class="cx"> Vector<Violation> minViolations;
</span><span class="cx"> Vector<Violation> maxViolations;
</span><del>- for (auto& child : children) {
- if (child->isOutOfFlowPositioned()) {
</del><ins>+ for (size_t i = 0; i < children.size(); ++i) {
+ RenderBox& child = *children[i];
+ if (child.isOutOfFlowPositioned()) {
</ins><span class="cx"> childSizes.append(0);
</span><span class="cx"> continue;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (inflexibleItems.contains(child))
- childSizes.append(inflexibleItems.get(child));
</del><ins>+ if (inflexibleItems.contains(&child))
+ childSizes.append(inflexibleItems.get(&child));
</ins><span class="cx"> else {
</span><del>- LayoutUnit preferredChildSize = preferredMainAxisContentExtentForChild(*child, hasInfiniteLineLength);
</del><ins>+ LayoutUnit preferredChildSize = preferredMainAxisContentExtentForChild(child, hasInfiniteLineLength);
</ins><span class="cx"> LayoutUnit childSize = preferredChildSize;
</span><span class="cx"> double extraSpace = 0;
</span><span class="cx"> if (availableFreeSpace > 0 && totalFlexGrow > 0 && flexSign == PositiveFlexibility && std::isfinite(totalFlexGrow))
</span><del>- extraSpace = availableFreeSpace * child->style().flexGrow() / totalFlexGrow;
</del><ins>+ extraSpace = availableFreeSpace * child.style().flexGrow() / totalFlexGrow;
</ins><span class="cx"> else if (availableFreeSpace < 0 && totalWeightedFlexShrink > 0 && flexSign == NegativeFlexibility && std::isfinite(totalWeightedFlexShrink))
</span><del>- extraSpace = availableFreeSpace * child->style().flexShrink() * preferredChildSize / totalWeightedFlexShrink;
</del><ins>+ extraSpace = availableFreeSpace * child.style().flexShrink() * preferredChildSize / totalWeightedFlexShrink;
</ins><span class="cx"> if (std::isfinite(extraSpace))
</span><span class="cx"> childSize += LayoutUnit::fromFloatRound(extraSpace);
</span><span class="cx">
</span><del>- LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(*child, childSize);
</del><ins>+ LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(child, childSize);
</ins><span class="cx"> childSizes.append(adjustedChildSize);
</span><span class="cx"> usedFreeSpace += adjustedChildSize - preferredChildSize;
</span><span class="cx">
</span><span class="cx"> LayoutUnit violation = adjustedChildSize - childSize;
</span><span class="cx"> if (violation > 0)
</span><del>- minViolations.append(Violation(*child, adjustedChildSize));
</del><ins>+ minViolations.append(Violation(child, adjustedChildSize));
</ins><span class="cx"> else if (violation < 0)
</span><del>- maxViolations.append(Violation(*child, adjustedChildSize));
</del><ins>+ maxViolations.append(Violation(child, adjustedChildSize));
</ins><span class="cx"> totalViolation += violation;
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -1028,7 +1030,8 @@
</span><span class="cx"> size_t RenderFlexibleBox::numberOfInFlowPositionedChildren(const OrderedFlexItemList& children) const
</span><span class="cx"> {
</span><span class="cx"> size_t count = 0;
</span><del>- for (auto& child : children) {
</del><ins>+ for (size_t i = 0; i < children.size(); ++i) {
+ RenderBox* child = children[i];
</ins><span class="cx"> if (!child->isOutOfFlowPositioned())
</span><span class="cx"> ++count;
</span><span class="cx"> }
</span><span class="lines">@@ -1152,16 +1155,17 @@
</span><span class="cx"> mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
</span><span class="cx">
</span><span class="cx"> size_t seenInFlowPositionedChildren = 0;
</span><del>- for (auto& child : children) {
- if (child->isOutOfFlowPositioned()) {
- child->layer()->setStaticBlockPosition(mainAxisOffset);
</del><ins>+ for (size_t i = 0; i < children.size(); ++i) {
+ RenderBox& child = *children[i];
+ if (child.isOutOfFlowPositioned()) {
+ child.layer()->setStaticBlockPosition(mainAxisOffset);
</ins><span class="cx"> continue;
</span><span class="cx"> }
</span><del>- mainAxisOffset -= mainAxisExtentForChild(*child) + flowAwareMarginEndForChild(*child);
</del><ins>+ mainAxisOffset -= mainAxisExtentForChild(child) + flowAwareMarginEndForChild(child);
</ins><span class="cx">
</span><del>- setFlowAwareLocationForChild(*child, LayoutPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(*child)));
</del><ins>+ setFlowAwareLocationForChild(child, LayoutPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(child)));
</ins><span class="cx">
</span><del>- mainAxisOffset -= flowAwareMarginStartForChild(*child);
</del><ins>+ mainAxisOffset -= flowAwareMarginStartForChild(child);
</ins><span class="cx">
</span><span class="cx"> ++seenInFlowPositionedChildren;
</span><span class="cx"> if (seenInFlowPositionedChildren < numberOfChildrenForJustifyContent)
</span><span class="lines">@@ -1205,18 +1209,18 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> LayoutUnit availableCrossAxisSpace = crossAxisContentExtent();
</span><del>- for (auto& lineContext : lineContexts)
- availableCrossAxisSpace -= lineContext.crossAxisExtent;
</del><ins>+ for (size_t i = 0; i < lineContexts.size(); ++i)
+ availableCrossAxisSpace -= lineContexts[i].crossAxisExtent;
</ins><span class="cx">
</span><span class="cx"> RenderBox* child = m_orderIterator.first();
</span><span class="cx"> LayoutUnit lineOffset = initialAlignContentOffset(availableCrossAxisSpace, position, distribution, lineContexts.size());
</span><del>- for (auto& lineContext : lineContexts) {
- lineContext.crossAxisOffset += lineOffset;
- for (size_t childNumber = 0; childNumber < lineContext.numberOfChildren; ++childNumber, child = m_orderIterator.next())
</del><ins>+ for (unsigned lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
+ lineContexts[lineNumber].crossAxisOffset += lineOffset;
+ for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = m_orderIterator.next())
</ins><span class="cx"> adjustAlignmentForChild(*child, lineOffset);
</span><span class="cx">
</span><span class="cx"> if (distribution == ContentDistributionStretch && availableCrossAxisSpace > 0)
</span><del>- lineContext.crossAxisExtent += availableCrossAxisSpace / static_cast<unsigned>(lineContexts.size());
</del><ins>+ lineContexts[lineNumber].crossAxisExtent += availableCrossAxisSpace / static_cast<unsigned>(lineContexts.size());
</ins><span class="cx">
</span><span class="cx"> lineOffset += alignContentSpaceBetweenChildren(availableCrossAxisSpace, distribution, lineContexts.size());
</span><span class="cx"> }
</span><span class="lines">@@ -1243,12 +1247,12 @@
</span><span class="cx"> Vector<LayoutUnit> minMarginAfterBaselines;
</span><span class="cx">
</span><span class="cx"> RenderBox* child = m_orderIterator.first();
</span><del>- for (auto& lineContext : lineContexts) {
</del><ins>+ for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
</ins><span class="cx"> LayoutUnit minMarginAfterBaseline = LayoutUnit::max();
</span><del>- LayoutUnit lineCrossAxisExtent = lineContext.crossAxisExtent;
- LayoutUnit maxAscent = lineContext.maxAscent;
</del><ins>+ LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
+ LayoutUnit maxAscent = lineContexts[lineNumber].maxAscent;
</ins><span class="cx">
</span><del>- for (size_t childNumber = 0; childNumber < lineContext.numberOfChildren; ++childNumber, child = m_orderIterator.next()) {
</del><ins>+ for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = m_orderIterator.next()) {
</ins><span class="cx"> ASSERT(child);
</span><span class="cx"> if (child->isOutOfFlowPositioned()) {
</span><span class="cx"> if (style().flexWrap() == FlexWrapReverse)
</span><span class="lines">@@ -1376,11 +1380,11 @@
</span><span class="cx"> {
</span><span class="cx"> LayoutUnit contentExtent = crossAxisContentExtent();
</span><span class="cx"> RenderBox* child = m_orderIterator.first();
</span><del>- for (auto& lineContext : lineContexts) {
- for (size_t childNumber = 0; childNumber < lineContext.numberOfChildren; ++childNumber, child = m_orderIterator.next()) {
</del><ins>+ for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
+ for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = m_orderIterator.next()) {
</ins><span class="cx"> ASSERT(child);
</span><del>- LayoutUnit lineCrossAxisExtent = lineContext.crossAxisExtent;
- LayoutUnit originalOffset = lineContext.crossAxisOffset - crossAxisStartEdge;
</del><ins>+ LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
+ LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
</ins><span class="cx"> LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
</span><span class="cx"> adjustAlignmentForChild(*child, newOffset - originalOffset);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderFlowThreadcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderFlowThread.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderFlowThread.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderFlowThread.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -299,8 +299,8 @@
</span><span class="cx"> RenderLayerList* lists[] = { layer()->negZOrderList(), layer()->normalFlowList(), layer()->posZOrderList() };
</span><span class="cx"> for (size_t listIndex = 0; listIndex < sizeof(lists) / sizeof(lists[0]); ++listIndex) {
</span><span class="cx"> if (RenderLayerList* list = lists[listIndex]) {
</span><del>- for (auto& layer : *list)
- updateLayerToRegionMappings(*layer, layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
</del><ins>+ for (size_t i = 0, listSize = list->size(); i < listSize; ++i)
+ updateLayerToRegionMappings(*list->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderInlinecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderInline.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderInline.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderInline.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -1707,7 +1707,10 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> const Vector<StyleDashboardRegion>& styleRegions = style().dashboardRegions();
</span><del>- for (auto& styleRegion : styleRegions) {
</del><ins>+ unsigned i, count = styleRegions.size();
+ for (i = 0; i < count; i++) {
+ StyleDashboardRegion styleRegion = styleRegions[i];
+
</ins><span class="cx"> LayoutRect linesBoundingBox = this->linesBoundingBox();
</span><span class="cx"> LayoutUnit w = linesBoundingBox.width();
</span><span class="cx"> LayoutUnit h = linesBoundingBox.height();
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayer.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayer.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderLayer.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -729,8 +729,10 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (posZOrderList) {
</span><ins>+ size_t listSize = posZOrderList->size();
</ins><span class="cx"> int stackingOrderIndex = 1;
</span><del>- for (auto& currentLayer : *posZOrderList) {
</del><ins>+ for (size_t i = 0; i < listSize; ++i) {
+ RenderLayer* currentLayer = posZOrderList->at(i);
</ins><span class="cx"> if (!currentLayer->isStackingContext())
</span><span class="cx"> continue;
</span><span class="cx"> lookup.set(currentLayer, stackingOrderIndex++);
</span><span class="lines">@@ -1184,8 +1186,9 @@
</span><span class="cx"> childOutOfFlowDescendantContainingBlocks.add(child->renderer().containingBlock());
</span><span class="cx">
</span><span class="cx"> if (outOfFlowDescendantContainingBlocks) {
</span><del>- for (auto& block : childOutOfFlowDescendantContainingBlocks)
- outOfFlowDescendantContainingBlocks->add(block);
</del><ins>+ HashSet<const RenderObject*>::const_iterator it = childOutOfFlowDescendantContainingBlocks.begin();
+ for (; it != childOutOfFlowDescendantContainingBlocks.end(); ++it)
+ outOfFlowDescendantContainingBlocks->add(*it);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> hasVisibleDescendant |= child->m_hasVisibleContent || child->m_hasVisibleDescendant;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayerBackingcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayerBacking.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayerBacking.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderLayerBacking.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -1898,7 +1898,9 @@
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> if (Vector<RenderLayer*>* normalFlowList = parent.normalFlowList()) {
</span><del>- for (auto& curLayer : *normalFlowList) {
</del><ins>+ size_t listSize = normalFlowList->size();
+ for (size_t i = 0; i < listSize; ++i) {
+ RenderLayer* curLayer = normalFlowList->at(i);
</ins><span class="cx"> if (!compositedWithOwnBackingStore(curLayer)
</span><span class="cx"> && (curLayer->isVisuallyNonEmpty() || descendantLayerPaintsIntoAncestor(*curLayer)))
</span><span class="cx"> return true;
</span><span class="lines">@@ -1911,7 +1913,9 @@
</span><span class="cx">
</span><span class="cx"> // Use the m_hasCompositingDescendant bit to optimize?
</span><span class="cx"> if (Vector<RenderLayer*>* negZOrderList = parent.negZOrderList()) {
</span><del>- for (auto& curLayer : *negZOrderList) {
</del><ins>+ size_t listSize = negZOrderList->size();
+ for (size_t i = 0; i < listSize; ++i) {
+ RenderLayer* curLayer = negZOrderList->at(i);
</ins><span class="cx"> if (!compositedWithOwnBackingStore(curLayer)
</span><span class="cx"> && (curLayer->isVisuallyNonEmpty() || descendantLayerPaintsIntoAncestor(*curLayer)))
</span><span class="cx"> return true;
</span><span class="lines">@@ -1919,7 +1923,9 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (Vector<RenderLayer*>* posZOrderList = parent.posZOrderList()) {
</span><del>- for (auto& curLayer : *posZOrderList) {
</del><ins>+ size_t listSize = posZOrderList->size();
+ for (size_t i = 0; i < listSize; ++i) {
+ RenderLayer* curLayer = posZOrderList->at(i);
</ins><span class="cx"> if (!compositedWithOwnBackingStore(curLayer)
</span><span class="cx"> && (curLayer->isVisuallyNonEmpty() || descendantLayerPaintsIntoAncestor(*curLayer)))
</span><span class="cx"> return true;
</span><span class="lines">@@ -2496,7 +2502,9 @@
</span><span class="cx"> KeyframeValueList backdropFilterVector(AnimatedPropertyWebkitBackdropFilter);
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- for (auto& currentKeyframe : keyframes.keyframes()) {
</del><ins>+ size_t numKeyframes = keyframes.size();
+ for (size_t i = 0; i < numKeyframes; ++i) {
+ const KeyframeValue& currentKeyframe = keyframes[i];
</ins><span class="cx"> const RenderStyle* keyframeStyle = currentKeyframe.style();
</span><span class="cx"> double key = currentKeyframe.key();
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLineBoxListcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLineBoxList.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLineBoxList.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderLineBoxList.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -267,8 +267,11 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (info.phase == PaintPhaseOutline || info.phase == PaintPhaseSelfOutline || info.phase == PaintPhaseChildOutlines) {
</span><del>- for (auto& flow : *info.outlineObjects)
</del><ins>+ ListHashSet<RenderInline*>::iterator end = info.outlineObjects->end();
+ for (ListHashSet<RenderInline*>::iterator it = info.outlineObjects->begin(); it != end; ++it) {
+ RenderInline* flow = *it;
</ins><span class="cx"> flow->paintOutline(info, paintOffset);
</span><ins>+ }
</ins><span class="cx"> info.outlineObjects->clear();
</span><span class="cx"> }
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderListBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderListBox.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderListBox.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderListBox.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -107,8 +107,12 @@
</span><span class="cx"> void RenderListBox::updateFromElement()
</span><span class="cx"> {
</span><span class="cx"> if (m_optionsChanged) {
</span><ins>+ const Vector<HTMLElement*>& listItems = selectElement().listItems();
+ int size = numItems();
+
</ins><span class="cx"> float width = 0;
</span><del>- for (auto& element : selectElement().listItems()) {
</del><ins>+ for (int i = 0; i < size; ++i) {
+ HTMLElement* element = listItems[i];
</ins><span class="cx"> String text;
</span><span class="cx"> FontCascade itemFont = style().fontCascade();
</span><span class="cx"> if (is<HTMLOptionElement>(*element))
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderMenuListcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderMenuList.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderMenuList.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderMenuList.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -58,9 +58,12 @@
</span><span class="cx"> #if PLATFORM(IOS)
</span><span class="cx"> static size_t selectedOptionCount(const RenderMenuList& renderMenuList)
</span><span class="cx"> {
</span><ins>+ const Vector<HTMLElement*>& listItems = renderMenuList.selectElement().listItems();
+ size_t numberOfItems = listItems.size();
+
</ins><span class="cx"> size_t count = 0;
</span><del>- for (auto& element : renderMenuList.selectElement().listItems()) {
- if (is<HTMLOptionElement>(*element) && downcast<HTMLOptionElement>(*element).selected())
</del><ins>+ for (size_t i = 0; i < numberOfItems; ++i) {
+ if (is<HTMLOptionElement>(*listItems[i]) && downcast<HTMLOptionElement>(*listItems[i]).selected())
</ins><span class="cx"> ++count;
</span><span class="cx"> }
</span><span class="cx"> return count;
</span><span class="lines">@@ -203,7 +206,11 @@
</span><span class="cx"> void RenderMenuList::updateOptionsWidth()
</span><span class="cx"> {
</span><span class="cx"> float maxOptionWidth = 0;
</span><del>- for (auto& element : selectElement().listItems()) {
</del><ins>+ const Vector<HTMLElement*>& listItems = selectElement().listItems();
+ int size = listItems.size();
+
+ for (int i = 0; i < size; ++i) {
+ HTMLElement* element = listItems[i];
</ins><span class="cx"> if (!is<HTMLOptionElement>(*element))
</span><span class="cx"> continue;
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderMultiColumnSetcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp (185516 => 185517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp 2015-06-12 18:22:32 UTC (rev 185516)
+++ trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp 2015-06-12 18:43:01 UTC (rev 185517)
</span><span class="lines">@@ -198,8 +198,8 @@
</span><span class="cx"> {
</span><span class="cx"> #ifndef NDEBUG
</span><span class="cx"> // There should be no implicit breaks assumed at this point.
</span><del>- for (auto& forcedBreak : m_contentRuns)
- ASSERT(!forcedBreak.assumedImplicitBreaks());
</del><ins>+ for (unsigned i = 0; i < forcedBreaksCount(); i++)
+ ASSERT(!m_contentRuns[i].assumedImplicitBreaks());
</ins><span class="cx"> #endif // NDEBUG
</span><span class="cx">
</span><span class="cx"> // Insert a final content run to encompass all content. This will include overflow if this is
</span></span></pre>
</div>
</div>
</body>
</html>