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/HTMLDialogElement.h"
  28 #include "core/html/HTMLFrameOwnerElement.h"
  29 #include "core/html/HTMLIFrameElement.h"
  30 #include "core/page/Page.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/RenderSelectionInfo.h"
  39 #include "core/rendering/compositing/CompositedLayerMapping.h"
  40 #include "core/rendering/compositing/RenderLayerCompositor.h"
  41 #include "core/svg/SVGDocumentExtensions.h"
  42 #include "platform/RuntimeEnabledFeatures.h"
  43 #include "platform/TraceEvent.h"
  44 #include "platform/geometry/FloatQuad.h"
  45 #include "platform/geometry/TransformState.h"
  46 #include "platform/graphics/GraphicsContext.h"
  47
  48 namespace WebCore {
  49
  50 RenderView::RenderView(Document* document)
  51     : RenderBlockFlow(document)
  52     , m_frameView(document->view())
  53     , m_selectionStart(0)
  54     , m_selectionEnd(0)
  55     , m_selectionStartPos(-1)
  56     , m_selectionEndPos(-1)
  57     , m_pageLogicalHeight(0)
  58     , m_pageLogicalHeightChanged(false)
  59     , m_layoutState(0)
  60     , m_renderQuoteHead(0)
  61     , m_renderCounterCount(0)
  62 {
  63     // init RenderObject attributes
  64     setInline(false);
  65
  66     m_minPreferredLogicalWidth = 0;
  67     m_maxPreferredLogicalWidth = 0;
  68
  69     setPreferredLogicalWidthsDirty(MarkOnlyThis);
  70
  71     setPositionState(AbsolutePosition); // to 0,0 :)
  72 }
  73
  74 RenderView::~RenderView()
  75 {
  76 }
  77
  78 bool RenderView::hitTest(const HitTestRequest& request, HitTestResult& result)
  79 {
  80     return hitTest(request, result.hitTestLocation(), result);
  81 }
  82
  83 bool RenderView::hitTest(const HitTestRequest& request, const HitTestLocation& location, HitTestResult& result)
  84 {
  85     TRACE_EVENT0("blink", "RenderView::hitTest");
  86
  87     // We have to recursively update layout/style here because otherwise, when the hit test recurses
  88     // into a child document, it could trigger a layout on the parent document, which can destroy RenderLayers
  89     // that are higher up in the call stack, leading to crashes.
  90     // Note that Document::updateLayout calls its parent's updateLayout.
  91     // FIXME: It should be the caller's responsibility to ensure an up-to-date layout.
  92     frameView()->updateLayoutAndStyleIfNeededRecursive();
  93     return layer()->hitTest(request, location, result);
  94 }
  95
  96 void RenderView::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit, LogicalExtentComputedValues& computedValues) const
  97 {
  98     computedValues.m_extent = (!shouldUsePrintingLayout() && m_frameView) ? LayoutUnit(viewLogicalHeight()) : logicalHeight;
  99 }
 100
 101 void RenderView::updateLogicalWidth()
 102 {
 103     if (!shouldUsePrintingLayout() && m_frameView)
 104         setLogicalWidth(viewLogicalWidth());
 105 }
 106
 107 LayoutUnit RenderView::availableLogicalHeight(AvailableLogicalHeightType heightType) const
 108 {
 109     // If we have columns, then the available logical height is reduced to the column height.
 110     if (hasColumns())
 111         return columnInfo()->columnHeight();
 112     return RenderBlockFlow::availableLogicalHeight(heightType);
 113 }
 114
 115 bool RenderView::isChildAllowed(RenderObject* child, RenderStyle*) const
 116 {
 117     return child->isBox();
 118 }
 119
 120 static bool canCenterDialog(const RenderStyle* style)
 121 {
 122     // FIXME: We must center for FixedPosition as well.
 123     return style->position() == AbsolutePosition && style->hasAutoTopAndBottom();
 124 }
 125
 126 void RenderView::positionDialog(RenderBox* box)
 127 {
 128     HTMLDialogElement* dialog = toHTMLDialogElement(box->node());
 129     if (dialog->centeringMode() == HTMLDialogElement::NotCentered)
 130         return;
 131     if (dialog->centeringMode() == HTMLDialogElement::Centered) {
 132         if (canCenterDialog(box->style()))
 133             box->setY(dialog->centeredPosition());
 134         return;
 135     }
 136
 137     ASSERT(dialog->centeringMode() == HTMLDialogElement::NeedsCentering);
 138     if (!canCenterDialog(box->style())) {
 139         dialog->setNotCentered();
 140         return;
 141     }
 142     FrameView* frameView = document().view();
 143     int scrollTop = frameView->scrollOffset().height();
 144     int visibleHeight = frameView->visibleContentRect(IncludeScrollbars).height();
 145     LayoutUnit top = scrollTop;
 146     if (box->height() < visibleHeight)
 147         top += (visibleHeight - box->height()) / 2;
 148     box->setY(top);
 149     dialog->setCentered(top);
 150 }
 151
 152 void RenderView::positionDialogs()
 153 {
 154     TrackedRendererListHashSet* positionedDescendants = positionedObjects();
 155     if (!positionedDescendants)
 156         return;
 157     TrackedRendererListHashSet::iterator end = positionedDescendants->end();
 158     for (TrackedRendererListHashSet::iterator it = positionedDescendants->begin(); it != end; ++it) {
 159         RenderBox* box = *it;
 160         if (isHTMLDialogElement(box->node()))
 161             positionDialog(box);
 162     }
 163 }
 164
 165 void RenderView::layoutContent()
 166 {
 167     ASSERT(needsLayout());
 168
 169     RenderBlockFlow::layout();
 170
 171     if (RuntimeEnabledFeatures::dialogElementEnabled())
 172         positionDialogs();
 173
 174 #ifndef NDEBUG
 175     checkLayoutState();
 176 #endif
 177 }
 178
 179 #ifndef NDEBUG
 180 void RenderView::checkLayoutState()
 181 {
 182     if (!RuntimeEnabledFeatures::repaintAfterLayoutEnabled()) {
 183         ASSERT(layoutDeltaMatches(LayoutSize()));
 184     }
 185     ASSERT(!m_layoutState->next());
 186 }
 187 #endif
 188
 189 bool RenderView::shouldDoFullRepaintForNextLayout() const
 190 {
 191     // It's hard to predict here which of full repaint or per-descendant repaint costs less.
 192     // For vertical writing mode or width change it's more likely that per-descendant repaint
 193     // eventually turns out to be full repaint but with the cost to handle more layout states
 194     // and discrete repaint rects, so marking full repaint here is more likely to cost less.
 195     // Otherwise, per-descendant repaint is more likely to avoid unnecessary full repaints.
 196
 197     if (shouldUsePrintingLayout())
 198         return true;
 199
 200     if (!style()->isHorizontalWritingMode() || width() != viewWidth())
 201         return true;
 202
 203     if (height() != viewHeight()) {
 204         // FIXME: Disable optimization to fix crbug.com/390378 for the branch.
 205         return true;
 206 #if 0
 207         if (RenderObject* backgroundRenderer = this->backgroundRenderer()) {
 208             // When background-attachment is 'fixed', we treat the viewport (instead of the 'root'
 209             // i.e. html or body) as the background positioning area, and we should full repaint
 210             // viewport resize if the background image is not composited and needs full repaint on
 211             // background positioning area resize.
 212             if (!m_compositor || !m_compositor->needsFixedRootBackgroundLayer(layer())) {
 213                 if (backgroundRenderer->style()->hasFixedBackgroundImage()
 214                     && mustInvalidateFillLayersPaintOnHeightChange(*backgroundRenderer->style()->backgroundLayers()))
 215                 return true;
 216             }
 217         }
 218 #endif
 219     }
 220
 221     return false;
 222 }
 223
 224 void RenderView::layout()
 225 {
 226     if (!document().paginated())
 227         setPageLogicalHeight(0);
 228
 229     if (shouldUsePrintingLayout())
 230         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = logicalWidth();
 231
 232     SubtreeLayoutScope layoutScope(*this);
 233
 234     // Use calcWidth/Height to get the new width/height, since this will take the full page zoom factor into account.
 235     bool relayoutChildren = !shouldUsePrintingLayout() && (!m_frameView || width() != viewWidth() || height() != viewHeight());
 236     if (relayoutChildren) {
 237         layoutScope.setChildNeedsLayout(this);
 238         for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
 239             if (child->isSVGRoot())
 240                 continue;
 241
 242             if ((child->isBox() && toRenderBox(child)->hasRelativeLogicalHeight())
 243                     || child->style()->logicalHeight().isPercent()
 244                     || child->style()->logicalMinHeight().isPercent()
 245                     || child->style()->logicalMaxHeight().isPercent())
 246                 layoutScope.setChildNeedsLayout(child);
 247         }
 248
 249         if (document().svgExtensions())
 250             document().accessSVGExtensions().invalidateSVGRootsWithRelativeLengthDescendents(&layoutScope);
 251     }
 252
 253     ASSERT(!m_layoutState);
 254     if (!needsLayout())
 255         return;
 256
 257     LayoutState rootLayoutState(pageLogicalHeight(), pageLogicalHeightChanged(), *this);
 258
 259     m_pageLogicalHeightChanged = false;
 260
 261     layoutContent();
 262
 263 #ifndef NDEBUG
 264     checkLayoutState();
 265 #endif
 266     clearNeedsLayout();
 267 }
 268
 269 void RenderView::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
 270 {
 271     ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == static_cast<bool>(mode & IsFixed));
 272
 273     if (!repaintContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) {
 274         TransformationMatrix t;
 275         getTransformFromContainer(0, LayoutSize(), t);
 276         transformState.applyTransform(t);
 277     }
 278
 279     if (mode & IsFixed && m_frameView)
 280         transformState.move(m_frameView->scrollOffsetForFixedPosition());
 281
 282     if (repaintContainer == this)
 283         return;
 284
 285     if (mode & TraverseDocumentBoundaries) {
 286         if (RenderObject* parentDocRenderer = frame()->ownerRenderer()) {
 287             transformState.move(-frame()->view()->scrollOffset());
 288             if (parentDocRenderer->isBox())
 289                 transformState.move(toLayoutSize(toRenderBox(parentDocRenderer)->contentBoxRect().location()));
 290             parentDocRenderer->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
 291             return;
 292         }
 293     }
 294
 295     // If a container was specified, and was not 0 or the RenderView,
 296     // then we should have found it by now.
 297     ASSERT_ARG(repaintContainer, !repaintContainer);
 298 }
 299
 300 const RenderObject* RenderView::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
 301 {
 302     LayoutSize offsetForFixedPosition;
 303     LayoutSize offset;
 304     RenderObject* container = 0;
 305
 306     if (m_frameView)
 307         offsetForFixedPosition = m_frameView->scrollOffsetForFixedPosition();
 308
 309     if (geometryMap.mapCoordinatesFlags() & TraverseDocumentBoundaries) {
 310         if (RenderPart* parentDocRenderer = frame()->ownerRenderer()) {
 311             offset = -m_frameView->scrollOffset();
 312             offset += toLayoutSize(parentDocRenderer->contentBoxRect().location());
 313             container = parentDocRenderer;
 314         }
 315     }
 316
 317     // If a container was specified, and was not 0 or the RenderView, then we
 318     // should have found it by now unless we're traversing to a parent document.
 319     ASSERT_ARG(ancestorToStopAt, !ancestorToStopAt || ancestorToStopAt == this || container);
 320
 321     if ((!ancestorToStopAt || container) && shouldUseTransformFromContainer(container)) {
 322         TransformationMatrix t;
 323         getTransformFromContainer(container, LayoutSize(), t);
 324         geometryMap.push(this, t, false, false, false, true, offsetForFixedPosition);
 325     } else {
 326         geometryMap.push(this, offset, false, false, false, false, offsetForFixedPosition);
 327     }
 328
 329     return container;
 330 }
 331
 332 void RenderView::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, TransformState& transformState) const
 333 {
 334     if (mode & IsFixed && m_frameView)
 335         transformState.move(m_frameView->scrollOffsetForFixedPosition());
 336
 337     if (mode & UseTransforms && shouldUseTransformFromContainer(0)) {
 338         TransformationMatrix t;
 339         getTransformFromContainer(0, LayoutSize(), t);
 340         transformState.applyTransform(t);
 341     }
 342 }
 343
 344 void RenderView::computeSelfHitTestRects(Vector<LayoutRect>& rects, const LayoutPoint&) const
 345 {
 346     // Record the entire size of the contents of the frame. Note that we don't just
 347     // use the viewport size (containing block) here because we want to ensure this includes
 348     // all children (so we can avoid walking them explicitly).
 349     rects.append(LayoutRect(LayoutPoint::zero(), frameView()->contentsSize()));
 350 }
 351
 352 void RenderView::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 353 {
 354     // If we ever require layout but receive a paint anyway, something has gone horribly wrong.
 355     ASSERT(!needsLayout());
 356     // RenderViews should never be called to paint with an offset not on device pixels.
 357     ASSERT(LayoutPoint(IntPoint(paintOffset.x(), paintOffset.y())) == paintOffset);
 358
 359     ANNOTATE_GRAPHICS_CONTEXT(paintInfo, this);
 360
 361     // This avoids painting garbage between columns if there is a column gap.
 362     if (m_frameView && style()->isOverflowPaged())
 363         paintInfo.context->fillRect(paintInfo.rect, m_frameView->baseBackgroundColor());
 364
 365     paintObject(paintInfo, paintOffset);
 366 }
 367
 368 static inline bool rendererObscuresBackground(RenderBox* rootBox)
 369 {
 370     ASSERT(rootBox);
 371     RenderStyle* style = rootBox->style();
 372     if (style->visibility() != VISIBLE
 373         || style->opacity() != 1
 374         || style->hasFilter()
 375         || style->hasTransform())
 376         return false;
 377
 378     if (rootBox->compositingState() == PaintsIntoOwnBacking)
 379         return false;
 380
 381     const RenderObject* rootRenderer = rootBox->rendererForRootBackground();
 382     if (rootRenderer->style()->backgroundClip() == TextFillBox)
 383         return false;
 384
 385     return true;
 386 }
 387
 388 bool RenderView::rootFillsViewportBackground(RenderBox* rootBox) const
 389 {
 390     ASSERT(rootBox);
 391     // CSS Boxes always fill the viewport background (see paintRootBoxFillLayers)
 392     if (!rootBox->isSVG())
 393         return true;
 394
 395     return rootBox->frameRect().contains(frameRect());
 396 }
 397
 398 void RenderView::paintBoxDecorations(PaintInfo& paintInfo, const LayoutPoint&)
 399 {
 400     // Check to see if we are enclosed by a layer that requires complex painting rules.  If so, we cannot blit
 401     // when scrolling, and we need to use slow repaints.  Examples of layers that require this are transparent layers,
 402     // layers with reflections, or transformed layers.
 403     // FIXME: This needs to be dynamic.  We should be able to go back to blitting if we ever stop being inside
 404     // a transform, transparency layer, etc.
 405     Element* elt;
 406     for (elt = document().ownerElement(); view() && elt && elt->renderer(); elt = elt->document().ownerElement()) {
 407         RenderLayer* layer = elt->renderer()->enclosingLayer();
 408         if (layer->cannotBlitToWindow()) {
 409             frameView()->setCannotBlitToWindow();
 410             break;
 411         }
 412
 413         if (layer->enclosingCompositingLayerForRepaint()) {
 414             frameView()->setCannotBlitToWindow();
 415             break;
 416         }
 417     }
 418
 419     if (document().ownerElement() || !view())
 420         return;
 421
 422     if (paintInfo.skipRootBackground())
 423         return;
 424
 425     bool shouldPaintBackground = true;
 426     Node* documentElement = document().documentElement();
 427     if (RenderBox* rootBox = documentElement ? toRenderBox(documentElement->renderer()) : 0)
 428         shouldPaintBackground = !rootFillsViewportBackground(rootBox) || !rendererObscuresBackground(rootBox);
 429
 430     // If painting will entirely fill the view, no need to fill the background.
 431     if (!shouldPaintBackground)
 432         return;
 433
 434     // This code typically only executes if the root element's visibility has been set to hidden,
 435     // if there is a transform on the <html>, or if there is a page scale factor less than 1.
 436     // Only fill with the base background color (typically white) if we're the root document,
 437     // since iframes/frames with no background in the child document should show the parent's background.
 438     if (frameView()->isTransparent()) // FIXME: This needs to be dynamic.  We should be able to go back to blitting if we ever stop being transparent.
 439         frameView()->setCannotBlitToWindow(); // The parent must show behind the child.
 440     else {
 441         Color baseColor = frameView()->baseBackgroundColor();
 442         if (baseColor.alpha()) {
 443             CompositeOperator previousOperator = paintInfo.context->compositeOperation();
 444             paintInfo.context->setCompositeOperation(CompositeCopy);
 445             paintInfo.context->fillRect(paintInfo.rect, baseColor);
 446             paintInfo.context->setCompositeOperation(previousOperator);
 447         } else {
 448             paintInfo.context->clearRect(paintInfo.rect);
 449         }
 450     }
 451 }
 452
 453 void RenderView::invalidateTreeAfterLayout(const RenderLayerModelObject& paintInvalidationContainer)
 454 {
 455     ASSERT(RuntimeEnabledFeatures::repaintAfterLayoutEnabled());
 456     ASSERT(!needsLayout());
 457
 458     // We specifically need to repaint the viewRect since other renderers
 459     // short-circuit on full-repaint.
 460     if (doingFullRepaint() && !viewRect().isEmpty())
 461         repaintViewRectangle(viewRect());
 462
 463     LayoutState rootLayoutState(0, false, *this);
 464     RenderBlock::invalidateTreeAfterLayout(paintInvalidationContainer);
 465 }
 466
 467 void RenderView::repaintViewRectangle(const LayoutRect& repaintRect) const
 468 {
 469     ASSERT(!repaintRect.isEmpty());
 470
 471     if (document().printing() || !m_frameView)
 472         return;
 473
 474     // We always just invalidate the root view, since we could be an iframe that is clipped out
 475     // or even invisible.
 476     Element* owner = document().ownerElement();
 477     if (layer()->compositingState() == PaintsIntoOwnBacking) {
 478         layer()->repainter().setBackingNeedsRepaintInRect(repaintRect);
 479     } else if (!owner) {
 480         m_frameView->contentRectangleForPaintInvalidation(pixelSnappedIntRect(repaintRect));
 481     } else if (RenderBox* obj = owner->renderBox()) {
 482         LayoutRect viewRectangle = viewRect();
 483         LayoutRect rectToRepaint = intersection(repaintRect, viewRectangle);
 484
 485         // Subtract out the contentsX and contentsY offsets to get our coords within the viewing
 486         // rectangle.
 487         rectToRepaint.moveBy(-viewRectangle.location());
 488
 489         // FIXME: Hardcoded offsets here are not good.
 490         rectToRepaint.moveBy(obj->contentBoxRect().location());
 491         obj->invalidatePaintRectangle(rectToRepaint);
 492     }
 493 }
 494
 495 void RenderView::repaintViewAndCompositedLayers()
 496 {
 497     paintInvalidationForWholeRenderer();
 498
 499     // The only way we know how to hit these ASSERTS below this point is via the Chromium OS login screen.
 500     DisableCompositingQueryAsserts disabler;
 501
 502     if (compositor()->inCompositingMode())
 503         compositor()->repaintCompositedLayers();
 504 }
 505
 506 void RenderView::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, bool fixed) const
 507 {
 508     // If a container was specified, and was not 0 or the RenderView,
 509     // then we should have found it by now.
 510     ASSERT_ARG(paintInvalidationContainer, !paintInvalidationContainer || paintInvalidationContainer == this);
 511
 512     if (document().printing())
 513         return;
 514
 515     if (style()->isFlippedBlocksWritingMode()) {
 516         // We have to flip by hand since the view's logical height has not been determined.  We
 517         // can use the viewport width and height.
 518         if (style()->isHorizontalWritingMode())
 519             rect.setY(viewHeight() - rect.maxY());
 520         else
 521             rect.setX(viewWidth() - rect.maxX());
 522     }
 523
 524     if (fixed && m_frameView) {
 525         rect.move(m_frameView->scrollOffsetForFixedPosition());
 526         // If we have a pending scroll, invalidate the previous scroll position.
 527         if (!m_frameView->pendingScrollDelta().isZero()) {
 528             rect.move(-m_frameView->pendingScrollDelta());
 529         }
 530     }
 531
 532     // Apply our transform if we have one (because of full page zooming).
 533     if (!paintInvalidationContainer && layer() && layer()->transform())
 534         rect = layer()->transform()->mapRect(rect);
 535 }
 536
 537 void RenderView::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 538 {
 539     rects.append(pixelSnappedIntRect(accumulatedOffset, layer()->size()));
 540 }
 541
 542 void RenderView::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
 543 {
 544     if (wasFixed)
 545         *wasFixed = false;
 546     quads.append(FloatRect(FloatPoint(), layer()->size()));
 547 }
 548
 549 static RenderObject* rendererAfterPosition(RenderObject* object, unsigned offset)
 550 {
 551     if (!object)
 552         return 0;
 553
 554     RenderObject* child = object->childAt(offset);
 555     return child ? child : object->nextInPreOrderAfterChildren();
 556 }
 557
 558 IntRect RenderView::selectionBounds(bool clipToVisibleContent) const
 559 {
 560     typedef HashMap<RenderObject*, OwnPtr<RenderSelectionInfo> > SelectionMap;
 561     SelectionMap selectedObjects;
 562
 563     RenderObject* os = m_selectionStart;
 564     RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
 565     while (os && os != stop) {
 566         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
 567             // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
 568             selectedObjects.set(os, adoptPtr(new RenderSelectionInfo(os, clipToVisibleContent)));
 569             RenderBlock* cb = os->containingBlock();
 570             while (cb && !cb->isRenderView()) {
 571                 OwnPtr<RenderSelectionInfo>& blockInfo = selectedObjects.add(cb, nullptr).storedValue->value;
 572                 if (blockInfo)
 573                     break;
 574                 blockInfo = adoptPtr(new RenderSelectionInfo(cb, clipToVisibleContent));
 575                 cb = cb->containingBlock();
 576             }
 577         }
 578
 579         os = os->nextInPreOrder();
 580     }
 581
 582     // Now create a single bounding box rect that encloses the whole selection.
 583     LayoutRect selRect;
 584     SelectionMap::iterator end = selectedObjects.end();
 585     for (SelectionMap::iterator i = selectedObjects.begin(); i != end; ++i) {
 586         RenderSelectionInfo* info = i->value.get();
 587         // RenderSelectionInfo::rect() is in the coordinates of the repaintContainer, so map to page coordinates.
 588         LayoutRect currRect = info->rect();
 589         if (const RenderLayerModelObject* repaintContainer = info->repaintContainer()) {
 590             FloatQuad absQuad = repaintContainer->localToAbsoluteQuad(FloatRect(currRect));
 591             currRect = absQuad.enclosingBoundingBox();
 592         }
 593         selRect.unite(currRect);
 594     }
 595     return pixelSnappedIntRect(selRect);
 596 }
 597
 598 void RenderView::repaintSelection() const
 599 {
 600     HashSet<RenderBlock*> processedBlocks;
 601
 602     RenderObject* end = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
 603     for (RenderObject* o = m_selectionStart; o && o != end; o = o->nextInPreOrder()) {
 604         if (!o->canBeSelectionLeaf() && o != m_selectionStart && o != m_selectionEnd)
 605             continue;
 606         if (o->selectionState() == SelectionNone)
 607             continue;
 608
 609         RenderSelectionInfo(o, true).repaint();
 610
 611         // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
 612         for (RenderBlock* block = o->containingBlock(); block && !block->isRenderView(); block = block->containingBlock()) {
 613             if (!processedBlocks.add(block).isNewEntry)
 614                 break;
 615             RenderSelectionInfo(block, true).repaint();
 616         }
 617     }
 618 }
 619
 620 // When exploring the RenderTree looking for the nodes involved in the Selection, sometimes it's
 621 // required to change the traversing direction because the "start" position is below the "end" one.
 622 static inline RenderObject* getNextOrPrevRenderObjectBasedOnDirection(const RenderObject* o, const RenderObject* stop, bool& continueExploring, bool& exploringBackwards)
 623 {
 624     RenderObject* next;
 625     if (exploringBackwards) {
 626         next = o->previousInPreOrder();
 627         continueExploring = next && !(next)->isRenderView();
 628     } else {
 629         next = o->nextInPreOrder();
 630         continueExploring = next && next != stop;
 631         exploringBackwards = !next && (next != stop);
 632         if (exploringBackwards) {
 633             next = stop->previousInPreOrder();
 634             continueExploring = next && !next->isRenderView();
 635         }
 636     }
 637
 638     return next;
 639 }
 640
 641 void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* end, int endPos, SelectionRepaintMode blockRepaintMode)
 642 {
 643     // This code makes no assumptions as to if the rendering tree is up to date or not
 644     // and will not try to update it. Currently clearSelection calls this
 645     // (intentionally) without updating the rendering tree as it doesn't care.
 646     // Other callers may want to force recalc style before calling this.
 647
 648     // Make sure both our start and end objects are defined.
 649     // Check www.msnbc.com and try clicking around to find the case where this happened.
 650     if ((start && !end) || (end && !start))
 651         return;
 652
 653     // Just return if the selection hasn't changed.
 654     if (m_selectionStart == start && m_selectionStartPos == startPos &&
 655         m_selectionEnd == end && m_selectionEndPos == endPos)
 656         return;
 657
 658     // Record the old selected objects.  These will be used later
 659     // when we compare against the new selected objects.
 660     int oldStartPos = m_selectionStartPos;
 661     int oldEndPos = m_selectionEndPos;
 662
 663     // Objects each have a single selection rect to examine.
 664     typedef HashMap<RenderObject*, OwnPtr<RenderSelectionInfo> > SelectedObjectMap;
 665     SelectedObjectMap oldSelectedObjects;
 666     SelectedObjectMap newSelectedObjects;
 667
 668     // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
 669     // In order to get the repaint rect right, we have to examine left, middle, and right rects individually, since otherwise
 670     // the union of those rects might remain the same even when changes have occurred.
 671     typedef HashMap<RenderBlock*, OwnPtr<RenderBlockSelectionInfo> > SelectedBlockMap;
 672     SelectedBlockMap oldSelectedBlocks;
 673     SelectedBlockMap newSelectedBlocks;
 674
 675     RenderObject* os = m_selectionStart;
 676     RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
 677     bool exploringBackwards = false;
 678     bool continueExploring = os && (os != stop);
 679     while (continueExploring) {
 680         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
 681             // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
 682             oldSelectedObjects.set(os, adoptPtr(new RenderSelectionInfo(os, true)));
 683             if (blockRepaintMode == RepaintNewXOROld) {
 684                 RenderBlock* cb = os->containingBlock();
 685                 while (cb && !cb->isRenderView()) {
 686                     OwnPtr<RenderBlockSelectionInfo>& blockInfo = oldSelectedBlocks.add(cb, nullptr).storedValue->value;
 687                     if (blockInfo)
 688                         break;
 689                     blockInfo = adoptPtr(new RenderBlockSelectionInfo(cb));
 690                     cb = cb->containingBlock();
 691                 }
 692             }
 693         }
 694
 695         os = getNextOrPrevRenderObjectBasedOnDirection(os, stop, continueExploring, exploringBackwards);
 696     }
 697
 698     // Now clear the selection.
 699     SelectedObjectMap::iterator oldObjectsEnd = oldSelectedObjects.end();
 700     for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i)
 701         i->key->setSelectionStateIfNeeded(SelectionNone);
 702
 703     // set selection start and end
 704     m_selectionStart = start;
 705     m_selectionStartPos = startPos;
 706     m_selectionEnd = end;
 707     m_selectionEndPos = endPos;
 708
 709     // Update the selection status of all objects between m_selectionStart and m_selectionEnd
 710     if (start && start == end)
 711         start->setSelectionStateIfNeeded(SelectionBoth);
 712     else {
 713         if (start)
 714             start->setSelectionStateIfNeeded(SelectionStart);
 715         if (end)
 716             end->setSelectionStateIfNeeded(SelectionEnd);
 717     }
 718
 719     RenderObject* o = start;
 720     stop = rendererAfterPosition(end, endPos);
 721
 722     while (o && o != stop) {
 723         if (o != start && o != end && o->canBeSelectionLeaf())
 724             o->setSelectionStateIfNeeded(SelectionInside);
 725         o = o->nextInPreOrder();
 726     }
 727
 728     if (blockRepaintMode != RepaintNothing)
 729         layer()->clearBlockSelectionGapsBounds();
 730
 731     // Now that the selection state has been updated for the new objects, walk them again and
 732     // put them in the new objects list.
 733     o = start;
 734     exploringBackwards = false;
 735     continueExploring = o && (o != stop);
 736     while (continueExploring) {
 737         if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
 738             newSelectedObjects.set(o, adoptPtr(new RenderSelectionInfo(o, true)));
 739             RenderBlock* cb = o->containingBlock();
 740             while (cb && !cb->isRenderView()) {
 741                 OwnPtr<RenderBlockSelectionInfo>& blockInfo = newSelectedBlocks.add(cb, nullptr).storedValue->value;
 742                 if (blockInfo)
 743                     break;
 744                 blockInfo = adoptPtr(new RenderBlockSelectionInfo(cb));
 745                 cb = cb->containingBlock();
 746             }
 747         }
 748
 749         o = getNextOrPrevRenderObjectBasedOnDirection(o, stop, continueExploring, exploringBackwards);
 750     }
 751
 752     if (!m_frameView || blockRepaintMode == RepaintNothing)
 753         return;
 754
 755     // Have any of the old selected objects changed compared to the new selection?
 756     for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i) {
 757         RenderObject* obj = i->key;
 758         RenderSelectionInfo* newInfo = newSelectedObjects.get(obj);
 759         RenderSelectionInfo* oldInfo = i->value.get();
 760         if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||
 761             (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
 762             (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
 763             oldInfo->repaint();
 764             if (newInfo) {
 765                 newInfo->repaint();
 766                 newSelectedObjects.remove(obj);
 767             }
 768         }
 769     }
 770
 771     // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
 772     SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
 773     for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i)
 774         i->value->repaint();
 775
 776     // Have any of the old blocks changed?
 777     SelectedBlockMap::iterator oldBlocksEnd = oldSelectedBlocks.end();
 778     for (SelectedBlockMap::iterator i = oldSelectedBlocks.begin(); i != oldBlocksEnd; ++i) {
 779         RenderBlock* block = i->key;
 780         RenderBlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
 781         RenderBlockSelectionInfo* oldInfo = i->value.get();
 782         if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {
 783             oldInfo->repaint();
 784             if (newInfo) {
 785                 newInfo->repaint();
 786                 newSelectedBlocks.remove(block);
 787             }
 788         }
 789     }
 790
 791     // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
 792     SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
 793     for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i)
 794         i->value->repaint();
 795 }
 796
 797 void RenderView::getSelection(RenderObject*& startRenderer, int& startOffset, RenderObject*& endRenderer, int& endOffset) const
 798 {
 799     startRenderer = m_selectionStart;
 800     startOffset = m_selectionStartPos;
 801     endRenderer = m_selectionEnd;
 802     endOffset = m_selectionEndPos;
 803 }
 804
 805 void RenderView::clearSelection()
 806 {
 807     layer()->repaintBlockSelectionGaps();
 808     setSelection(0, -1, 0, -1, RepaintNewMinusOld);
 809 }
 810
 811 void RenderView::selectionStartEnd(int& startPos, int& endPos) const
 812 {
 813     startPos = m_selectionStartPos;
 814     endPos = m_selectionEndPos;
 815 }
 816
 817 bool RenderView::shouldUsePrintingLayout() const
 818 {
 819     if (!document().printing() || !m_frameView)
 820         return false;
 821     return m_frameView->frame().shouldUsePrintingLayout();
 822 }
 823
 824 LayoutRect RenderView::viewRect() const
 825 {
 826     if (shouldUsePrintingLayout())
 827         return LayoutRect(LayoutPoint(), size());
 828     if (m_frameView)
 829         return m_frameView->visibleContentRect();
 830     return LayoutRect();
 831 }
 832
 833 IntRect RenderView::unscaledDocumentRect() const
 834 {
 835     LayoutRect overflowRect(layoutOverflowRect());
 836     flipForWritingMode(overflowRect);
 837     return pixelSnappedIntRect(overflowRect);
 838 }
 839
 840 bool RenderView::rootBackgroundIsEntirelyFixed() const
 841 {
 842     if (RenderObject* backgroundRenderer = this->backgroundRenderer())
 843         return backgroundRenderer->hasEntirelyFixedBackground();
 844     return false;
 845 }
 846
 847 RenderObject* RenderView::backgroundRenderer() const
 848 {
 849     if (Element* documentElement = document().documentElement()) {
 850         if (RenderObject* rootObject = documentElement->renderer())
 851             return rootObject->rendererForRootBackground();
 852     }
 853     return 0;
 854 }
 855
 856 LayoutRect RenderView::backgroundRect(RenderBox* backgroundRenderer) const
 857 {
 858     if (!hasColumns())
 859         return unscaledDocumentRect();
 860
 861     ColumnInfo* columnInfo = this->columnInfo();
 862     LayoutRect backgroundRect(0, 0, columnInfo->desiredColumnWidth(), columnInfo->columnHeight() * columnInfo->columnCount());
 863     if (!isHorizontalWritingMode())
 864         backgroundRect = backgroundRect.transposedRect();
 865     backgroundRenderer->flipForWritingMode(backgroundRect);
 866
 867     return backgroundRect;
 868 }
 869
 870 IntRect RenderView::documentRect() const
 871 {
 872     FloatRect overflowRect(unscaledDocumentRect());
 873     if (hasTransform())
 874         overflowRect = layer()->currentTransform().mapRect(overflowRect);
 875     return IntRect(overflowRect);
 876 }
 877
 878 int RenderView::viewHeight(IncludeScrollbarsInRect scrollbarInclusion) const
 879 {
 880     int height = 0;
 881     if (!shouldUsePrintingLayout() && m_frameView)
 882         height = m_frameView->layoutSize(scrollbarInclusion).height();
 883
 884     return height;
 885 }
 886
 887 int RenderView::viewWidth(IncludeScrollbarsInRect scrollbarInclusion) const
 888 {
 889     int width = 0;
 890     if (!shouldUsePrintingLayout() && m_frameView)
 891         width = m_frameView->layoutSize(scrollbarInclusion).width();
 892
 893     return width;
 894 }
 895
 896 int RenderView::viewLogicalHeight() const
 897 {
 898     return style()->isHorizontalWritingMode() ? viewHeight(ExcludeScrollbars) : viewWidth(ExcludeScrollbars);
 899 }
 900
 901 LayoutUnit RenderView::viewLogicalHeightForPercentages() const
 902 {
 903     if (shouldUsePrintingLayout())
 904         return pageLogicalHeight();
 905     return viewLogicalHeight();
 906 }
 907
 908 float RenderView::zoomFactor() const
 909 {
 910     return m_frameView->frame().pageZoomFactor();
 911 }
 912
 913 void RenderView::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
 914 {
 915     if (result.innerNode())
 916         return;
 917
 918     Node* node = document().documentElement();
 919     if (node) {
 920         result.setInnerNode(node);
 921         if (!result.innerNonSharedNode())
 922             result.setInnerNonSharedNode(node);
 923
 924         LayoutPoint adjustedPoint = point;
 925         offsetForContents(adjustedPoint);
 926
 927         result.setLocalPoint(adjustedPoint);
 928     }
 929 }
 930
 931 bool RenderView::usesCompositing() const
 932 {
 933     return m_compositor && m_compositor->staleInCompositingMode();
 934 }
 935
 936 RenderLayerCompositor* RenderView::compositor()
 937 {
 938     if (!m_compositor)
 939         m_compositor = adoptPtr(new RenderLayerCompositor(*this));
 940
 941     return m_compositor.get();
 942 }
 943
 944 void RenderView::setIsInWindow(bool isInWindow)
 945 {
 946     if (m_compositor)
 947         m_compositor->setIsInWindow(isInWindow);
 948 }
 949
 950 FlowThreadController* RenderView::flowThreadController()
 951 {
 952     if (!m_flowThreadController)
 953         m_flowThreadController = FlowThreadController::create();
 954
 955     return m_flowThreadController.get();
 956 }
 957
 958 void RenderView::pushLayoutState(LayoutState& layoutState)
 959 {
 960     if (m_flowThreadController) {
 961         RenderFlowThread* currentFlowThread = m_flowThreadController->currentRenderFlowThread();
 962         if (currentFlowThread)
 963             currentFlowThread->pushFlowThreadLayoutState(layoutState.renderer());
 964     }
 965     m_layoutState = &layoutState;
 966 }
 967
 968 void RenderView::popLayoutState()
 969 {
 970     ASSERT(m_layoutState);
 971     m_layoutState = m_layoutState->next();
 972     if (!m_flowThreadController)
 973         return;
 974
 975     RenderFlowThread* currentFlowThread = m_flowThreadController->currentRenderFlowThread();
 976     if (!currentFlowThread)
 977         return;
 978
 979     currentFlowThread->popFlowThreadLayoutState();
 980 }
 981
 982 IntervalArena* RenderView::intervalArena()
 983 {
 984     if (!m_intervalArena)
 985         m_intervalArena = IntervalArena::create();
 986     return m_intervalArena.get();
 987 }
 988
 989 bool RenderView::backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const
 990 {
 991     // FIXME: Remove this main frame check. Same concept applies to subframes too.
 992     if (!frame()->isMainFrame())
 993         return false;
 994
 995     return m_frameView->hasOpaqueBackground();
 996 }
 997
 998 double RenderView::layoutViewportWidth() const
 999 {
1000     float scale = m_frameView ? m_frameView->frame().pageZoomFactor() : 1;
1001     return viewWidth(IncludeScrollbars) / scale;
1002 }
1003
1004 double RenderView::layoutViewportHeight() const
1005 {
1006     float scale = m_frameView ? m_frameView->frame().pageZoomFactor() : 1;
1007     return viewHeight(IncludeScrollbars) / scale;
1008 }
1009
1010 } // namespace WebCore