[CSSRegions] Incorrect computed height for content with region-break-before
[WebKit-https.git] / Source / WebCore / rendering / RenderRegion.cpp
1 /*
2  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above
9  *    copyright notice, this list of conditions and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above
12  *    copyright notice, this list of conditions and the following
13  *    disclaimer in the documentation and/or other materials
14  *    provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
21  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
25  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
26  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "RenderRegion.h"
32
33 #include "FlowThreadController.h"
34 #include "GraphicsContext.h"
35 #include "HitTestResult.h"
36 #include "IntRect.h"
37 #include "PaintInfo.h"
38 #include "Range.h"
39 #include "RenderBoxRegionInfo.h"
40 #include "RenderNamedFlowThread.h"
41 #include "RenderView.h"
42 #include "StyleResolver.h"
43
44 namespace WebCore {
45
46 RenderRegion::RenderRegion(Node* node, RenderFlowThread* flowThread)
47     : RenderReplaced(node, IntSize())
48     , m_flowThread(flowThread)
49     , m_parentNamedFlowThread(0)
50     , m_isValid(false)
51     , m_hasCustomRegionStyle(false)
52     , m_hasAutoLogicalHeight(false)
53     , m_regionState(RegionUndefined)
54 {
55 }
56
57 LayoutUnit RenderRegion::pageLogicalWidth() const
58 {
59     return m_flowThread->isHorizontalWritingMode() ? contentWidth() : contentHeight();
60 }
61
62 LayoutUnit RenderRegion::pageLogicalHeight() const
63 {
64     if (hasOverrideHeight() && view()->normalLayoutPhase())
65         return overrideLogicalContentHeight() + borderAndPaddingLogicalHeight();
66     return m_flowThread->isHorizontalWritingMode() ? contentHeight() : contentWidth();
67 }
68
69 LayoutUnit RenderRegion::logicalHeightOfAllFlowThreadContent() const
70 {
71     if (hasOverrideHeight() && view()->normalLayoutPhase())
72         return overrideLogicalContentHeight() + borderAndPaddingLogicalHeight();
73     return m_flowThread->isHorizontalWritingMode() ? contentHeight() : contentWidth();
74 }
75
76 LayoutRect RenderRegion::flowThreadPortionOverflowRect() const
77 {
78     return overflowRectForFlowThreadPortion(flowThreadPortionRect(), isFirstRegion(), isLastRegion());
79 }
80
81 LayoutRect RenderRegion::overflowRectForFlowThreadPortion(LayoutRect flowThreadPortionRect, bool isFirstPortion, bool isLastPortion) const
82 {
83     // FIXME: Would like to just use hasOverflowClip() but we aren't a block yet. When RenderRegion is eliminated and
84     // folded into RenderBlock, switch to hasOverflowClip().
85     bool clipX = style()->overflowX() != OVISIBLE;
86     bool clipY = style()->overflowY() != OVISIBLE;
87     bool isLastRegionWithRegionOverflowBreak = (isLastPortion && (style()->regionOverflow() == BreakRegionOverflow));
88     if ((clipX && clipY) || !isValid() || !m_flowThread || isLastRegionWithRegionOverflowBreak)
89         return flowThreadPortionRect;
90
91     LayoutRect flowThreadOverflow = m_flowThread->visualOverflowRect();
92
93     // Only clip along the flow thread axis.
94     LayoutUnit outlineSize = maximalOutlineSize(PaintPhaseOutline);
95     LayoutRect clipRect;
96     if (m_flowThread->isHorizontalWritingMode()) {
97         LayoutUnit minY = isFirstPortion ? (flowThreadOverflow.y() - outlineSize) : flowThreadPortionRect.y();
98         LayoutUnit maxY = isLastPortion ? max(flowThreadPortionRect.maxY(), flowThreadOverflow.maxY()) + outlineSize : flowThreadPortionRect.maxY();
99         LayoutUnit minX = clipX ? flowThreadPortionRect.x() : (flowThreadOverflow.x() - outlineSize);
100         LayoutUnit maxX = clipX ? flowThreadPortionRect.maxX() : (flowThreadOverflow.maxX() + outlineSize);
101         clipRect = LayoutRect(minX, minY, maxX - minX, maxY - minY);
102     } else {
103         LayoutUnit minX = isFirstPortion ? (flowThreadOverflow.x() - outlineSize) : flowThreadPortionRect.x();
104         LayoutUnit maxX = isLastPortion ? max(flowThreadPortionRect.maxX(), flowThreadOverflow.maxX()) + outlineSize : flowThreadPortionRect.maxX();
105         LayoutUnit minY = clipY ? flowThreadPortionRect.y() : (flowThreadOverflow.y() - outlineSize);
106         LayoutUnit maxY = clipY ? flowThreadPortionRect.maxY() : (flowThreadOverflow.maxY() + outlineSize);
107         clipRect = LayoutRect(minX, minY, maxX - minX, maxY - minY);
108     }
109
110     return clipRect;
111 }
112
113 LayoutUnit RenderRegion::pageLogicalTopForOffset(LayoutUnit /* offset */) const
114 {
115     return flowThread()->isHorizontalWritingMode() ? flowThreadPortionRect().y() : flowThreadPortionRect().x();
116 }
117
118 bool RenderRegion::isFirstRegion() const
119 {
120     ASSERT(isValid() && m_flowThread);
121     return m_flowThread->firstRegion() == this;
122 }
123
124 bool RenderRegion::isLastRegion() const
125 {
126     ASSERT(isValid() && m_flowThread);
127     return m_flowThread->lastRegion() == this;
128 }
129
130 void RenderRegion::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
131 {
132     // Delegate painting of content in region to RenderFlowThread.
133     if (!m_flowThread || !isValid())
134         return;
135
136     setRegionObjectsRegionStyle();
137     m_flowThread->paintFlowThreadPortionInRegion(paintInfo, this, flowThreadPortionRect(), flowThreadPortionOverflowRect(), LayoutPoint(paintOffset.x() + borderLeft() + paddingLeft(), paintOffset.y() + borderTop() + paddingTop()));
138     restoreRegionObjectsOriginalStyle();
139 }
140
141 // Hit Testing
142 bool RenderRegion::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction action)
143 {
144     if (!isValid())
145         return false;
146
147     LayoutPoint adjustedLocation = accumulatedOffset + location();
148
149     // Check our bounds next. For this purpose always assume that we can only be hit in the
150     // foreground phase (which is true for replaced elements like images).
151     // FIXME: Once we support overflow, we need to intersect with that and not with the bounds rect.
152     LayoutRect boundsRect = borderBoxRectInRegion(locationInContainer.region());
153     boundsRect.moveBy(adjustedLocation);
154     if (visibleToHitTesting() && action == HitTestForeground && locationInContainer.intersects(boundsRect)) {
155         // Check the contents of the RenderFlowThread.
156         if (m_flowThread && m_flowThread->hitTestFlowThreadPortionInRegion(this, flowThreadPortionRect(), flowThreadPortionOverflowRect(), request, result, locationInContainer, LayoutPoint(adjustedLocation.x() + borderLeft() + paddingLeft(), adjustedLocation.y() + borderTop() + paddingTop())))
157             return true;
158         updateHitTestResult(result, locationInContainer.point() - toLayoutSize(adjustedLocation));
159         if (!result.addNodeToRectBasedTestResult(generatingNode(), request, locationInContainer, boundsRect))
160             return true;
161     }
162
163     return false;
164 }
165
166 void RenderRegion::checkRegionStyle()
167 {
168     ASSERT(m_flowThread);
169     bool customRegionStyle = false;
170
171     // FIXME: Region styling doesn't work for pseudo elements.
172     if (node()) {
173         Element* regionElement = static_cast<Element*>(node());
174         customRegionStyle = view()->document()->styleResolver()->checkRegionStyle(regionElement);
175     }
176     setHasCustomRegionStyle(customRegionStyle);
177     m_flowThread->checkRegionsWithStyling();
178 }
179
180 void RenderRegion::updateRegionHasAutoLogicalHeightFlag()
181 {
182     ASSERT(m_flowThread);
183
184     if (!isValid())
185         return;
186
187     bool didHaveAutoLogicalHeight = m_hasAutoLogicalHeight;
188     m_hasAutoLogicalHeight = shouldHaveAutoLogicalHeight();
189     if (m_hasAutoLogicalHeight != didHaveAutoLogicalHeight) {
190         if (m_hasAutoLogicalHeight)
191             view()->flowThreadController()->incrementAutoLogicalHeightRegions();
192         else {
193             clearOverrideLogicalContentHeight();
194             view()->flowThreadController()->decrementAutoLogicalHeightRegions();
195         }
196     }
197 }
198
199 void RenderRegion::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
200 {
201     RenderReplaced::styleDidChange(diff, oldStyle);
202
203     // If the region is not attached to any thread, there is no need to check
204     // whether the region has region styling since no content will be displayed
205     // into the region.
206     if (!m_flowThread) {
207         setHasCustomRegionStyle(false);
208         return;
209     }
210
211     checkRegionStyle();
212     updateRegionHasAutoLogicalHeightFlag();
213 }
214
215 void RenderRegion::layout()
216 {
217     StackStats::LayoutCheckPoint layoutCheckPoint;
218     RenderReplaced::layout();
219     if (m_flowThread && isValid()) {
220         LayoutRect oldRegionRect(flowThreadPortionRect());
221         if (!isHorizontalWritingMode())
222             oldRegionRect = oldRegionRect.transposedRect();
223         if (oldRegionRect.width() != pageLogicalWidth() || oldRegionRect.height() != pageLogicalHeight())
224             m_flowThread->invalidateRegions();
225     }
226
227     // FIXME: We need to find a way to set up overflow properly. Our flow thread hasn't gotten a layout
228     // yet, so we can't look to it for correct information. It's possible we could wait until after the RenderFlowThread
229     // gets a layout, and then try to propagate overflow information back to the region, and then mark for a second layout.
230     // That second layout would then be able to use the information from the RenderFlowThread to set up overflow.
231     //
232     // The big problem though is that overflow needs to be region-specific. We can't simply use the RenderFlowThread's global
233     // overflow values, since then we'd always think any narrow region had huge overflow (all the way to the width of the
234     // RenderFlowThread itself).
235     //
236     // We'll need to expand RenderBoxRegionInfo to also hold left and right overflow values.
237 }
238
239 void RenderRegion::repaintFlowThreadContent(const LayoutRect& repaintRect, bool immediate) const
240 {
241     repaintFlowThreadContentRectangle(repaintRect, immediate, flowThreadPortionRect(), flowThreadPortionOverflowRect(), contentBoxRect().location());
242 }
243
244 void RenderRegion::repaintFlowThreadContentRectangle(const LayoutRect& repaintRect, bool immediate, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect, const LayoutPoint& regionLocation) const
245 {
246     // We only have to issue a repaint in this region if the region rect intersects the repaint rect.
247     LayoutRect flippedFlowThreadPortionRect(flowThreadPortionRect);
248     LayoutRect flippedFlowThreadPortionOverflowRect(flowThreadPortionOverflowRect);
249     flowThread()->flipForWritingMode(flippedFlowThreadPortionRect); // Put the region rects into physical coordinates.
250     flowThread()->flipForWritingMode(flippedFlowThreadPortionOverflowRect);
251
252     LayoutRect clippedRect(repaintRect);
253     clippedRect.intersect(flippedFlowThreadPortionOverflowRect);
254     if (clippedRect.isEmpty())
255         return;
256
257     // Put the region rect into the region's physical coordinate space.
258     clippedRect.setLocation(regionLocation + (clippedRect.location() - flippedFlowThreadPortionRect.location()));
259
260     // Now switch to the region's writing mode coordinate space and let it repaint itself.
261     flipForWritingMode(clippedRect);
262     
263     // Issue the repaint.
264     repaintRectangle(clippedRect, immediate);
265 }
266
267 void RenderRegion::installFlowThread()
268 {
269     ASSERT(view());
270
271     m_flowThread = view()->flowThreadController()->ensureRenderFlowThreadWithName(style()->regionThread());
272
273     // By now the flow thread should already be added to the rendering tree,
274     // so we go up the rendering parents and check that this region is not part of the same
275     // flow that it actually needs to display. It would create a circular reference.
276     RenderObject* parentObject = parent();
277     m_parentNamedFlowThread = 0;
278     for ( ; parentObject; parentObject = parentObject->parent()) {
279         if (parentObject->isRenderNamedFlowThread()) {
280             m_parentNamedFlowThread = toRenderNamedFlowThread(parentObject);
281             // Do not take into account a region that links a flow with itself. The dependency
282             // cannot change, so it is not worth adding it to the list.
283             if (m_flowThread == m_parentNamedFlowThread)
284                 m_flowThread = 0;
285             break;
286         }
287     }
288 }
289
290 void RenderRegion::attachRegion()
291 {
292     if (documentBeingDestroyed())
293         return;
294     
295     // A region starts off invalid.
296     setIsValid(false);
297
298     // Initialize the flow thread reference and create the flow thread object if needed.
299     // The flow thread lifetime is influenced by the number of regions attached to it,
300     // and we are attaching the region to the flow thread.
301     installFlowThread();
302     
303     if (!m_flowThread)
304         return;
305
306     m_flowThread->addRegionToThread(this);
307
308     // The region just got attached to the flow thread, lets check whether
309     // it has region styling rules associated.
310     checkRegionStyle();
311
312     if (!isValid())
313         return;
314
315     m_hasAutoLogicalHeight = shouldHaveAutoLogicalHeight();
316     if (hasAutoLogicalHeight())
317         view()->flowThreadController()->incrementAutoLogicalHeightRegions();
318 }
319
320 void RenderRegion::detachRegion()
321 {
322     if (m_flowThread) {
323         m_flowThread->removeRegionFromThread(this);
324         if (hasAutoLogicalHeight()) {
325             ASSERT(isValid());
326             view()->flowThreadController()->decrementAutoLogicalHeightRegions();
327         }
328     }
329     m_flowThread = 0;
330 }
331
332 RenderBoxRegionInfo* RenderRegion::renderBoxRegionInfo(const RenderBox* box) const
333 {
334     if (!m_isValid || !m_flowThread)
335         return 0;
336     return m_renderBoxRegionInfo.get(box);
337 }
338
339 RenderBoxRegionInfo* RenderRegion::setRenderBoxRegionInfo(const RenderBox* box, LayoutUnit logicalLeftInset, LayoutUnit logicalRightInset,
340     bool containingBlockChainIsInset)
341 {
342     ASSERT(m_isValid && m_flowThread);
343     if (!m_isValid || !m_flowThread)
344         return 0;
345
346     OwnPtr<RenderBoxRegionInfo>& boxInfo = m_renderBoxRegionInfo.add(box, nullptr).iterator->value;
347     if (boxInfo)
348         *boxInfo = RenderBoxRegionInfo(logicalLeftInset, logicalRightInset, containingBlockChainIsInset);
349     else
350         boxInfo = adoptPtr(new RenderBoxRegionInfo(logicalLeftInset, logicalRightInset, containingBlockChainIsInset));
351
352     return boxInfo.get();
353 }
354
355 PassOwnPtr<RenderBoxRegionInfo> RenderRegion::takeRenderBoxRegionInfo(const RenderBox* box)
356 {
357     return m_renderBoxRegionInfo.take(box);
358 }
359
360 void RenderRegion::removeRenderBoxRegionInfo(const RenderBox* box)
361 {
362     m_renderBoxRegionInfo.remove(box);
363 }
364
365 void RenderRegion::deleteAllRenderBoxRegionInfo()
366 {
367     m_renderBoxRegionInfo.clear();
368 }
369
370 LayoutUnit RenderRegion::logicalTopOfFlowThreadContentRect(const LayoutRect& rect) const
371 {
372     if (!m_isValid || !flowThread())
373         return 0;
374     return flowThread()->isHorizontalWritingMode() ? rect.y() : rect.x();
375 }
376
377 LayoutUnit RenderRegion::logicalBottomOfFlowThreadContentRect(const LayoutRect& rect) const
378 {
379     if (!m_isValid || !flowThread())
380         return 0;
381     return flowThread()->isHorizontalWritingMode() ? rect.maxY() : rect.maxX();
382 }
383
384 void RenderRegion::setRegionObjectsRegionStyle()
385 {
386     if (!hasCustomRegionStyle())
387         return;
388
389     // Start from content nodes and recursively compute the style in region for the render objects below.
390     // If the style in region was already computed, used that style instead of computing a new one.
391     RenderNamedFlowThread* namedFlow = view()->flowThreadController()->ensureRenderFlowThreadWithName(style()->regionThread());
392     const NamedFlowContentNodes& contentNodes = namedFlow->contentNodes();
393
394     for (NamedFlowContentNodes::const_iterator iter = contentNodes.begin(), end = contentNodes.end(); iter != end; ++iter) {
395         const Node* node = *iter;
396         // The list of content nodes contains also the nodes with display:none.
397         if (!node->renderer())
398             continue;
399
400         RenderObject* object = node->renderer();
401         // If the content node does not flow any of its children in this region,
402         // we do not compute any style for them in this region.
403         if (!flowThread()->objectInFlowRegion(object, this))
404             continue;
405
406         setObjectStyleInRegion(object);
407         setChildrenStyleInRegion(object);
408     }
409 }
410
411 static bool canCacheObjectStyleInRegion(const RenderStyle* styleInRegion, const RenderStyle* originalStyle)
412 {
413     ASSERT(styleInRegion);
414     ASSERT(originalStyle);
415
416     unsigned changedContextSensitiveProperties = ContextSensitivePropertyNone;
417     StyleDifference styleDiff = originalStyle->diff(styleInRegion, changedContextSensitiveProperties);
418     return styleDiff < StyleDifferenceLayoutPositionedMovementOnly;
419 }
420
421 // Restore the objects original style and cache the style in region for the objects
422 // for which it is safe to cache that style.
423 void RenderRegion::restoreRegionObjectsOriginalStyle()
424 {
425     if (!hasCustomRegionStyle())
426         return;
427
428     RenderObjectRegionStyleMap temp;
429     for (RenderObjectRegionStyleMap::iterator iter = m_renderObjectRegionStyle.begin(), end = m_renderObjectRegionStyle.end(); iter != end; ++iter) {
430         RenderObject* object = const_cast<RenderObject*>(iter->key);
431         RefPtr<RenderStyle> objectRegionStyle = object->style();
432         RefPtr<RenderStyle> objectOriginalStyle = iter->value.style;
433         object->setStyleInternal(objectOriginalStyle);
434
435         if (iter->value.canBeCached || canCacheObjectStyleInRegion(objectRegionStyle.get(), objectOriginalStyle.get())) {
436             ObjectRegionStyleInfo styleInfo;
437             styleInfo.style = objectRegionStyle;
438             styleInfo.canBeCached = true;
439             styleInfo.originalStyle = false;
440             temp.set(object, styleInfo);
441         }
442     }
443
444     m_renderObjectRegionStyle.swap(temp);
445 }
446
447 void RenderRegion::insertedIntoTree()
448 {
449     RenderReplaced::insertedIntoTree();
450
451     attachRegion();
452 }
453
454 void RenderRegion::willBeRemovedFromTree()
455 {
456     RenderReplaced::willBeRemovedFromTree();
457
458     detachRegion();
459 }
460
461 // We also need to compute parent's region style to inherit styling information.
462 // The computation of styles in region should not exceed content nodes boundaries.
463 PassRefPtr<RenderStyle> RenderRegion::computeStyleInRegion(const RenderObject* object)
464 {
465     ASSERT(object);
466     ASSERT(object->view());
467     ASSERT(object->view()->document());
468
469     if (object->isAnonymous())
470         return RenderStyle::createAnonymousStyleWithDisplay(ensureRegionStyleForObject(object->parent()), object->style()->display());
471
472     if (object->isText())
473         return RenderStyle::clone(ensureRegionStyleForObject(object->parent()));
474
475     // FIXME: Region styling fails for pseudo-elements because the renderers don't have a node.
476     ASSERT(object->node() && object->node()->isElementNode());
477     Element* element = toElement(object->node());
478     RefPtr<RenderStyle> renderObjectRegionStyle = object->view()->document()->styleResolver()->styleForElement(element,
479         element->inNamedFlow() ? 0 : ensureRegionStyleForObject(object->parent()) /*parent style in region*/, DisallowStyleSharing, MatchAllRules, this);
480
481     return renderObjectRegionStyle.release();
482 }
483
484 void RenderRegion::setChildrenStyleInRegion(const RenderObject* object)
485 {
486     for (RenderObject* child = object->firstChild(); child; child = child->nextSibling()) {
487         setObjectStyleInRegion(child);
488         setChildrenStyleInRegion(child);
489     }
490 }
491
492 static void setObjectHasBoxDecorationsFlag(RenderObject* object)
493 {
494     ASSERT(object);
495     ASSERT(object->inRenderFlowThread());
496
497     if (!object->isBoxModelObject() || object->hasBoxDecorations())
498         return;
499
500     bool hasBoxDecorations = object->isTableCell()
501         || object->style()->hasBackground()
502         || object->style()->hasBorder()
503         || object->style()->hasAppearance()
504         || object->style()->boxShadow();
505     object->setHasBoxDecorations(hasBoxDecorations);
506 }
507
508 // Set the current style for the object to be the style in region.
509 // If the style in region is not computed yet, compute it before replacing the original style.
510 // The original object style is stored so that it can be restored later.
511 void RenderRegion::setObjectStyleInRegion(RenderObject* object)
512 {
513     ASSERT(object->inRenderFlowThread());
514     ASSERT(!object->isRenderFlowThread());
515
516     RefPtr<RenderStyle> objectOriginalStyle = object->style();
517     RenderObjectRegionStyleMap::iterator it = m_renderObjectRegionStyle.find(object);
518
519     if (it == m_renderObjectRegionStyle.end()) {
520         ensureRegionStyleForObject(object);
521         it = m_renderObjectRegionStyle.find(object);
522     }
523
524     object->setStyleInternal(it->value.style);
525     setObjectHasBoxDecorationsFlag(object);
526
527     it->value.style = objectOriginalStyle;
528     it->value.originalStyle = true;
529 }
530
531 // Clear the style for the children of this object.
532 void RenderRegion::clearObjectStyleInRegion(const RenderObject* object)
533 {
534     ASSERT(object);
535     m_renderObjectRegionStyle.remove(object);
536
537     for (RenderObject* child = object->firstChild(); child; child = child->nextSibling())
538         clearObjectStyleInRegion(child);
539 }
540
541 RenderStyle* RenderRegion::ensureRegionStyleForObject(const RenderObject* object)
542 {
543     ASSERT(object);
544     ASSERT(object->inRenderFlowThread());
545
546     if (object->isRenderFlowThread())
547         return object->style();
548
549     RenderObjectRegionStyleMap::iterator it = m_renderObjectRegionStyle.find(object);
550     if (it != m_renderObjectRegionStyle.end()) {
551         // If the current value stored is the original style, it means that we already
552         // switched styles and the style in region can be retrived using style().
553         return it->value.originalStyle ? object->style() : it->value.style.get();
554     }
555
556     RefPtr<RenderStyle> objectStyleInRegion = computeStyleInRegion(object);
557
558     ObjectRegionStyleInfo styleInfo;
559     styleInfo.style = objectStyleInRegion;
560     styleInfo.originalStyle = false;
561     styleInfo.canBeCached = canCacheObjectStyleInRegion(objectStyleInRegion.get(), object->style());
562     m_renderObjectRegionStyle.add(object, styleInfo);
563
564     return objectStyleInRegion.get();
565 }
566
567 // FIXME: when RenderRegion will inherit from RenderBlock instead of RenderReplaced,
568 // we should overwrite computePreferredLogicalWidths ( see https://bugs.webkit.org/show_bug.cgi?id=74132 )
569 LayoutUnit RenderRegion::minPreferredLogicalWidth() const
570 {
571     if (!m_flowThread || !m_isValid)
572         return RenderReplaced::minPreferredLogicalWidth();
573
574     // FIXME: Currently, the code handles only the <length> case for min-width. It should also support other values, like percentage, calc
575     // or viewport relative.
576     RenderStyle* styleToUse = style();
577     LayoutUnit minPreferredLogicalWidth = m_flowThread->minPreferredLogicalWidth();
578
579     if (styleToUse->logicalMinWidth().isFixed() && styleToUse->logicalMinWidth().value() > 0)
580         minPreferredLogicalWidth = std::max(minPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(styleToUse->logicalMinWidth().value()));
581
582     if (styleToUse->logicalMaxWidth().isFixed())
583         minPreferredLogicalWidth = std::min(minPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(styleToUse->logicalMaxWidth().value()));
584
585     return minPreferredLogicalWidth + borderAndPaddingLogicalWidth();
586 }
587
588 LayoutUnit RenderRegion::maxPreferredLogicalWidth() const
589 {
590     if (!m_flowThread || !m_isValid)
591         return RenderReplaced::maxPreferredLogicalWidth();
592
593     // FIXME: Currently, the code handles only the <length> case for max-width. It should also support other values, like percentage, calc
594     // or viewport relative.
595     RenderStyle* styleToUse = style();
596     LayoutUnit maxPreferredLogicalWidth = m_flowThread->maxPreferredLogicalWidth();
597
598     if (styleToUse->logicalMinWidth().isFixed() && styleToUse->logicalMinWidth().value() > 0)
599         maxPreferredLogicalWidth = std::max(maxPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(styleToUse->logicalMinWidth().value()));
600
601     if (styleToUse->logicalMaxWidth().isFixed())
602         maxPreferredLogicalWidth = std::min(maxPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(styleToUse->logicalMaxWidth().value()));
603
604     return maxPreferredLogicalWidth + borderAndPaddingLogicalWidth();
605 }
606
607 void RenderRegion::getRanges(Vector<RefPtr<Range> >& rangeObjects) const
608 {
609     RenderNamedFlowThread* namedFlow = view()->flowThreadController()->ensureRenderFlowThreadWithName(style()->regionThread());
610     namedFlow->getRanges(rangeObjects, this);
611 }
612
613 void RenderRegion::updateLogicalHeight()
614 {
615     RenderReplaced::updateLogicalHeight();
616
617     if (!hasAutoLogicalHeight())
618         return;
619
620     // We want to update the logical height based on the computed override logical
621     // content height only if the view is in the layout phase
622     // in which all the auto logical height regions have their override logical height set.
623     if (view()->normalLayoutPhase())
624         return;
625
626     // There may be regions with auto logical height that during the prerequisite layout phase
627     // did not have the chance to layout flow thread content. Because of that, these regions do not
628     // have an overrideLogicalContentHeight computed and they will not be able to fragment any flow
629     // thread content.
630     if (!hasOverrideHeight())
631         return;
632
633     LayoutUnit newLogicalHeight = overrideLogicalContentHeight() + borderAndPaddingLogicalHeight();
634     ASSERT(newLogicalHeight < LayoutUnit::max() / 2);
635     if (newLogicalHeight > logicalHeight())
636         setLogicalHeight(newLogicalHeight);
637 }
638
639 bool RenderRegion::needsOverrideLogicalContentHeightComputation() const
640 {
641     return hasAutoLogicalHeight() && view()->normalLayoutPhase() && !hasOverrideHeight();
642 }
643
644 } // namespace WebCore