1/*
2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public License
16 * along with this library; see the file COPYING.LIB.  If not, write to
17 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
19 */
20
21#include "config.h"
22#include "core/rendering/RenderView.h"
23
24#include "core/dom/Document.h"
25#include "core/dom/Element.h"
26#include "core/frame/LocalFrame.h"
27#include "core/html/HTMLFrameOwnerElement.h"
28#include "core/html/HTMLIFrameElement.h"
29#include "core/page/Page.h"
30#include "core/paint/ViewPainter.h"
31#include "core/rendering/ColumnInfo.h"
32#include "core/rendering/FlowThreadController.h"
33#include "core/rendering/GraphicsContextAnnotator.h"
34#include "core/rendering/HitTestResult.h"
35#include "core/rendering/RenderFlowThread.h"
36#include "core/rendering/RenderGeometryMap.h"
37#include "core/rendering/RenderLayer.h"
38#include "core/rendering/RenderPart.h"
39#include "core/rendering/RenderQuote.h"
40#include "core/rendering/RenderSelectionInfo.h"
41#include "core/rendering/compositing/CompositedLayerMapping.h"
42#include "core/rendering/compositing/RenderLayerCompositor.h"
43#include "core/svg/SVGDocumentExtensions.h"
44#include "platform/TraceEvent.h"
45#include "platform/geometry/FloatQuad.h"
46#include "platform/geometry/TransformState.h"
47#include "platform/graphics/GraphicsContext.h"
48
49namespace blink {
50
51RenderView::RenderView(Document* document)
52    : RenderBlockFlow(document)
53    , m_frameView(document->view())
54    , m_selectionStart(nullptr)
55    , m_selectionEnd(nullptr)
56    , m_selectionStartPos(-1)
57    , m_selectionEndPos(-1)
58    , m_pageLogicalHeight(0)
59    , m_pageLogicalHeightChanged(false)
60    , m_layoutState(0)
61    , m_renderQuoteHead(nullptr)
62    , m_renderCounterCount(0)
63    , m_hitTestCount(0)
64{
65    // init RenderObject attributes
66    setInline(false);
67
68    m_minPreferredLogicalWidth = 0;
69    m_maxPreferredLogicalWidth = 0;
70
71    setPreferredLogicalWidthsDirty(MarkOnlyThis);
72
73    setPositionState(AbsolutePosition); // to 0,0 :)
74}
75
76RenderView::~RenderView()
77{
78}
79
80void RenderView::trace(Visitor* visitor)
81{
82    visitor->trace(m_selectionStart);
83    visitor->trace(m_selectionEnd);
84    visitor->trace(m_renderQuoteHead);
85    RenderBlockFlow::trace(visitor);
86}
87
88bool RenderView::hitTest(const HitTestRequest& request, HitTestResult& result)
89{
90    return hitTest(request, result.hitTestLocation(), result);
91}
92
93bool RenderView::hitTest(const HitTestRequest& request, const HitTestLocation& location, HitTestResult& result)
94{
95    TRACE_EVENT0("blink", "RenderView::hitTest");
96    m_hitTestCount++;
97
98    // We have to recursively update layout/style here because otherwise, when the hit test recurses
99    // into a child document, it could trigger a layout on the parent document, which can destroy RenderLayers
100    // that are higher up in the call stack, leading to crashes.
101    // Note that Document::updateLayout calls its parent's updateLayout.
102    // FIXME: It should be the caller's responsibility to ensure an up-to-date layout.
103    frameView()->updateLayoutAndStyleIfNeededRecursive();
104
105    bool hitLayer = layer()->hitTest(request, location, result);
106
107    // ScrollView scrollbars are not the same as RenderLayer scrollbars tested by RenderLayer::hitTestOverflowControls,
108    // so we need to test ScrollView scrollbars separately here. Note that it's important we do this after
109    // the hit test above, because that may overwrite the entire HitTestResult when it finds a hit.
110    IntPoint viewPoint = location.roundedPoint() - frameView()->scrollOffset();
111    if (Scrollbar* frameScrollbar = frameView()->scrollbarAtViewPoint(viewPoint))
112        result.setScrollbar(frameScrollbar);
113
114    return hitLayer;
115}
116
117void RenderView::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit, LogicalExtentComputedValues& computedValues) const
118{
119    computedValues.m_extent = (!shouldUsePrintingLayout() && m_frameView) ? LayoutUnit(viewLogicalHeight()) : logicalHeight;
120}
121
122void RenderView::updateLogicalWidth()
123{
124    if (!shouldUsePrintingLayout() && m_frameView)
125        setLogicalWidth(viewLogicalWidth());
126}
127
128LayoutUnit RenderView::availableLogicalHeight(AvailableLogicalHeightType heightType) const
129{
130    // If we have columns, then the available logical height is reduced to the column height.
131    if (hasColumns())
132        return columnInfo()->columnHeight();
133    return RenderBlockFlow::availableLogicalHeight(heightType);
134}
135
136bool RenderView::isChildAllowed(RenderObject* child, RenderStyle*) const
137{
138    return child->isBox();
139}
140
141void RenderView::layoutContent()
142{
143    ASSERT(needsLayout());
144
145    RenderBlockFlow::layout();
146
147#if ENABLE(ASSERT)
148    checkLayoutState();
149#endif
150}
151
152#if ENABLE(ASSERT)
153void RenderView::checkLayoutState()
154{
155    ASSERT(!m_layoutState->next());
156}
157#endif
158
159bool RenderView::shouldDoFullPaintInvalidationForNextLayout() const
160{
161    // It's hard to predict here which of full paint invalidation or per-descendant paint invalidation costs less.
162    // For vertical writing mode or width change it's more likely that per-descendant paint invalidation
163    // eventually turns out to be full paint invalidation but with the cost to handle more layout states
164    // and discrete paint invalidation rects, so marking full paint invalidation here is more likely to cost less.
165    // Otherwise, per-descendant paint invalidation is more likely to avoid unnecessary full paint invalidation.
166
167    if (shouldUsePrintingLayout())
168        return true;
169
170    if (!style()->isHorizontalWritingMode() || width() != viewWidth())
171        return true;
172
173    if (height() != viewHeight()) {
174        if (RenderObject* backgroundRenderer = this->backgroundRenderer()) {
175            // When background-attachment is 'fixed', we treat the viewport (instead of the 'root'
176            // i.e. html or body) as the background positioning area, and we should full paint invalidation
177            // viewport resize if the background image is not composited and needs full paint invalidation on
178            // background positioning area resize.
179            if (!m_compositor || !m_compositor->needsFixedRootBackgroundLayer(layer())) {
180                if (backgroundRenderer->style()->hasFixedBackgroundImage()
181                    && mustInvalidateFillLayersPaintOnHeightChange(backgroundRenderer->style()->backgroundLayers()))
182                    return true;
183            }
184        }
185    }
186
187    return false;
188}
189
190void RenderView::layout()
191{
192    if (!document().paginated())
193        setPageLogicalHeight(0);
194
195    if (shouldUsePrintingLayout())
196        m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = logicalWidth();
197
198    SubtreeLayoutScope layoutScope(*this);
199
200    // Use calcWidth/Height to get the new width/height, since this will take the full page zoom factor into account.
201    bool relayoutChildren = !shouldUsePrintingLayout() && (!m_frameView || width() != viewWidth() || height() != viewHeight());
202    if (relayoutChildren) {
203        layoutScope.setChildNeedsLayout(this);
204        for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
205            if (child->isSVGRoot())
206                continue;
207
208            if ((child->isBox() && toRenderBox(child)->hasRelativeLogicalHeight())
209                    || child->style()->logicalHeight().isPercent()
210                    || child->style()->logicalMinHeight().isPercent()
211                    || child->style()->logicalMaxHeight().isPercent())
212                layoutScope.setChildNeedsLayout(child);
213        }
214
215        if (document().svgExtensions())
216            document().accessSVGExtensions().invalidateSVGRootsWithRelativeLengthDescendents(&layoutScope);
217    }
218
219    ASSERT(!m_layoutState);
220    if (!needsLayout())
221        return;
222
223    LayoutState rootLayoutState(pageLogicalHeight(), pageLogicalHeightChanged(), *this);
224
225    m_pageLogicalHeightChanged = false;
226
227    layoutContent();
228
229#if ENABLE(ASSERT)
230    checkLayoutState();
231#endif
232    clearNeedsLayout();
233}
234
235void RenderView::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const
236{
237    ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == static_cast<bool>(mode & IsFixed));
238
239    if (!paintInvalidationContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) {
240        TransformationMatrix t;
241        getTransformFromContainer(0, LayoutSize(), t);
242        transformState.applyTransform(t);
243    }
244
245    if (mode & IsFixed && m_frameView)
246        transformState.move(m_frameView->scrollOffsetForFixedPosition());
247
248    if (paintInvalidationContainer == this)
249        return;
250
251    if (mode & TraverseDocumentBoundaries) {
252        if (RenderObject* parentDocRenderer = frame()->ownerRenderer()) {
253            transformState.move(-frame()->view()->scrollOffset());
254            if (parentDocRenderer->isBox())
255                transformState.move(toLayoutSize(toRenderBox(parentDocRenderer)->contentBoxRect().location()));
256            parentDocRenderer->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
257            return;
258        }
259    }
260}
261
262const RenderObject* RenderView::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
263{
264    LayoutSize offsetForFixedPosition;
265    LayoutSize offset;
266    RenderObject* container = 0;
267
268    if (m_frameView)
269        offsetForFixedPosition = m_frameView->scrollOffsetForFixedPosition();
270
271    if (geometryMap.mapCoordinatesFlags() & TraverseDocumentBoundaries) {
272        if (RenderPart* parentDocRenderer = frame()->ownerRenderer()) {
273            offset = -m_frameView->scrollOffset();
274            offset += toLayoutSize(parentDocRenderer->contentBoxRect().location());
275            container = parentDocRenderer;
276        }
277    }
278
279    // If a container was specified, and was not 0 or the RenderView, then we
280    // should have found it by now unless we're traversing to a parent document.
281    ASSERT_ARG(ancestorToStopAt, !ancestorToStopAt || ancestorToStopAt == this || container);
282
283    if ((!ancestorToStopAt || container) && shouldUseTransformFromContainer(container)) {
284        TransformationMatrix t;
285        getTransformFromContainer(container, LayoutSize(), t);
286        geometryMap.push(this, t, false, false, false, true, offsetForFixedPosition);
287    } else {
288        geometryMap.push(this, offset, false, false, false, false, offsetForFixedPosition);
289    }
290
291    return container;
292}
293
294void RenderView::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, TransformState& transformState) const
295{
296    if (mode & IsFixed && m_frameView)
297        transformState.move(m_frameView->scrollOffsetForFixedPosition());
298
299    if (mode & UseTransforms && shouldUseTransformFromContainer(0)) {
300        TransformationMatrix t;
301        getTransformFromContainer(0, LayoutSize(), t);
302        transformState.applyTransform(t);
303    }
304}
305
306void RenderView::computeSelfHitTestRects(Vector<LayoutRect>& rects, const LayoutPoint&) const
307{
308    // Record the entire size of the contents of the frame. Note that we don't just
309    // use the viewport size (containing block) here because we want to ensure this includes
310    // all children (so we can avoid walking them explicitly).
311    rects.append(LayoutRect(LayoutPoint::zero(), frameView()->contentsSize()));
312}
313
314void RenderView::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
315{
316    ViewPainter(*this).paint(paintInfo, paintOffset);
317}
318
319void RenderView::paintBoxDecorationBackground(PaintInfo& paintInfo, const LayoutPoint&)
320{
321    ViewPainter(*this).paintBoxDecorationBackground(paintInfo);
322}
323
324void RenderView::invalidateTreeIfNeeded(const PaintInvalidationState& paintInvalidationState)
325{
326    ASSERT(!needsLayout());
327
328    // We specifically need to issue paint invalidations for the viewRect since other renderers
329    // short-circuit on full-paint invalidation.
330    LayoutRect dirtyRect = viewRect();
331    if (doingFullPaintInvalidation() && !dirtyRect.isEmpty()) {
332        const RenderLayerModelObject* paintInvalidationContainer = &paintInvalidationState.paintInvalidationContainer();
333        mapRectToPaintInvalidationBacking(paintInvalidationContainer, dirtyRect, &paintInvalidationState);
334        invalidatePaintUsingContainer(paintInvalidationContainer, dirtyRect, InvalidationFull);
335    }
336    RenderBlock::invalidateTreeIfNeeded(paintInvalidationState);
337}
338
339void RenderView::invalidatePaintForRectangle(const LayoutRect& paintInvalidationRect) const
340{
341    ASSERT(!paintInvalidationRect.isEmpty());
342
343    if (document().printing() || !m_frameView)
344        return;
345
346    ASSERT(layer()->compositingState() == PaintsIntoOwnBacking || !frame()->ownerRenderer());
347
348    if (layer()->compositingState() == PaintsIntoOwnBacking) {
349        setBackingNeedsPaintInvalidationInRect(paintInvalidationRect);
350    } else {
351        m_frameView->contentRectangleForPaintInvalidation(pixelSnappedIntRect(paintInvalidationRect));
352    }
353}
354
355void RenderView::invalidatePaintForViewAndCompositedLayers()
356{
357    setShouldDoFullPaintInvalidation(true);
358
359    // The only way we know how to hit these ASSERTS below this point is via the Chromium OS login screen.
360    DisableCompositingQueryAsserts disabler;
361
362    if (compositor()->inCompositingMode())
363        compositor()->fullyInvalidatePaint();
364}
365
366void RenderView::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* invalidationState) const
367{
368    mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, IsNotFixedPosition, invalidationState);
369}
370
371void RenderView::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, ViewportConstrainedPosition viewportConstraint, const PaintInvalidationState* state) const
372{
373    if (document().printing())
374        return;
375
376    if (style()->isFlippedBlocksWritingMode()) {
377        // We have to flip by hand since the view's logical height has not been determined.  We
378        // can use the viewport width and height.
379        if (style()->isHorizontalWritingMode())
380            rect.setY(viewHeight() - rect.maxY());
381        else
382            rect.setX(viewWidth() - rect.maxX());
383    }
384
385    if (viewportConstraint == IsFixedPosition && m_frameView) {
386        rect.move(m_frameView->scrollOffsetForFixedPosition());
387        // If we have a pending scroll, invalidate the previous scroll position.
388        if (!m_frameView->pendingScrollDelta().isZero()) {
389            rect.move(-m_frameView->pendingScrollDelta());
390        }
391    }
392
393    // Apply our transform if we have one (because of full page zooming).
394    if (!paintInvalidationContainer && layer() && layer()->transform())
395        rect = layer()->transform()->mapRect(rect);
396
397    ASSERT(paintInvalidationContainer);
398    if (paintInvalidationContainer == this)
399        return;
400
401    Element* owner = document().ownerElement();
402    if (!owner)
403        return;
404
405    if (RenderBox* obj = owner->renderBox()) {
406        // Intersect the viewport with the paint invalidation rect.
407        LayoutRect viewRectangle = viewRect();
408        rect.intersect(viewRectangle);
409
410        // Adjust for scroll offset of the view.
411        rect.moveBy(-viewRectangle.location());
412
413        // Adjust for frame border.
414        rect.moveBy(obj->contentBoxRect().location());
415        obj->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, 0);
416    }
417}
418
419
420void RenderView::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
421{
422    rects.append(pixelSnappedIntRect(accumulatedOffset, layer()->size()));
423}
424
425void RenderView::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
426{
427    if (wasFixed)
428        *wasFixed = false;
429    quads.append(FloatRect(FloatPoint(), layer()->size()));
430}
431
432static RenderObject* rendererAfterPosition(RenderObject* object, unsigned offset)
433{
434    if (!object)
435        return 0;
436
437    RenderObject* child = object->childAt(offset);
438    return child ? child : object->nextInPreOrderAfterChildren();
439}
440
441IntRect RenderView::selectionBounds() const
442{
443    typedef WillBeHeapHashMap<RawPtrWillBeMember<RenderObject>, OwnPtrWillBeMember<RenderSelectionInfo> > SelectionMap;
444    SelectionMap selectedObjects;
445
446    RenderObject* os = m_selectionStart;
447    RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
448    while (os && os != stop) {
449        if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
450            // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
451            selectedObjects.set(os, adoptPtrWillBeNoop(new RenderSelectionInfo(os)));
452            RenderBlock* cb = os->containingBlock();
453            while (cb && !cb->isRenderView()) {
454                OwnPtrWillBeMember<RenderSelectionInfo>& blockInfo = selectedObjects.add(cb, nullptr).storedValue->value;
455                if (blockInfo)
456                    break;
457                blockInfo = adoptPtrWillBeNoop(new RenderSelectionInfo(cb));
458                cb = cb->containingBlock();
459            }
460        }
461
462        os = os->nextInPreOrder();
463    }
464
465    // Now create a single bounding box rect that encloses the whole selection.
466    LayoutRect selRect;
467    SelectionMap::iterator end = selectedObjects.end();
468    for (SelectionMap::iterator i = selectedObjects.begin(); i != end; ++i) {
469        RenderSelectionInfo* info = i->value.get();
470        // RenderSelectionInfo::rect() is in the coordinates of the paintInvalidationContainer, so map to page coordinates.
471        LayoutRect currRect = info->rect();
472        if (const RenderLayerModelObject* paintInvalidationContainer = info->paintInvalidationContainer()) {
473            FloatQuad absQuad = paintInvalidationContainer->localToAbsoluteQuad(FloatRect(currRect));
474            currRect = absQuad.enclosingBoundingBox();
475        }
476        selRect.unite(currRect);
477    }
478    return pixelSnappedIntRect(selRect);
479}
480
481void RenderView::invalidatePaintForSelection() const
482{
483    HashSet<RenderBlock*> processedBlocks;
484
485    // For querying RenderLayer::compositingState()
486    // FIXME: this may be wrong. crbug.com/407416
487    DisableCompositingQueryAsserts disabler;
488
489    RenderObject* end = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
490    for (RenderObject* o = m_selectionStart; o && o != end; o = o->nextInPreOrder()) {
491        if (!o->canBeSelectionLeaf() && o != m_selectionStart && o != m_selectionEnd)
492            continue;
493        if (o->selectionState() == SelectionNone)
494            continue;
495
496        RenderSelectionInfo(o).invalidatePaint();
497
498        // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
499        for (RenderBlock* block = o->containingBlock(); block && !block->isRenderView(); block = block->containingBlock()) {
500            if (!processedBlocks.add(block).isNewEntry)
501                break;
502            RenderSelectionInfo(block).invalidatePaint();
503        }
504    }
505}
506
507// When exploring the RenderTree looking for the nodes involved in the Selection, sometimes it's
508// required to change the traversing direction because the "start" position is below the "end" one.
509static inline RenderObject* getNextOrPrevRenderObjectBasedOnDirection(const RenderObject* o, const RenderObject* stop, bool& continueExploring, bool& exploringBackwards)
510{
511    RenderObject* next;
512    if (exploringBackwards) {
513        next = o->previousInPreOrder();
514        continueExploring = next && !(next)->isRenderView();
515    } else {
516        next = o->nextInPreOrder();
517        continueExploring = next && next != stop;
518        exploringBackwards = !next && (next != stop);
519        if (exploringBackwards) {
520            next = stop->previousInPreOrder();
521            continueExploring = next && !next->isRenderView();
522        }
523    }
524
525    return next;
526}
527
528void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* end, int endPos, SelectionPaintInvalidationMode blockPaintInvalidationMode)
529{
530    // This code makes no assumptions as to if the rendering tree is up to date or not
531    // and will not try to update it. Currently clearSelection calls this
532    // (intentionally) without updating the rendering tree as it doesn't care.
533    // Other callers may want to force recalc style before calling this.
534
535    // Make sure both our start and end objects are defined.
536    // Check www.msnbc.com and try clicking around to find the case where this happened.
537    if ((start && !end) || (end && !start))
538        return;
539
540    // Just return if the selection hasn't changed.
541    if (m_selectionStart == start && m_selectionStartPos == startPos &&
542        m_selectionEnd == end && m_selectionEndPos == endPos)
543        return;
544
545    // Record the old selected objects.  These will be used later
546    // when we compare against the new selected objects.
547    int oldStartPos = m_selectionStartPos;
548    int oldEndPos = m_selectionEndPos;
549
550    // Objects each have a single selection rect to examine.
551    typedef WillBeHeapHashMap<RawPtrWillBeMember<RenderObject>, OwnPtrWillBeMember<RenderSelectionInfo> > SelectedObjectMap;
552    SelectedObjectMap oldSelectedObjects;
553    SelectedObjectMap newSelectedObjects;
554
555    // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
556    // In order to get the paint invalidation rect right, we have to examine left, middle, and right rects individually, since otherwise
557    // the union of those rects might remain the same even when changes have occurred.
558    typedef WillBeHeapHashMap<RawPtrWillBeMember<RenderBlock>, OwnPtrWillBeMember<RenderBlockSelectionInfo> > SelectedBlockMap;
559    SelectedBlockMap oldSelectedBlocks;
560    SelectedBlockMap newSelectedBlocks;
561
562    RenderObject* os = m_selectionStart;
563    RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
564    bool exploringBackwards = false;
565    bool continueExploring = os && (os != stop);
566    while (continueExploring) {
567        if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
568            // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
569            oldSelectedObjects.set(os, adoptPtrWillBeNoop(new RenderSelectionInfo(os)));
570            if (blockPaintInvalidationMode == PaintInvalidationNewXOROld) {
571                RenderBlock* cb = os->containingBlock();
572                while (cb && !cb->isRenderView()) {
573                    OwnPtrWillBeMember<RenderBlockSelectionInfo>& blockInfo = oldSelectedBlocks.add(cb, nullptr).storedValue->value;
574                    if (blockInfo)
575                        break;
576                    blockInfo = adoptPtrWillBeNoop(new RenderBlockSelectionInfo(cb));
577                    cb = cb->containingBlock();
578                }
579            }
580        }
581
582        os = getNextOrPrevRenderObjectBasedOnDirection(os, stop, continueExploring, exploringBackwards);
583    }
584
585    // Now clear the selection.
586    SelectedObjectMap::iterator oldObjectsEnd = oldSelectedObjects.end();
587    for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i)
588        i->key->setSelectionStateIfNeeded(SelectionNone);
589
590    // set selection start and end
591    m_selectionStart = start;
592    m_selectionStartPos = startPos;
593    m_selectionEnd = end;
594    m_selectionEndPos = endPos;
595
596    // Update the selection status of all objects between m_selectionStart and m_selectionEnd
597    if (start && start == end)
598        start->setSelectionStateIfNeeded(SelectionBoth);
599    else {
600        if (start)
601            start->setSelectionStateIfNeeded(SelectionStart);
602        if (end)
603            end->setSelectionStateIfNeeded(SelectionEnd);
604    }
605
606    RenderObject* o = start;
607    stop = rendererAfterPosition(end, endPos);
608
609    while (o && o != stop) {
610        if (o != start && o != end && o->canBeSelectionLeaf())
611            o->setSelectionStateIfNeeded(SelectionInside);
612        o = o->nextInPreOrder();
613    }
614
615    if (blockPaintInvalidationMode != PaintInvalidationNothing)
616        layer()->clearBlockSelectionGapsBounds();
617
618    // Now that the selection state has been updated for the new objects, walk them again and
619    // put them in the new objects list.
620    o = start;
621    exploringBackwards = false;
622    continueExploring = o && (o != stop);
623    while (continueExploring) {
624        if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
625            newSelectedObjects.set(o, adoptPtrWillBeNoop(new RenderSelectionInfo(o)));
626            RenderBlock* cb = o->containingBlock();
627            while (cb && !cb->isRenderView()) {
628                OwnPtrWillBeMember<RenderBlockSelectionInfo>& blockInfo = newSelectedBlocks.add(cb, nullptr).storedValue->value;
629                if (blockInfo)
630                    break;
631                blockInfo = adoptPtrWillBeNoop(new RenderBlockSelectionInfo(cb));
632                cb = cb->containingBlock();
633            }
634        }
635
636        o = getNextOrPrevRenderObjectBasedOnDirection(o, stop, continueExploring, exploringBackwards);
637    }
638
639    if (!m_frameView || blockPaintInvalidationMode == PaintInvalidationNothing)
640        return;
641
642    // For querying RenderLayer::compositingState()
643    // FIXME: this is wrong, selection should not cause eager invalidation. crbug.com/407416
644    DisableCompositingQueryAsserts disabler;
645
646    // Have any of the old selected objects changed compared to the new selection?
647    for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i) {
648        RenderObject* obj = i->key;
649        RenderSelectionInfo* newInfo = newSelectedObjects.get(obj);
650        RenderSelectionInfo* oldInfo = i->value.get();
651        if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||
652            (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
653            (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
654            oldInfo->invalidatePaint();
655            if (newInfo) {
656                newInfo->invalidatePaint();
657                newSelectedObjects.remove(obj);
658            }
659        }
660    }
661
662    // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
663    SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
664    for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i)
665        i->value->invalidatePaint();
666
667    // Have any of the old blocks changed?
668    SelectedBlockMap::iterator oldBlocksEnd = oldSelectedBlocks.end();
669    for (SelectedBlockMap::iterator i = oldSelectedBlocks.begin(); i != oldBlocksEnd; ++i) {
670        RenderBlock* block = i->key;
671        RenderBlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
672        RenderBlockSelectionInfo* oldInfo = i->value.get();
673        if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {
674            oldInfo->invalidatePaint();
675            if (newInfo) {
676                newInfo->invalidatePaint();
677                newSelectedBlocks.remove(block);
678            }
679        }
680    }
681
682    // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
683    SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
684    for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i)
685        i->value->invalidatePaint();
686}
687
688void RenderView::getSelection(RenderObject*& startRenderer, int& startOffset, RenderObject*& endRenderer, int& endOffset) const
689{
690    startRenderer = m_selectionStart;
691    startOffset = m_selectionStartPos;
692    endRenderer = m_selectionEnd;
693    endOffset = m_selectionEndPos;
694}
695
696void RenderView::clearSelection()
697{
698    // For querying RenderLayer::compositingState()
699    // This is correct, since destroying render objects needs to cause eager paint invalidations.
700    DisableCompositingQueryAsserts disabler;
701
702    layer()->invalidatePaintForBlockSelectionGaps();
703    setSelection(0, -1, 0, -1, PaintInvalidationNewMinusOld);
704}
705
706void RenderView::selectionStartEnd(int& startPos, int& endPos) const
707{
708    startPos = m_selectionStartPos;
709    endPos = m_selectionEndPos;
710}
711
712bool RenderView::shouldUsePrintingLayout() const
713{
714    if (!document().printing() || !m_frameView)
715        return false;
716    return m_frameView->frame().shouldUsePrintingLayout();
717}
718
719LayoutRect RenderView::viewRect() const
720{
721    if (shouldUsePrintingLayout())
722        return LayoutRect(LayoutPoint(), size());
723    if (m_frameView)
724        return m_frameView->visibleContentRect();
725    return LayoutRect();
726}
727
728IntRect RenderView::unscaledDocumentRect() const
729{
730    LayoutRect overflowRect(layoutOverflowRect());
731    flipForWritingMode(overflowRect);
732    return pixelSnappedIntRect(overflowRect);
733}
734
735bool RenderView::rootBackgroundIsEntirelyFixed() const
736{
737    if (RenderObject* backgroundRenderer = this->backgroundRenderer())
738        return backgroundRenderer->hasEntirelyFixedBackground();
739    return false;
740}
741
742RenderObject* RenderView::backgroundRenderer() const
743{
744    if (Element* documentElement = document().documentElement()) {
745        if (RenderObject* rootObject = documentElement->renderer())
746            return rootObject->rendererForRootBackground();
747    }
748    return 0;
749}
750
751LayoutRect RenderView::backgroundRect(RenderBox* backgroundRenderer) const
752{
753    if (!hasColumns())
754        return unscaledDocumentRect();
755
756    ColumnInfo* columnInfo = this->columnInfo();
757    LayoutRect backgroundRect(0, 0, columnInfo->desiredColumnWidth(), columnInfo->columnHeight() * columnInfo->columnCount());
758    if (!isHorizontalWritingMode())
759        backgroundRect = backgroundRect.transposedRect();
760    backgroundRenderer->flipForWritingMode(backgroundRect);
761
762    return backgroundRect;
763}
764
765IntRect RenderView::documentRect() const
766{
767    FloatRect overflowRect(unscaledDocumentRect());
768    if (hasTransform())
769        overflowRect = layer()->currentTransform().mapRect(overflowRect);
770    return IntRect(overflowRect);
771}
772
773int RenderView::viewHeight(IncludeScrollbarsInRect scrollbarInclusion) const
774{
775    int height = 0;
776    if (!shouldUsePrintingLayout() && m_frameView)
777        height = m_frameView->layoutSize(scrollbarInclusion).height();
778
779    return height;
780}
781
782int RenderView::viewWidth(IncludeScrollbarsInRect scrollbarInclusion) const
783{
784    int width = 0;
785    if (!shouldUsePrintingLayout() && m_frameView)
786        width = m_frameView->layoutSize(scrollbarInclusion).width();
787
788    return width;
789}
790
791int RenderView::viewLogicalHeight() const
792{
793    return style()->isHorizontalWritingMode() ? viewHeight(ExcludeScrollbars) : viewWidth(ExcludeScrollbars);
794}
795
796LayoutUnit RenderView::viewLogicalHeightForPercentages() const
797{
798    if (shouldUsePrintingLayout())
799        return pageLogicalHeight();
800    return viewLogicalHeight();
801}
802
803float RenderView::zoomFactor() const
804{
805    return m_frameView->frame().pageZoomFactor();
806}
807
808void RenderView::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
809{
810    if (result.innerNode())
811        return;
812
813    Node* node = document().documentElement();
814    if (node) {
815        result.setInnerNode(node);
816        if (!result.innerNonSharedNode())
817            result.setInnerNonSharedNode(node);
818
819        LayoutPoint adjustedPoint = point;
820        offsetForContents(adjustedPoint);
821
822        result.setLocalPoint(adjustedPoint);
823    }
824}
825
826bool RenderView::usesCompositing() const
827{
828    return m_compositor && m_compositor->staleInCompositingMode();
829}
830
831RenderLayerCompositor* RenderView::compositor()
832{
833    if (!m_compositor)
834        m_compositor = adoptPtr(new RenderLayerCompositor(*this));
835
836    return m_compositor.get();
837}
838
839void RenderView::setIsInWindow(bool isInWindow)
840{
841    if (m_compositor)
842        m_compositor->setIsInWindow(isInWindow);
843}
844
845FlowThreadController* RenderView::flowThreadController()
846{
847    if (!m_flowThreadController)
848        m_flowThreadController = FlowThreadController::create();
849
850    return m_flowThreadController.get();
851}
852
853void RenderView::pushLayoutState(LayoutState& layoutState)
854{
855    if (m_flowThreadController) {
856        RenderFlowThread* currentFlowThread = m_flowThreadController->currentRenderFlowThread();
857        if (currentFlowThread)
858            currentFlowThread->pushFlowThreadLayoutState(layoutState.renderer());
859    }
860    m_layoutState = &layoutState;
861}
862
863void RenderView::popLayoutState()
864{
865    ASSERT(m_layoutState);
866    m_layoutState = m_layoutState->next();
867    if (!m_flowThreadController)
868        return;
869
870    RenderFlowThread* currentFlowThread = m_flowThreadController->currentRenderFlowThread();
871    if (!currentFlowThread)
872        return;
873
874    currentFlowThread->popFlowThreadLayoutState();
875}
876
877IntervalArena* RenderView::intervalArena()
878{
879    if (!m_intervalArena)
880        m_intervalArena = IntervalArena::create();
881    return m_intervalArena.get();
882}
883
884bool RenderView::backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const
885{
886    // FIXME: Remove this main frame check. Same concept applies to subframes too.
887    if (!frame()->isMainFrame())
888        return false;
889
890    return m_frameView->hasOpaqueBackground();
891}
892
893double RenderView::layoutViewportWidth() const
894{
895    float scale = m_frameView ? m_frameView->frame().pageZoomFactor() : 1;
896    return viewWidth(IncludeScrollbars) / scale;
897}
898
899double RenderView::layoutViewportHeight() const
900{
901    float scale = m_frameView ? m_frameView->frame().pageZoomFactor() : 1;
902    return viewHeight(IncludeScrollbars) / scale;
903}
904
905} // namespace blink
906