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