Changeset 165890 in webkit
- Timestamp:
- Mar 19, 2014 5:38:51 AM (10 years ago)
- Location:
- trunk
- Files:
-
- 8 added
- 13 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/LayoutTests/ChangeLog
r165889 r165890 1 2014-03-19 Mihnea Ovidenie <mihnea@adobe.com> 2 3 [CSSRegions] Compute region ranges for children of inline blocks 4 https://bugs.webkit.org/show_bug.cgi?id=130392 5 6 Reviewed by Andrei Bucur. 7 8 * fast/regions/inline-block-inline-children-flowed-in-regions-expected.html: Added. 9 * fast/regions/inline-block-inline-children-flowed-in-regions.html: Added. 10 * fast/regions/inline-blocks-dyn-enlarged-regions-expected.html: Added. 11 * fast/regions/inline-blocks-dyn-enlarged-regions.html: Added. 12 * fast/regions/inline-blocks-dyn-shrunk-regions-expected.html: Added. 13 * fast/regions/inline-blocks-dyn-shrunk-regions.html: Added. 14 * fast/regions/inline-blocks-in-two-regions-expected.html: Added. 15 * fast/regions/inline-blocks-in-two-regions.html: Added. 16 1 17 2014-03-19 Frédéric Wang <fred.wang@free.fr> 2 18 -
trunk/Source/WebCore/ChangeLog
r165882 r165890 1 2014-03-19 Mihnea Ovidenie <mihnea@adobe.com> 2 3 [CSSRegions] Compute region ranges for children of inline blocks 4 https://bugs.webkit.org/show_bug.cgi?id=130392 5 6 Reviewed by Andrei Bucur. 7 8 Extend the region ranges computation for children of inline blocks. 9 When we cannot retrieve the region range for a box using cached information, 10 either from region range map or from the region cached on the RootInlineBox, 11 try to find the top most unsplittable box up to the flow thread boundary. 12 If we find such unsplittable box and the box has a region range, then return 13 this range. 14 15 Before this patch, method getRegionRangeForBox did not return true/false 16 if it was able to retrieve the range and the caller checked the returned 17 region values. I modified the method to return true if we were able to compute 18 the range. 19 20 Tests: fast/regions/inline-block-inline-children-flowed-in-regions.html 21 fast/regions/inline-blocks-dyn-enlarged-regions.html 22 fast/regions/inline-blocks-dyn-shrunk-regions.html 23 fast/regions/inline-blocks-in-two-regions.html 24 25 * inspector/InspectorOverlay.cpp: 26 (WebCore::buildObjectForRendererFragments): 27 * rendering/RenderBlock.cpp: 28 (WebCore::RenderBlock::updateRegionRangeForBoxChild): 29 * rendering/RenderBlockFlow.cpp: 30 (WebCore::RenderBlockFlow::hasNextPage): 31 * rendering/RenderBox.cpp: 32 (WebCore::RenderBox::clampToStartAndEndRegions): 33 (WebCore::RenderBox::borderBoxRectInRegion): 34 (WebCore::RenderBox::computeRectForRepaint): 35 (WebCore::RenderBox::layoutOverflowRectForPropagation): 36 * rendering/RenderBoxModelObject.cpp: 37 (WebCore::RenderBoxModelObject::mapAbsoluteToLocalPoint): 38 * rendering/RenderFlowThread.cpp: 39 (WebCore::RenderFlowThread::regionForCompositedLayer): 40 (WebCore::RenderFlowThread::adjustedPositionRelativeToOffsetParent): 41 (WebCore::RenderFlowThread::removeRenderBoxRegionInfo): 42 (WebCore::RenderFlowThread::logicalWidthChangedInRegionsForBlock): 43 (WebCore::RenderFlowThread::getRegionRangeForBoxFromCachedInfo): 44 (WebCore::RenderFlowThread::getRegionRangeForBox): 45 (WebCore::RenderFlowThread::objectShouldPaintInFlowRegion): 46 (WebCore::RenderFlowThread::objectInFlowRegion): 47 (WebCore::RenderFlowThread::addRegionsVisualEffectOverflow): 48 (WebCore::RenderFlowThread::addRegionsVisualOverflowFromTheme): 49 (WebCore::RenderFlowThread::addRegionsOverflowFromChild): 50 (WebCore::RenderFlowThread::addRegionsLayoutOverflow): 51 (WebCore::RenderFlowThread::addRegionsVisualOverflow): 52 (WebCore::RenderFlowThread::clearRegionsOverflow): 53 * rendering/RenderFlowThread.h: 54 * rendering/RenderNamedFlowThread.cpp: 55 (WebCore::RenderNamedFlowThread::fragmentFromAbsolutePointAndBox): 56 * rendering/RenderObject.cpp: 57 (WebCore::RenderObject::locateFlowThreadContainingBlock): 58 Make sure we return the right render flow thread in the case of 59 region-based multicolumn inside named flows. 60 * rendering/RenderRegion.cpp: 61 (WebCore::RenderRegion::rectFlowPortionForBox): 62 1 63 2014-03-19 Krzysztof Wolanski <k.wolanski@samsung.com> 2 64 -
trunk/Source/WebCore/inspector/InspectorOverlay.cpp
r165676 r165890 517 517 RenderRegion* startRegion = nullptr; 518 518 RenderRegion* endRegion = nullptr; 519 containingFlowThread->getRegionRangeForBox(enclosingBox, startRegion, endRegion); 520 if (!startRegion) { 519 if (!containingFlowThread->getRegionRangeForBox(enclosingBox, startRegion, endRegion)) { 521 520 // The flow has no visible regions. The renderer is not visible on screen. 522 521 return nullptr; 523 522 } 523 524 524 const RenderRegionList& regionList = containingFlowThread->renderRegionList(); 525 525 for (RenderRegionList::const_iterator iter = regionList.find(startRegion); iter != regionList.end(); ++iter) { -
trunk/Source/WebCore/rendering/RenderBlock.cpp
r165873 r165890 5112 5112 return false; 5113 5113 5114 RenderRegion* startRegion = 0;5115 RenderRegion* endRegion = 0;5114 RenderRegion* startRegion = nullptr; 5115 RenderRegion* endRegion = nullptr; 5116 5116 flowThread->getRegionRangeForBox(&box, startRegion, endRegion); 5117 5117 5118 5118 computeRegionRangeForBoxChild(box); 5119 5119 5120 RenderRegion* newStartRegion = 0;5121 RenderRegion* newEndRegion = 0;5120 RenderRegion* newStartRegion = nullptr; 5121 RenderRegion* newEndRegion = nullptr; 5122 5122 flowThread->getRegionRangeForBox(&box, newStartRegion, newEndRegion); 5123 5123 -
trunk/Source/WebCore/rendering/RenderBlockFlow.cpp
r165873 r165890 1675 1675 if (!region) 1676 1676 return false; 1677 1677 1678 if (region->isLastRegion()) 1678 1679 return region->isRenderRegionSet() || region->style().regionFragment() == BreakRegionFragment 1679 1680 || (pageBoundaryRule == IncludePageBoundary && pageOffset == region->logicalTopForFlowThreadContent()); 1680 1681 1681 RenderRegion* startRegion = 0;1682 RenderRegion* endRegion = 0;1682 RenderRegion* startRegion = nullptr; 1683 RenderRegion* endRegion = nullptr; 1683 1684 flowThread->getRegionRangeForBox(this, startRegion, endRegion); 1684 1685 if (region == endRegion) 1686 return false; 1687 return true; 1685 return region != endRegion; 1688 1686 } 1689 1687 -
trunk/Source/WebCore/rendering/RenderBox.cpp
r165599 r165890 132 132 // last regions extended infinitely. Otherwise the lines are going to size according to the regions 133 133 // they overflow into, which makes no sense when this block doesn't exist in |region| at all. 134 RenderRegion* startRegion = 0; 135 RenderRegion* endRegion = 0; 136 flowThread->getRegionRangeForBox(this, startRegion, endRegion); 137 138 if (startRegion && region->logicalTopForFlowThreadContent() < startRegion->logicalTopForFlowThreadContent()) 134 RenderRegion* startRegion = nullptr; 135 RenderRegion* endRegion = nullptr; 136 if (!flowThread->getRegionRangeForBox(this, startRegion, endRegion)) 137 return region; 138 139 if (region->logicalTopForFlowThreadContent() < startRegion->logicalTopForFlowThreadContent()) 139 140 return startRegion; 140 if ( endRegion &®ion->logicalTopForFlowThreadContent() > endRegion->logicalTopForFlowThreadContent())141 if (region->logicalTopForFlowThreadContent() > endRegion->logicalTopForFlowThreadContent()) 141 142 return endRegion; 142 143 … … 165 166 return borderBoxRect(); 166 167 167 RenderRegion* startRegion = 0; 168 RenderRegion* endRegion = 0; 169 flowThread->getRegionRangeForBox(this, startRegion, endRegion); 170 171 // FIXME: In a perfect world this condition should never happen. 172 if (!startRegion || !endRegion) 168 RenderRegion* startRegion = nullptr; 169 RenderRegion* endRegion = nullptr; 170 if (!flowThread->getRegionRangeForBox(this, startRegion, endRegion)) { 171 // FIXME: In a perfect world this condition should never happen. 173 172 return borderBoxRect(); 174 173 } 174 175 175 ASSERT(flowThread->regionInRange(region, startRegion, endRegion)); 176 176 … … 2104 2104 2105 2105 if (o->isRenderFlowThread()) { 2106 RenderRegion* firstRegion = 0; 2107 RenderRegion* lastRegion = 0; 2108 toRenderFlowThread(o)->getRegionRangeForBox(this, firstRegion, lastRegion); 2109 if (firstRegion) 2106 RenderRegion* firstRegion = nullptr; 2107 RenderRegion* lastRegion = nullptr; 2108 if (toRenderFlowThread(o)->getRegionRangeForBox(this, firstRegion, lastRegion)) 2110 2109 rect.moveBy(firstRegion->flowThreadPortionRect().location()); 2111 2110 } … … 4537 4536 if (namedFlowFragment) { 4538 4537 if (RenderFlowThread* flowThread = namedFlowFragment->flowThread()) { 4539 RenderRegion* startRegion = 0; 4540 RenderRegion* endRegion = 0; 4541 flowThread->getRegionRangeForBox(this, startRegion, endRegion); 4542 4543 if (startRegion && endRegion) 4538 RenderRegion* startRegion = nullptr; 4539 RenderRegion* endRegion = nullptr; 4540 if (flowThread->getRegionRangeForBox(this, startRegion, endRegion)) 4544 4541 overflowRect.unite(namedFlowFragment->visualOverflowRectForBox(this)); 4545 4542 } -
trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp
r165699 r165890 2633 2633 // not the FlowThread that is its container in the RenderObject tree. 2634 2634 if (o->isRenderFlowThread() && isBox()) { 2635 RenderRegion* startRegion; 2636 RenderRegion* endRegion; 2637 toRenderFlowThread(o)->getRegionRangeForBox(toRenderBox(this), startRegion, endRegion); 2638 if (startRegion) 2635 RenderRegion* startRegion = nullptr; 2636 RenderRegion* endRegion = nullptr; 2637 if (toRenderFlowThread(o)->getRegionRangeForBox(toRenderBox(this), startRegion, endRegion)) 2639 2638 o = startRegion; 2640 2639 } -
trunk/Source/WebCore/rendering/RenderFlowThread.cpp
r165377 r165890 239 239 bool RenderFlowThread::hasCompositingRegionDescendant() const 240 240 { 241 for (auto& region : m_regionList) 241 for (auto& region : m_regionList) { 242 242 if (toRenderNamedFlowFragment(region)->layerOwner().layer()->hasCompositingDescendant()) 243 243 return true; 244 } 244 245 245 246 return false; … … 259 260 260 261 if (childLayer.renderBox()) { 261 RenderRegion* startRegion = 0; 262 RenderRegion* endRegion = 0; 263 getRegionRangeForBox(childLayer.renderBox(), startRegion, endRegion); 264 // The video tag is such a box that doesn't have a region range because it's inline (by default). 265 if (startRegion) 262 RenderRegion* startRegion = nullptr; 263 RenderRegion* endRegion = nullptr; 264 if (getRegionRangeForBox(childLayer.renderBox(), startRegion, endRegion)) 266 265 return toRenderNamedFlowFragment(startRegion); 267 266 } … … 315 314 RegionToLayerListMap regionToLayerListMap; 316 315 317 RenderLayerList* lists[] = { layer()->negZOrderList(), layer()->normalFlowList(), layer()->posZOrderList() };318 for (size_t listIndex = 0; listIndex < sizeof(lists) / sizeof(lists[0]); ++listIndex) 319 if (RenderLayerList* list = lists[listIndex]) 316 RenderLayerList* lists[] = { layer()->negZOrderList(), layer()->normalFlowList(), layer()->posZOrderList() }; 317 for (size_t listIndex = 0; listIndex < sizeof(lists) / sizeof(lists[0]); ++listIndex) { 318 if (RenderLayerList* list = lists[listIndex]) { 320 319 for (size_t i = 0, listSize = list->size(); i < listSize; ++i) 321 320 updateLayerToRegionMappings(*list->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate); 321 } 322 } 322 323 323 324 if (needsLayerUpdate) { … … 466 467 while (objContainingBlock && !objContainingBlock->isRenderNamedFlowThread()) { 467 468 // Check if this object is in a different region. 468 RenderRegion* parentStartRegion = 0; 469 RenderRegion* parentEndRegion = 0; 470 getRegionRangeForBox(objContainingBlock, parentStartRegion, parentEndRegion); 471 if (parentStartRegion && parentStartRegion != startRegion) { 469 RenderRegion* parentStartRegion = nullptr; 470 RenderRegion* parentEndRegion = nullptr; 471 if (getRegionRangeForBox(objContainingBlock, parentStartRegion, parentEndRegion) && parentStartRegion != startRegion) { 472 472 wasComputedRelativeToOtherRegion = true; 473 473 break; … … 594 594 } 595 595 596 RenderRegion* startRegion ;597 RenderRegion* endRegion ;596 RenderRegion* startRegion = nullptr; 597 RenderRegion* endRegion = nullptr; 598 598 getRegionRangeForBox(box, startRegion, endRegion); 599 599 … … 631 631 return; 632 632 633 RenderRegion* startRegion;634 RenderRegion* endRegion;635 getRegionRangeForBox(block, startRegion, endRegion);636 637 633 // Not necessary for the flow thread, since we already computed the correct info for it. 638 634 // If the regions have changed invalidate the children. … … 641 637 return; 642 638 } 639 640 RenderRegion* startRegion = nullptr; 641 RenderRegion* endRegion = nullptr; 642 getRegionRangeForBox(block, startRegion, endRegion); 643 643 644 644 for (auto& region : m_regionList) { … … 750 750 } 751 751 752 void RenderFlowThread::getRegionRangeForBox(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const 753 { 754 startRegion = endRegion = 0; 752 bool RenderFlowThread::getRegionRangeForBoxFromCachedInfo(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const 753 { 754 ASSERT(box); 755 ASSERT(hasValidRegionInfo()); 756 ASSERT((startRegion == nullptr) && (endRegion == nullptr)); 757 755 758 auto it = m_regionRangeMap.find(box); 756 757 759 if (it != m_regionRangeMap.end()) { 758 760 const RenderRegionRange& range = it->value; … … 760 762 endRegion = range.endRegion(); 761 763 ASSERT(m_regionList.contains(startRegion) && m_regionList.contains(endRegion)); 762 return ;764 return true; 763 765 } 764 766 765 767 InlineElementBox* boxWrapper = box->inlineBoxWrapper(); 766 if (boxWrapper) { 767 const RootInlineBox& boxWrapperRootInlineBox = boxWrapper->root(); 768 startRegion = endRegion = boxWrapperRootInlineBox.containingRegion(); 769 return; 770 } 768 if (boxWrapper && boxWrapper->root().containingRegion()) { 769 startRegion = endRegion = boxWrapper->root().containingRegion(); 770 ASSERT(m_regionList.contains(startRegion) && m_regionList.contains(endRegion)); 771 return true; 772 } 773 774 return false; 775 } 776 777 bool RenderFlowThread::getRegionRangeForBox(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const 778 { 779 ASSERT(box); 780 781 startRegion = endRegion = nullptr; 782 if (!hasValidRegionInfo()) // We clear the ranges when we invalidate the regions. 783 return false; 784 785 if (getRegionRangeForBoxFromCachedInfo(box, startRegion, endRegion)) 786 return true; 787 788 // Check if the box is contained in an unsplittable box. 789 // If the unsplittable box has region range, then the start and end region for the box 790 // should be equal with the region for the unsplittable box if any. 791 RenderBox* topMostUnsplittable = nullptr; 792 RenderBox* cb = const_cast<RenderBox*>(box); 793 do { 794 if (cb->isUnsplittableForPagination()) 795 topMostUnsplittable = cb; 796 cb = cb->parent()->enclosingBox(); 797 } while (!cb->isRenderFlowThread()); 798 799 if (topMostUnsplittable) { 800 if (getRegionRangeForBoxFromCachedInfo(topMostUnsplittable, startRegion, endRegion)) { 801 endRegion = startRegion; 802 return true; 803 } 804 } 805 806 return false; 771 807 } 772 808 … … 801 837 if (flowThread != this) 802 838 return false; 839 803 840 if (!m_regionList.contains(const_cast<RenderRegion*>(region))) 804 841 return false; 805 842 806 843 RenderBox* enclosingBox = object->enclosingBox(); 807 RenderRegion* enclosingBoxStartRegion = 0; 808 RenderRegion* enclosingBoxEndRegion = 0; 809 getRegionRangeForBox(enclosingBox, enclosingBoxStartRegion, enclosingBoxEndRegion); 810 844 RenderRegion* enclosingBoxStartRegion = nullptr; 845 RenderRegion* enclosingBoxEndRegion = nullptr; 811 846 // If the box has no range, do not check regionInRange. Boxes inside inlines do not get ranges. 812 847 // Instead, the containing RootInlineBox will abort when trying to paint inside the wrong region. 813 if (enclosingBoxStartRegion && enclosingBoxEndRegion && !regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion)) 848 if (getRegionRangeForBox(enclosingBox, enclosingBoxStartRegion, enclosingBoxEndRegion) 849 && !regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion)) 814 850 return false; 815 851 … … 825 861 if (flowThread != this) 826 862 return false; 863 827 864 if (!m_regionList.contains(const_cast<RenderRegion*>(region))) 828 865 return false; 829 866 830 867 RenderBox* enclosingBox = object->enclosingBox(); 831 RenderRegion* enclosingBoxStartRegion = 0; 832 RenderRegion* enclosingBoxEndRegion = 0; 833 getRegionRangeForBox(enclosingBox, enclosingBoxStartRegion, enclosingBoxEndRegion); 868 RenderRegion* enclosingBoxStartRegion = nullptr; 869 RenderRegion* enclosingBoxEndRegion = nullptr; 870 if (!getRegionRangeForBox(enclosingBox, enclosingBoxStartRegion, enclosingBoxEndRegion)) 871 return false; 872 834 873 if (!regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion)) 835 874 return false; … … 884 923 return; 885 924 886 for (auto regionIter = startRegion ? m_regionList.find(startRegion) : m_regionList.begin(), 887 end = m_regionList.end(); regionIter != end; ++regionIter) { 925 for (auto regionIter = startRegion ? m_regionList.find(startRegion) : m_regionList.begin(), end = m_regionList.end(); regionIter != end; ++regionIter) { 888 926 RenderRegion* region = *regionIter; 889 927 if (region->hasAutoLogicalHeight()) { … … 1180 1218 return; 1181 1219 1182 if (RenderRegion* region = mapFromFlowToRegion(transformState)) 1220 if (RenderRegion* region = mapFromFlowToRegion(transformState)) { 1183 1221 // FIXME: The cast below is probably not the best solution, we may need to find a better way. 1184 1222 static_cast<const RenderObject*>(region)->mapLocalToContainer(region->containerForRepaint(), transformState, mode, wasFixed); 1223 } 1185 1224 } 1186 1225 … … 1242 1281 void RenderFlowThread::addRegionsVisualEffectOverflow(const RenderBox* box) 1243 1282 { 1244 RenderRegion* startRegion = 0; 1245 RenderRegion* endRegion = 0; 1246 getRegionRangeForBox(box, startRegion, endRegion); 1283 RenderRegion* startRegion = nullptr; 1284 RenderRegion* endRegion = nullptr; 1285 if (!getRegionRangeForBox(box, startRegion, endRegion)) 1286 return; 1247 1287 1248 1288 for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) { … … 1261 1301 void RenderFlowThread::addRegionsVisualOverflowFromTheme(const RenderBlock* block) 1262 1302 { 1263 RenderRegion* startRegion = 0; 1264 RenderRegion* endRegion = 0; 1265 getRegionRangeForBox(block, startRegion, endRegion); 1303 RenderRegion* startRegion = nullptr; 1304 RenderRegion* endRegion = nullptr; 1305 if (!getRegionRangeForBox(block, startRegion, endRegion)) 1306 return; 1266 1307 1267 1308 for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) { … … 1282 1323 void RenderFlowThread::addRegionsOverflowFromChild(const RenderBox* box, const RenderBox* child, const LayoutSize& delta) 1283 1324 { 1284 RenderRegion* startRegion = 0; 1285 RenderRegion* endRegion = 0; 1286 getRegionRangeForBox(child, startRegion, endRegion); 1287 1288 RenderRegion* containerStartRegion = 0; 1289 RenderRegion* containerEndRegion = 0; 1290 getRegionRangeForBox(box, containerStartRegion, containerEndRegion); 1325 RenderRegion* startRegion = nullptr; 1326 RenderRegion* endRegion = nullptr; 1327 if (!getRegionRangeForBox(child, startRegion, endRegion)) 1328 return; 1329 1330 RenderRegion* containerStartRegion = nullptr; 1331 RenderRegion* containerEndRegion = nullptr; 1332 if (!getRegionRangeForBox(box, containerStartRegion, containerEndRegion)) 1333 return; 1291 1334 1292 1335 for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) { … … 1318 1361 void RenderFlowThread::addRegionsLayoutOverflow(const RenderBox* box, const LayoutRect& layoutOverflow) 1319 1362 { 1320 RenderRegion* startRegion = 0; 1321 RenderRegion* endRegion = 0; 1322 getRegionRangeForBox(box, startRegion, endRegion); 1363 RenderRegion* startRegion = nullptr; 1364 RenderRegion* endRegion = nullptr; 1365 if (!getRegionRangeForBox(box, startRegion, endRegion)) 1366 return; 1323 1367 1324 1368 for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) { … … 1335 1379 void RenderFlowThread::addRegionsVisualOverflow(const RenderBox* box, const LayoutRect& visualOverflow) 1336 1380 { 1337 RenderRegion* startRegion = 0; 1338 RenderRegion* endRegion = 0; 1339 getRegionRangeForBox(box, startRegion, endRegion); 1381 RenderRegion* startRegion = nullptr; 1382 RenderRegion* endRegion = nullptr; 1383 if (!getRegionRangeForBox(box, startRegion, endRegion)) 1384 return; 1340 1385 1341 1386 for (RenderRegionList::iterator iter = m_regionList.find(startRegion); iter != m_regionList.end(); ++iter) { … … 1352 1397 void RenderFlowThread::clearRegionsOverflow(const RenderBox* box) 1353 1398 { 1354 RenderRegion* startRegion = 0; 1355 RenderRegion* endRegion = 0; 1356 getRegionRangeForBox(box, startRegion, endRegion); 1399 RenderRegion* startRegion = nullptr; 1400 RenderRegion* endRegion = nullptr; 1401 if (!getRegionRangeForBox(box, startRegion, endRegion)) 1402 return; 1357 1403 1358 1404 for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) { -
trunk/Source/WebCore/rendering/RenderFlowThread.h
r165720 r165890 124 124 125 125 void setRegionRangeForBox(const RenderBox*, RenderRegion*, RenderRegion*); 126 voidgetRegionRangeForBox(const RenderBox*, RenderRegion*& startRegion, RenderRegion*& endRegion) const;126 bool getRegionRangeForBox(const RenderBox*, RenderRegion*& startRegion, RenderRegion*& endRegion) const; 127 127 bool hasRegionRangeForBox(const RenderBox* box) const { ASSERT(box); return m_regionRangeMap.contains(box); } 128 128 … … 246 246 inline const RenderBox* currentActiveRenderBox() const; 247 247 248 bool getRegionRangeForBoxFromCachedInfo(const RenderBox*, RenderRegion*& startRegion, RenderRegion*& endRegion) const; 249 248 250 RenderRegionList m_regionList; 249 251 unsigned short m_previousRegionCount; -
trunk/Source/WebCore/rendering/RenderNamedFlowFragment.cpp
r165542 r165890 284 284 } 285 285 286 if ((oldRegionRect.width() != pageLogicalWidth() || oldRegionRect.height() != pageLogicalHeight()) && !m_flowThread->inFinalLayoutPhase()) 286 if ((oldRegionRect.width() != pageLogicalWidth() || oldRegionRect.height() != pageLogicalHeight()) && !m_flowThread->inFinalLayoutPhase()) { 287 287 // This can happen even if we are in the inConstrainedLayoutPhase and it will trigger a pathological layout of the flow thread. 288 288 m_flowThread->invalidateRegions(); 289 } 289 290 } 290 291 } -
trunk/Source/WebCore/rendering/RenderNamedFlowThread.cpp
r165676 r165890 370 370 RenderRegion* startRegion = nullptr; 371 371 RenderRegion* endRegion = nullptr; 372 getRegionRangeForBox(&flowedBox, startRegion, endRegion); 373 374 if (!startRegion) 372 if (!getRegionRangeForBox(&flowedBox, startRegion, endRegion)) 375 373 return nullptr; 376 374 -
trunk/Source/WebCore/rendering/RenderObject.cpp
r165736 r165890 527 527 // See if we have the thread cached because we're in the middle of layout. 528 528 RenderFlowThread* flowThread = view().flowThreadController().currentRenderFlowThread(); 529 if (flowThread )529 if (flowThread && (flowThreadState() == flowThread->flowThreadState())) 530 530 return flowThread; 531 531 -
trunk/Source/WebCore/rendering/RenderRegion.cpp
r165615 r165890 474 474 LayoutRect mappedRect = m_flowThread->mapFromLocalToFlowThread(box, rect); 475 475 476 RenderRegion* startRegion = 0; 477 RenderRegion* endRegion = 0; 478 m_flowThread->getRegionRangeForBox(box, startRegion, endRegion); 479 480 if (startRegion && endRegion) { 476 RenderRegion* startRegion = nullptr; 477 RenderRegion* endRegion = nullptr; 478 if (m_flowThread->getRegionRangeForBox(box, startRegion, endRegion)) { 481 479 if (flowThread()->isHorizontalWritingMode()) { 482 480 if (this != startRegion)
Note: See TracChangeset
for help on using the changeset viewer.