src/third_party/WebKit/Source/core/rendering/RenderView.cpp

   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
  49 namespace blink {
  50
  51 RenderView::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
  76 RenderView::~RenderView()
  77 {
  78 }
  79
  80 void 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
  88 bool RenderView::hitTest(const HitTestRequest& request, HitTestResult& result)
  89 {
  90     return hitTest(request, result.hitTestLocation(), result);
  91 }
  92
  93 bool 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
 117 void RenderView::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit, LogicalExtentComputedValues& computedValues) const
 118 {
 119     computedValues.m_extent = (!shouldUsePrintingLayout() && m_frameView) ? LayoutUnit(viewLogicalHeight()) : logicalHeight;
 120 }
 121
 122 void RenderView::updateLogicalWidth()
 123 {
 124     if (!shouldUsePrintingLayout() && m_frameView)
 125         setLogicalWidth(viewLogicalWidth());
 126 }
 127
 128 LayoutUnit 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
 136 bool RenderView::isChildAllowed(RenderObject* child, RenderStyle*) const
 137 {
 138     return child->isBox();
 139 }
 140
 141 void 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)
 153 void RenderView::checkLayoutState()
 154 {
 155     ASSERT(!m_layoutState->next());
 156 }
 157 #endif
 158
 159 bool 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
 190 void 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
 235 void 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
 262 const 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
 294 void 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
 306 void 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
 314 void RenderView::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 315 {
 316     ViewPainter(*this).paint(paintInfo, paintOffset);
 317 }
 318
 319 void RenderView::paintBoxDecorationBackground(PaintInfo& paintInfo, const LayoutPoint&)
 320 {
 321     ViewPainter(*this).paintBoxDecorationBackground(paintInfo);
 322 }
 323
 324 void 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
 339 void 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
 355 void 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
 366 void RenderView::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* invalidationState) const
 367 {
 368     mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, IsNotFixedPosition, invalidationState);
 369 }
 370
 371 void 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
 420 void RenderView::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 421 {
 422     rects.append(pixelSnappedIntRect(accumulatedOffset, layer()->size()));
 423 }
 424
 425 void RenderView::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
 426 {
 427     if (wasFixed)
 428         *wasFixed = false;
 429     quads.append(FloatRect(FloatPoint(), layer()->size()));
 430 }
 431
 432 static 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
 441 IntRect 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
 481 void 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.
 509 static 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
 528 void 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
 688 void 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
 696 void 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
 706 void RenderView::selectionStartEnd(int& startPos, int& endPos) const
 707 {
 708     startPos = m_selectionStartPos;
 709     endPos = m_selectionEndPos;
 710 }
 711
 712 bool RenderView::shouldUsePrintingLayout() const
 713 {
 714     if (!document().printing() || !m_frameView)
 715         return false;
 716     return m_frameView->frame().shouldUsePrintingLayout();
 717 }
 718
 719 LayoutRect 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
 728 IntRect RenderView::unscaledDocumentRect() const
 729 {
 730     LayoutRect overflowRect(layoutOverflowRect());
 731     flipForWritingMode(overflowRect);
 732     return pixelSnappedIntRect(overflowRect);
 733 }
 734
 735 bool RenderView::rootBackgroundIsEntirelyFixed() const
 736 {
 737     if (RenderObject* backgroundRenderer = this->backgroundRenderer())
 738         return backgroundRenderer->hasEntirelyFixedBackground();
 739     return false;
 740 }
 741
 742 RenderObject* 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
 751 LayoutRect 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
 765 IntRect RenderView::documentRect() const
 766 {
 767     FloatRect overflowRect(unscaledDocumentRect());
 768     if (hasTransform())
 769         overflowRect = layer()->currentTransform().mapRect(overflowRect);
 770     return IntRect(overflowRect);
 771 }
 772
 773 int 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
 782 int 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
 791 int RenderView::viewLogicalHeight() const
 792 {
 793     return style()->isHorizontalWritingMode() ? viewHeight(ExcludeScrollbars) : viewWidth(ExcludeScrollbars);
 794 }
 795
 796 LayoutUnit RenderView::viewLogicalHeightForPercentages() const
 797 {
 798     if (shouldUsePrintingLayout())
 799         return pageLogicalHeight();
 800     return viewLogicalHeight();
 801 }
 802
 803 float RenderView::zoomFactor() const
 804 {
 805     return m_frameView->frame().pageZoomFactor();
 806 }
 807
 808 void 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
 826 bool RenderView::usesCompositing() const
 827 {
 828     return m_compositor && m_compositor->staleInCompositingMode();
 829 }
 830
 831 RenderLayerCompositor* RenderView::compositor()
 832 {
 833     if (!m_compositor)
 834         m_compositor = adoptPtr(new RenderLayerCompositor(*this));
 835
 836     return m_compositor.get();
 837 }
 838
 839 void RenderView::setIsInWindow(bool isInWindow)
 840 {
 841     if (m_compositor)
 842         m_compositor->setIsInWindow(isInWindow);
 843 }
 844
 845 FlowThreadController* RenderView::flowThreadController()
 846 {
 847     if (!m_flowThreadController)
 848         m_flowThreadController = FlowThreadController::create();
 849
 850     return m_flowThreadController.get();
 851 }
 852
 853 void 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
 863 void 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
 877 IntervalArena* RenderView::intervalArena()
 878 {
 879     if (!m_intervalArena)
 880         m_intervalArena = IntervalArena::create();
 881     return m_intervalArena.get();
 882 }
 883
 884 bool 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
 893 double RenderView::layoutViewportWidth() const
 894 {
 895     float scale = m_frameView ? m_frameView->frame().pageZoomFactor() : 1;
 896     return viewWidth(IncludeScrollbars) / scale;
 897 }
 898
 899 double RenderView::layoutViewportHeight() const
 900 {
 901     float scale = m_frameView ? m_frameView->frame().pageZoomFactor() : 1;
 902     return viewHeight(IncludeScrollbars) / scale;
 903 }
 904
 905 } // namespace blink