| /* |
| * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org> |
| * 1999 Lars Knoll <knoll@kde.org> |
| * 1999 Antti Koivisto <koivisto@kde.org> |
| * 2000 Dirk Mueller <mueller@kde.org> |
| * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved. |
| * (C) 2006 Graham Dennis (graham.dennis@gmail.com) |
| * (C) 2006 Alexey Proskuryakov (ap@nypop.com) |
| * Copyright (C) 2009 Google Inc. All rights reserved. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public License |
| * along with this library; see the file COPYING.LIB. If not, write to |
| * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #include "config.h" |
| #include "core/frame/FrameView.h" |
| |
| #include "core/HTMLNames.h" |
| #include "core/accessibility/AXObjectCache.h" |
| #include "core/css/FontFaceSet.h" |
| #include "core/css/resolver/StyleResolver.h" |
| #include "core/dom/DocumentMarkerController.h" |
| #include "core/dom/ScriptForbiddenScope.h" |
| #include "core/editing/FrameSelection.h" |
| #include "core/events/OverflowEvent.h" |
| #include "core/fetch/ResourceFetcher.h" |
| #include "core/fetch/ResourceLoadPriorityOptimizer.h" |
| #include "core/frame/FrameHost.h" |
| #include "core/frame/LocalFrame.h" |
| #include "core/frame/Settings.h" |
| #include "core/html/HTMLFrameElement.h" |
| #include "core/html/HTMLPlugInElement.h" |
| #include "core/html/parser/TextResourceDecoder.h" |
| #include "core/inspector/InspectorInstrumentation.h" |
| #include "core/inspector/InspectorTraceEvents.h" |
| #include "core/loader/FrameLoader.h" |
| #include "core/loader/FrameLoaderClient.h" |
| #include "core/page/Chrome.h" |
| #include "core/page/ChromeClient.h" |
| #include "core/page/EventHandler.h" |
| #include "core/page/FocusController.h" |
| #include "core/page/FrameTree.h" |
| #include "core/page/scrolling/ScrollingCoordinator.h" |
| #include "core/rendering/FastTextAutosizer.h" |
| #include "core/rendering/RenderCounter.h" |
| #include "core/rendering/RenderEmbeddedObject.h" |
| #include "core/rendering/RenderLayer.h" |
| #include "core/rendering/RenderListBox.h" |
| #include "core/rendering/RenderPart.h" |
| #include "core/rendering/RenderScrollbar.h" |
| #include "core/rendering/RenderScrollbarPart.h" |
| #include "core/rendering/RenderTheme.h" |
| #include "core/rendering/RenderView.h" |
| #include "core/rendering/RenderWidget.h" |
| #include "core/rendering/TextAutosizer.h" |
| #include "core/rendering/compositing/CompositedLayerMapping.h" |
| #include "core/rendering/compositing/RenderLayerCompositor.h" |
| #include "core/rendering/style/RenderStyle.h" |
| #include "core/rendering/svg/RenderSVGRoot.h" |
| #include "core/svg/SVGDocumentExtensions.h" |
| #include "core/svg/SVGSVGElement.h" |
| #include "platform/RuntimeEnabledFeatures.h" |
| #include "platform/TraceEvent.h" |
| #include "platform/fonts/FontCache.h" |
| #include "platform/geometry/FloatRect.h" |
| #include "platform/graphics/GraphicsContext.h" |
| #include "platform/graphics/GraphicsLayerDebugInfo.h" |
| #include "platform/scroll/ScrollAnimator.h" |
| #include "platform/scroll/ScrollbarTheme.h" |
| #include "platform/text/TextStream.h" |
| #include "wtf/CurrentTime.h" |
| #include "wtf/TemporaryChange.h" |
| |
| namespace WebCore { |
| |
| using namespace HTMLNames; |
| |
| double FrameView::s_currentFrameTimeStamp = 0.0; |
| bool FrameView::s_inPaintContents = false; |
| |
| // The maximum number of updateWidgets iterations that should be done before returning. |
| static const unsigned maxUpdateWidgetsIterations = 2; |
| static const double resourcePriorityUpdateDelayAfterScroll = 0.250; |
| |
| static RenderLayer::UpdateLayerPositionsFlags updateLayerPositionFlags(RenderLayer* layer, bool isRelayoutingSubtree, bool didFullPaintInvalidation) |
| { |
| RenderLayer::UpdateLayerPositionsFlags flags = didFullPaintInvalidation ? RenderLayer::NeedsFullRepaintInBacking : RenderLayer::CheckForRepaint; |
| |
| if (isRelayoutingSubtree && (layer->isPaginated() || layer->enclosingPaginationLayer())) |
| flags |= RenderLayer::UpdatePagination; |
| |
| return flags; |
| } |
| |
| FrameView::FrameView(LocalFrame* frame) |
| : m_frame(frame) |
| , m_canHaveScrollbars(true) |
| , m_slowRepaintObjectCount(0) |
| , m_hasPendingLayout(false) |
| , m_layoutSubtreeRoot(0) |
| , m_inSynchronousPostLayout(false) |
| , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired) |
| , m_updateWidgetsTimer(this, &FrameView::updateWidgetsTimerFired) |
| , m_isTransparent(false) |
| , m_baseBackgroundColor(Color::white) |
| , m_mediaType("screen") |
| , m_overflowStatusDirty(true) |
| , m_viewportRenderer(0) |
| , m_wasScrolledByUser(false) |
| , m_inProgrammaticScroll(false) |
| , m_safeToPropagateScrollToParent(true) |
| , m_isTrackingPaintInvalidations(false) |
| , m_scrollCorner(0) |
| , m_shouldAutoSize(false) |
| , m_inAutoSize(false) |
| , m_didRunAutosize(false) |
| , m_hasSoftwareFilters(false) |
| , m_visibleContentScaleFactor(1) |
| , m_inputEventsScaleFactorForEmulation(1) |
| , m_layoutSizeFixedToFrameSize(true) |
| , m_didScrollTimer(this, &FrameView::didScrollTimerFired) |
| { |
| ASSERT(m_frame); |
| init(); |
| |
| if (!m_frame->isMainFrame()) |
| return; |
| |
| ScrollableArea::setVerticalScrollElasticity(ScrollElasticityAllowed); |
| ScrollableArea::setHorizontalScrollElasticity(ScrollElasticityAllowed); |
| } |
| |
| PassRefPtr<FrameView> FrameView::create(LocalFrame* frame) |
| { |
| RefPtr<FrameView> view = adoptRef(new FrameView(frame)); |
| view->show(); |
| return view.release(); |
| } |
| |
| PassRefPtr<FrameView> FrameView::create(LocalFrame* frame, const IntSize& initialSize) |
| { |
| RefPtr<FrameView> view = adoptRef(new FrameView(frame)); |
| view->Widget::setFrameRect(IntRect(view->location(), initialSize)); |
| view->setLayoutSizeInternal(initialSize); |
| |
| view->show(); |
| return view.release(); |
| } |
| |
| FrameView::~FrameView() |
| { |
| if (m_postLayoutTasksTimer.isActive()) |
| m_postLayoutTasksTimer.stop(); |
| |
| if (m_didScrollTimer.isActive()) |
| m_didScrollTimer.stop(); |
| |
| removeFromAXObjectCache(); |
| resetScrollbars(); |
| |
| // Custom scrollbars should already be destroyed at this point |
| ASSERT(!horizontalScrollbar() || !horizontalScrollbar()->isCustomScrollbar()); |
| ASSERT(!verticalScrollbar() || !verticalScrollbar()->isCustomScrollbar()); |
| |
| setHasHorizontalScrollbar(false); // Remove native scrollbars now before we lose the connection to the HostWindow. |
| setHasVerticalScrollbar(false); |
| |
| ASSERT(!m_scrollCorner); |
| |
| ASSERT(m_frame); |
| ASSERT(m_frame->view() != this || !m_frame->contentRenderer()); |
| // FIXME: Do we need to do something here for OOPI? |
| HTMLFrameOwnerElement* ownerElement = m_frame->deprecatedLocalOwner(); |
| if (ownerElement && ownerElement->ownedWidget() == this) |
| ownerElement->setWidget(nullptr); |
| } |
| |
| void FrameView::reset() |
| { |
| m_cannotBlitToWindow = false; |
| m_isOverlapped = false; |
| m_contentIsOpaque = false; |
| m_hasPendingLayout = false; |
| m_layoutSubtreeRoot = 0; |
| m_doFullPaintInvalidation = false; |
| m_layoutSchedulingEnabled = true; |
| m_inPerformLayout = false; |
| m_canInvalidatePaintDuringPerformLayout = false; |
| m_inSynchronousPostLayout = false; |
| m_layoutCount = 0; |
| m_nestedLayoutCount = 0; |
| m_postLayoutTasksTimer.stop(); |
| m_updateWidgetsTimer.stop(); |
| m_firstLayout = true; |
| m_firstLayoutCallbackPending = false; |
| m_wasScrolledByUser = false; |
| m_safeToPropagateScrollToParent = true; |
| m_lastViewportSize = IntSize(); |
| m_lastZoomFactor = 1.0f; |
| m_isTrackingPaintInvalidations = false; |
| m_trackedPaintInvalidationRects.clear(); |
| m_lastPaintTime = 0; |
| m_paintBehavior = PaintBehaviorNormal; |
| m_isPainting = false; |
| m_visuallyNonEmptyCharacterCount = 0; |
| m_visuallyNonEmptyPixelCount = 0; |
| m_isVisuallyNonEmpty = false; |
| m_firstVisuallyNonEmptyLayoutCallbackPending = true; |
| m_maintainScrollPositionAnchor = nullptr; |
| m_viewportConstrainedObjects.clear(); |
| } |
| |
| void FrameView::removeFromAXObjectCache() |
| { |
| if (AXObjectCache* cache = axObjectCache()) |
| cache->remove(this); |
| } |
| |
| void FrameView::resetScrollbars() |
| { |
| // Reset the document's scrollbars back to our defaults before we yield the floor. |
| m_firstLayout = true; |
| setScrollbarsSuppressed(true); |
| if (m_canHaveScrollbars) |
| setScrollbarModes(ScrollbarAuto, ScrollbarAuto); |
| else |
| setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff); |
| setScrollbarsSuppressed(false); |
| } |
| |
| void FrameView::init() |
| { |
| reset(); |
| |
| m_size = LayoutSize(); |
| |
| // Propagate the marginwidth/height and scrolling modes to the view. |
| // FIXME: Do we need to do this for OOPI? |
| Element* ownerElement = m_frame->deprecatedLocalOwner(); |
| if (ownerElement && (isHTMLFrameElement(*ownerElement) || isHTMLIFrameElement(*ownerElement))) { |
| HTMLFrameElementBase* frameElt = toHTMLFrameElementBase(ownerElement); |
| if (frameElt->scrollingMode() == ScrollbarAlwaysOff) |
| setCanHaveScrollbars(false); |
| } |
| } |
| |
| void FrameView::prepareForDetach() |
| { |
| RELEASE_ASSERT(!isInPerformLayout()); |
| |
| if (ScrollAnimator* scrollAnimator = existingScrollAnimator()) |
| scrollAnimator->cancelAnimations(); |
| |
| detachCustomScrollbars(); |
| // When the view is no longer associated with a frame, it needs to be removed from the ax object cache |
| // right now, otherwise it won't be able to reach the topDocument()'s axObject cache later. |
| removeFromAXObjectCache(); |
| |
| if (m_frame->page()) { |
| if (ScrollingCoordinator* scrollingCoordinator = m_frame->page()->scrollingCoordinator()) |
| scrollingCoordinator->willDestroyScrollableArea(this); |
| } |
| } |
| |
| void FrameView::detachCustomScrollbars() |
| { |
| Scrollbar* horizontalBar = horizontalScrollbar(); |
| if (horizontalBar && horizontalBar->isCustomScrollbar()) |
| setHasHorizontalScrollbar(false); |
| |
| Scrollbar* verticalBar = verticalScrollbar(); |
| if (verticalBar && verticalBar->isCustomScrollbar()) |
| setHasVerticalScrollbar(false); |
| |
| if (m_scrollCorner) { |
| m_scrollCorner->destroy(); |
| m_scrollCorner = 0; |
| } |
| } |
| |
| void FrameView::recalculateScrollbarOverlayStyle() |
| { |
| ScrollbarOverlayStyle oldOverlayStyle = scrollbarOverlayStyle(); |
| ScrollbarOverlayStyle overlayStyle = ScrollbarOverlayStyleDefault; |
| |
| Color backgroundColor = documentBackgroundColor(); |
| // Reduce the background color from RGB to a lightness value |
| // and determine which scrollbar style to use based on a lightness |
| // heuristic. |
| double hue, saturation, lightness; |
| backgroundColor.getHSL(hue, saturation, lightness); |
| if (lightness <= .5) |
| overlayStyle = ScrollbarOverlayStyleLight; |
| |
| if (oldOverlayStyle != overlayStyle) |
| setScrollbarOverlayStyle(overlayStyle); |
| } |
| |
| void FrameView::clear() |
| { |
| reset(); |
| setScrollbarsSuppressed(true); |
| } |
| |
| bool FrameView::didFirstLayout() const |
| { |
| return !m_firstLayout; |
| } |
| |
| void FrameView::invalidateRect(const IntRect& rect) |
| { |
| if (!parent()) { |
| if (HostWindow* window = hostWindow()) |
| window->invalidateContentsAndRootView(rect); |
| return; |
| } |
| |
| RenderPart* renderer = m_frame->ownerRenderer(); |
| if (!renderer) |
| return; |
| |
| IntRect paintInvalidationRect = rect; |
| paintInvalidationRect.move(renderer->borderLeft() + renderer->paddingLeft(), |
| renderer->borderTop() + renderer->paddingTop()); |
| renderer->invalidatePaintRectangle(paintInvalidationRect); |
| } |
| |
| void FrameView::setFrameRect(const IntRect& newRect) |
| { |
| IntRect oldRect = frameRect(); |
| if (newRect == oldRect) |
| return; |
| |
| // Autosized font sizes depend on the width of the viewing area. |
| bool autosizerNeedsUpdating = false; |
| if (newRect.width() != oldRect.width()) { |
| if (m_frame->isMainFrame() && m_frame->settings()->textAutosizingEnabled()) { |
| autosizerNeedsUpdating = true; |
| for (Frame* frame = m_frame.get(); frame; frame = frame->tree().traverseNext()) { |
| if (!frame->isLocalFrame()) |
| continue; |
| if (TextAutosizer* textAutosizer = toLocalFrame(frame)->document()->textAutosizer()) |
| textAutosizer->recalculateMultipliers(); |
| } |
| } |
| } |
| |
| ScrollView::setFrameRect(newRect); |
| |
| updateScrollableAreaSet(); |
| |
| if (autosizerNeedsUpdating) { |
| // This needs to be after the call to ScrollView::setFrameRect, because it reads the new width. |
| if (FastTextAutosizer* textAutosizer = m_frame->document()->fastTextAutosizer()) |
| textAutosizer->updatePageInfoInAllFrames(); |
| } |
| |
| if (RenderView* renderView = this->renderView()) { |
| if (renderView->usesCompositing()) |
| renderView->compositor()->frameViewDidChangeSize(); |
| } |
| |
| viewportConstrainedVisibleContentSizeChanged(newRect.width() != oldRect.width(), newRect.height() != oldRect.height()); |
| |
| if (oldRect.size() != newRect.size() |
| && m_frame->isMainFrame() |
| && m_frame->settings()->pinchVirtualViewportEnabled()) |
| page()->frameHost().pinchViewport().mainFrameDidChangeSize(); |
| } |
| |
| bool FrameView::scheduleAnimation() |
| { |
| if (HostWindow* window = hostWindow()) { |
| window->scheduleAnimation(); |
| return true; |
| } |
| return false; |
| } |
| |
| Page* FrameView::page() const |
| { |
| return frame().page(); |
| } |
| |
| RenderView* FrameView::renderView() const |
| { |
| return frame().contentRenderer(); |
| } |
| |
| void FrameView::setCanHaveScrollbars(bool canHaveScrollbars) |
| { |
| m_canHaveScrollbars = canHaveScrollbars; |
| ScrollView::setCanHaveScrollbars(canHaveScrollbars); |
| } |
| |
| bool FrameView::shouldUseCustomScrollbars(Element*& customScrollbarElement, LocalFrame*& customScrollbarFrame) |
| { |
| customScrollbarElement = 0; |
| customScrollbarFrame = 0; |
| |
| if (Settings* settings = m_frame->settings()) { |
| if (!settings->allowCustomScrollbarInMainFrame() && m_frame->isMainFrame()) |
| return false; |
| } |
| |
| // FIXME: We need to update the scrollbar dynamically as documents change (or as doc elements and bodies get discovered that have custom styles). |
| Document* doc = m_frame->document(); |
| |
| // Try the <body> element first as a scrollbar source. |
| Element* body = doc ? doc->body() : 0; |
| if (body && body->renderer() && body->renderer()->style()->hasPseudoStyle(SCROLLBAR)) { |
| customScrollbarElement = body; |
| return true; |
| } |
| |
| // If the <body> didn't have a custom style, then the root element might. |
| Element* docElement = doc ? doc->documentElement() : 0; |
| if (docElement && docElement->renderer() && docElement->renderer()->style()->hasPseudoStyle(SCROLLBAR)) { |
| customScrollbarElement = docElement; |
| return true; |
| } |
| |
| // If we have an owning ipage/LocalFrame element, then it can set the custom scrollbar also. |
| RenderPart* frameRenderer = m_frame->ownerRenderer(); |
| if (frameRenderer && frameRenderer->style()->hasPseudoStyle(SCROLLBAR)) { |
| customScrollbarFrame = m_frame.get(); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| PassRefPtr<Scrollbar> FrameView::createScrollbar(ScrollbarOrientation orientation) |
| { |
| Element* customScrollbarElement = 0; |
| LocalFrame* customScrollbarFrame = 0; |
| if (shouldUseCustomScrollbars(customScrollbarElement, customScrollbarFrame)) |
| return RenderScrollbar::createCustomScrollbar(this, orientation, customScrollbarElement, customScrollbarFrame); |
| |
| // Nobody set a custom style, so we just use a native scrollbar. |
| return ScrollView::createScrollbar(orientation); |
| } |
| |
| void FrameView::setContentsSize(const IntSize& size) |
| { |
| if (size == contentsSize()) |
| return; |
| |
| ScrollView::setContentsSize(size); |
| ScrollView::contentsResized(); |
| |
| Page* page = frame().page(); |
| if (!page) |
| return; |
| |
| updateScrollableAreaSet(); |
| |
| page->chrome().contentsSizeChanged(m_frame.get(), size); |
| } |
| |
| IntPoint FrameView::clampOffsetAtScale(const IntPoint& offset, float scale) const |
| { |
| IntPoint maxScrollExtent(contentsSize().width() - scrollOrigin().x(), contentsSize().height() - scrollOrigin().y()); |
| FloatSize scaledSize = unscaledVisibleContentSize(); |
| if (scale) |
| scaledSize.scale(1 / scale); |
| |
| IntPoint clampedOffset = offset; |
| clampedOffset = clampedOffset.shrunkTo(maxScrollExtent - expandedIntSize(scaledSize)); |
| clampedOffset = clampedOffset.expandedTo(-scrollOrigin()); |
| |
| return clampedOffset; |
| } |
| |
| void FrameView::adjustViewSize() |
| { |
| RenderView* renderView = this->renderView(); |
| if (!renderView) |
| return; |
| |
| ASSERT(m_frame->view() == this); |
| |
| const IntRect rect = renderView->documentRect(); |
| const IntSize& size = rect.size(); |
| ScrollView::setScrollOrigin(IntPoint(-rect.x(), -rect.y()), !m_frame->document()->printing(), size == contentsSize()); |
| |
| setContentsSize(size); |
| } |
| |
| void FrameView::applyOverflowToViewportAndSetRenderer(RenderObject* o, ScrollbarMode& hMode, ScrollbarMode& vMode) |
| { |
| // Handle the overflow:hidden/scroll case for the body/html elements. WinIE treats |
| // overflow:hidden and overflow:scroll on <body> as applying to the document's |
| // scrollbars. The CSS2.1 draft states that HTML UAs should use the <html> or <body> element and XML/XHTML UAs should |
| // use the root element. |
| |
| EOverflow overflowX = o->style()->overflowX(); |
| EOverflow overflowY = o->style()->overflowY(); |
| |
| if (o->isSVGRoot()) { |
| // Don't allow overflow to affect <img> and css backgrounds |
| if (toRenderSVGRoot(o)->isEmbeddedThroughSVGImage()) |
| return; |
| |
| // FIXME: evaluate if we can allow overflow for these cases too. |
| // Overflow is always hidden when stand-alone SVG documents are embedded. |
| if (toRenderSVGRoot(o)->isEmbeddedThroughFrameContainingSVGDocument()) { |
| overflowX = OHIDDEN; |
| overflowY = OHIDDEN; |
| } |
| } |
| |
| bool ignoreOverflowHidden = false; |
| if (m_frame->settings()->ignoreMainFrameOverflowHiddenQuirk() && m_frame->isMainFrame()) |
| ignoreOverflowHidden = true; |
| |
| switch (overflowX) { |
| case OHIDDEN: |
| if (!ignoreOverflowHidden) |
| hMode = ScrollbarAlwaysOff; |
| break; |
| case OSCROLL: |
| hMode = ScrollbarAlwaysOn; |
| break; |
| case OAUTO: |
| hMode = ScrollbarAuto; |
| break; |
| default: |
| // Don't set it at all. |
| ; |
| } |
| |
| switch (overflowY) { |
| case OHIDDEN: |
| if (!ignoreOverflowHidden) |
| vMode = ScrollbarAlwaysOff; |
| break; |
| case OSCROLL: |
| vMode = ScrollbarAlwaysOn; |
| break; |
| case OAUTO: |
| vMode = ScrollbarAuto; |
| break; |
| default: |
| // Don't set it at all. |
| ; |
| } |
| |
| m_viewportRenderer = o; |
| } |
| |
| void FrameView::calculateScrollbarModesForLayoutAndSetViewportRenderer(ScrollbarMode& hMode, ScrollbarMode& vMode, ScrollbarModesCalculationStrategy strategy) |
| { |
| m_viewportRenderer = 0; |
| |
| // FIXME: How do we handle this for OOPI? |
| const HTMLFrameOwnerElement* owner = m_frame->deprecatedLocalOwner(); |
| if (owner && (owner->scrollingMode() == ScrollbarAlwaysOff)) { |
| hMode = ScrollbarAlwaysOff; |
| vMode = ScrollbarAlwaysOff; |
| return; |
| } |
| |
| if (m_canHaveScrollbars || strategy == RulesFromWebContentOnly) { |
| hMode = ScrollbarAuto; |
| vMode = ScrollbarAuto; |
| } else { |
| hMode = ScrollbarAlwaysOff; |
| vMode = ScrollbarAlwaysOff; |
| } |
| |
| if (!isSubtreeLayout()) { |
| Document* document = m_frame->document(); |
| Node* body = document->body(); |
| if (isHTMLFrameSetElement(body) && body->renderer()) { |
| vMode = ScrollbarAlwaysOff; |
| hMode = ScrollbarAlwaysOff; |
| } else if (Element* viewportElement = document->viewportDefiningElement()) { |
| if (RenderObject* viewportRenderer = viewportElement->renderer()) { |
| if (viewportRenderer->style()) |
| applyOverflowToViewportAndSetRenderer(viewportRenderer, hMode, vMode); |
| } |
| } |
| } |
| } |
| |
| void FrameView::updateAcceleratedCompositingSettings() |
| { |
| if (RenderView* renderView = this->renderView()) |
| renderView->compositor()->updateAcceleratedCompositingSettings(); |
| } |
| |
| void FrameView::recalcOverflowAfterStyleChange() |
| { |
| RenderView* renderView = this->renderView(); |
| ASSERT(renderView); |
| if (!renderView->needsOverflowRecalcAfterStyleChange()) |
| return; |
| |
| renderView->recalcOverflowAfterStyleChange(); |
| |
| if (needsLayout()) |
| return; |
| |
| InUpdateScrollbarsScope inUpdateScrollbarsScope(this); |
| |
| bool shouldHaveHorizontalScrollbar = false; |
| bool shouldHaveVerticalScrollbar = false; |
| computeScrollbarExistence(shouldHaveHorizontalScrollbar, shouldHaveVerticalScrollbar); |
| |
| bool hasHorizontalScrollbar = horizontalScrollbar(); |
| bool hasVerticalScrollbar = verticalScrollbar(); |
| if (hasHorizontalScrollbar != shouldHaveHorizontalScrollbar |
| || hasVerticalScrollbar != shouldHaveVerticalScrollbar) { |
| setNeedsLayout(); |
| return; |
| } |
| |
| adjustViewSize(); |
| updateScrollbarGeometry(); |
| } |
| |
| bool FrameView::usesCompositedScrolling() const |
| { |
| RenderView* renderView = this->renderView(); |
| if (!renderView) |
| return false; |
| if (m_frame->settings() && m_frame->settings()->compositedScrollingForFramesEnabled()) |
| return renderView->compositor()->inCompositingMode(); |
| return false; |
| } |
| |
| GraphicsLayer* FrameView::layerForScrolling() const |
| { |
| RenderView* renderView = this->renderView(); |
| if (!renderView) |
| return 0; |
| return renderView->compositor()->scrollLayer(); |
| } |
| |
| GraphicsLayer* FrameView::layerForHorizontalScrollbar() const |
| { |
| RenderView* renderView = this->renderView(); |
| if (!renderView) |
| return 0; |
| return renderView->compositor()->layerForHorizontalScrollbar(); |
| } |
| |
| GraphicsLayer* FrameView::layerForVerticalScrollbar() const |
| { |
| RenderView* renderView = this->renderView(); |
| if (!renderView) |
| return 0; |
| return renderView->compositor()->layerForVerticalScrollbar(); |
| } |
| |
| GraphicsLayer* FrameView::layerForScrollCorner() const |
| { |
| RenderView* renderView = this->renderView(); |
| if (!renderView) |
| return 0; |
| return renderView->compositor()->layerForScrollCorner(); |
| } |
| |
| bool FrameView::hasCompositedContent() const |
| { |
| // FIXME: change to inCompositingMode. Fails fast/repaint/iframe-scroll-repaint.html. |
| if (RenderView* renderView = this->renderView()) |
| return renderView->compositor()->staleInCompositingMode(); |
| return false; |
| } |
| |
| bool FrameView::isEnclosedInCompositingLayer() const |
| { |
| // FIXME: It's a bug that compositing state isn't always up to date when this is called. crbug.com/366314 |
| DisableCompositingQueryAsserts disabler; |
| |
| RenderObject* frameOwnerRenderer = m_frame->ownerRenderer(); |
| if (frameOwnerRenderer && frameOwnerRenderer->enclosingLayer()->enclosingCompositingLayerForRepaint()) |
| return true; |
| |
| if (FrameView* parentView = parentFrameView()) |
| return parentView->isEnclosedInCompositingLayer(); |
| |
| return false; |
| } |
| |
| RenderObject* FrameView::layoutRoot(bool onlyDuringLayout) const |
| { |
| return onlyDuringLayout && layoutPending() ? 0 : m_layoutSubtreeRoot; |
| } |
| |
| inline void FrameView::forceLayoutParentViewIfNeeded() |
| { |
| RenderPart* ownerRenderer = m_frame->ownerRenderer(); |
| if (!ownerRenderer || !ownerRenderer->frame()) |
| return; |
| |
| RenderBox* contentBox = embeddedContentBox(); |
| if (!contentBox) |
| return; |
| |
| RenderSVGRoot* svgRoot = toRenderSVGRoot(contentBox); |
| if (svgRoot->everHadLayout() && !svgRoot->needsLayout()) |
| return; |
| |
| // If the embedded SVG document appears the first time, the ownerRenderer has already finished |
| // layout without knowing about the existence of the embedded SVG document, because RenderReplaced |
| // embeddedContentBox() returns 0, as long as the embedded document isn't loaded yet. Before |
| // bothering to lay out the SVG document, mark the ownerRenderer needing layout and ask its |
| // FrameView for a layout. After that the RenderEmbeddedObject (ownerRenderer) carries the |
| // correct size, which RenderSVGRoot::computeReplacedLogicalWidth/Height rely on, when laying |
| // out for the first time, or when the RenderSVGRoot size has changed dynamically (eg. via <script>). |
| RefPtr<FrameView> frameView = ownerRenderer->frame()->view(); |
| |
| // Mark the owner renderer as needing layout. |
| ownerRenderer->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(); |
| |
| // Synchronously enter layout, to layout the view containing the host object/embed/iframe. |
| ASSERT(frameView); |
| frameView->layout(); |
| } |
| |
| void FrameView::performPreLayoutTasks() |
| { |
| TRACE_EVENT0("webkit", "FrameView::performPreLayoutTasks"); |
| lifecycle().advanceTo(DocumentLifecycle::InPreLayout); |
| |
| // Don't schedule more layouts, we're in one. |
| TemporaryChange<bool> changeSchedulingEnabled(m_layoutSchedulingEnabled, false); |
| |
| if (!m_nestedLayoutCount && !m_inSynchronousPostLayout && m_postLayoutTasksTimer.isActive()) { |
| // This is a new top-level layout. If there are any remaining tasks from the previous layout, finish them now. |
| m_inSynchronousPostLayout = true; |
| performPostLayoutTasks(); |
| m_inSynchronousPostLayout = false; |
| } |
| |
| Document* document = m_frame->document(); |
| document->notifyResizeForViewportUnits(); |
| |
| // Viewport-dependent media queries may cause us to need completely different style information. |
| if (!document->styleResolver() || document->styleResolver()->mediaQueryAffectedByViewportChange()) { |
| document->styleResolverChanged(); |
| document->mediaQueryAffectingValueChanged(); |
| |
| // FIXME: This instrumentation event is not strictly accurate since cached media query results |
| // do not persist across StyleResolver rebuilds. |
| InspectorInstrumentation::mediaQueryResultChanged(document); |
| } else { |
| document->evaluateMediaQueryList(); |
| } |
| |
| document->updateRenderTreeIfNeeded(); |
| lifecycle().advanceTo(DocumentLifecycle::StyleClean); |
| } |
| |
| void FrameView::performLayout(RenderObject* rootForThisLayout, bool inSubtreeLayout) |
| { |
| TRACE_EVENT0("webkit", "FrameView::performLayout"); |
| |
| ScriptForbiddenScope forbidScript; |
| |
| ASSERT(!isInPerformLayout()); |
| lifecycle().advanceTo(DocumentLifecycle::InPerformLayout); |
| |
| TemporaryChange<bool> changeInPerformLayout(m_inPerformLayout, true); |
| |
| // performLayout is the actual guts of layout(). |
| // FIXME: The 300 other lines in layout() probably belong in other helper functions |
| // so that a single human could understand what layout() is actually doing. |
| |
| LayoutState layoutState(*rootForThisLayout); |
| |
| forceLayoutParentViewIfNeeded(); |
| |
| // FIXME (crbug.com/256657): Do not do two layouts for text autosizing. |
| rootForThisLayout->layout(); |
| gatherDebugLayoutRects(rootForThisLayout); |
| |
| ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->updateAllImageResourcePriorities(); |
| |
| TextAutosizer* textAutosizer = frame().document()->textAutosizer(); |
| bool autosized; |
| { |
| AllowPaintInvalidationScope paintInvalidationAllowed(this); |
| autosized = textAutosizer && textAutosizer->processSubtree(rootForThisLayout); |
| } |
| |
| if (autosized && rootForThisLayout->needsLayout()) { |
| TRACE_EVENT0("webkit", "2nd layout due to Text Autosizing"); |
| UseCounter::count(*frame().document(), UseCounter::TextAutosizingLayout); |
| rootForThisLayout->layout(); |
| gatherDebugLayoutRects(rootForThisLayout); |
| } |
| |
| lifecycle().advanceTo(DocumentLifecycle::AfterPerformLayout); |
| } |
| |
| void FrameView::scheduleOrPerformPostLayoutTasks() |
| { |
| if (m_postLayoutTasksTimer.isActive()) |
| return; |
| |
| if (!m_inSynchronousPostLayout) { |
| m_inSynchronousPostLayout = true; |
| // Calls resumeScheduledEvents() |
| performPostLayoutTasks(); |
| m_inSynchronousPostLayout = false; |
| } |
| |
| if (!m_postLayoutTasksTimer.isActive() && (needsLayout() || m_inSynchronousPostLayout)) { |
| // If we need layout or are already in a synchronous call to postLayoutTasks(), |
| // defer widget updates and event dispatch until after we return. postLayoutTasks() |
| // can make us need to update again, and we can get stuck in a nasty cycle unless |
| // we call it through the timer here. |
| m_postLayoutTasksTimer.startOneShot(0, FROM_HERE); |
| if (needsLayout()) |
| layout(); |
| } |
| } |
| |
| void FrameView::layout(bool allowSubtree) |
| { |
| // We should never layout a Document which is not in a LocalFrame. |
| ASSERT(m_frame); |
| ASSERT(m_frame->view() == this); |
| ASSERT(m_frame->page()); |
| |
| if (isInPerformLayout() || !m_frame->document()->isActive()) |
| return; |
| |
| TRACE_EVENT0("webkit", "FrameView::layout"); |
| TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "Layout"); |
| |
| // Protect the view from being deleted during layout (in recalcStyle) |
| RefPtr<FrameView> protector(this); |
| |
| // Every scroll that happens during layout is programmatic. |
| TemporaryChange<bool> changeInProgrammaticScroll(m_inProgrammaticScroll, true); |
| |
| m_hasPendingLayout = false; |
| DocumentLifecycle::Scope lifecycleScope(lifecycle(), DocumentLifecycle::LayoutClean); |
| |
| RELEASE_ASSERT(!isPainting()); |
| |
| TRACE_EVENT_BEGIN1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Layout", "beginData", InspectorLayoutEvent::beginData(this)); |
| TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"), "CallStack", "stack", InspectorCallStackEvent::currentCallStack()); |
| // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing. |
| InspectorInstrumentationCookie cookie = InspectorInstrumentation::willLayout(m_frame.get()); |
| |
| if (!allowSubtree && isSubtreeLayout()) { |
| m_layoutSubtreeRoot->markContainingBlocksForLayout(false); |
| m_layoutSubtreeRoot = 0; |
| } |
| |
| performPreLayoutTasks(); |
| |
| // If there is only one ref to this view left, then its going to be destroyed as soon as we exit, |
| // so there's no point to continuing to layout |
| if (protector->hasOneRef()) |
| return; |
| |
| Document* document = m_frame->document(); |
| bool inSubtreeLayout = isSubtreeLayout(); |
| RenderObject* rootForThisLayout = inSubtreeLayout ? m_layoutSubtreeRoot : document->renderView(); |
| if (!rootForThisLayout) { |
| // FIXME: Do we need to set m_size here? |
| ASSERT_NOT_REACHED(); |
| return; |
| } |
| |
| FontCachePurgePreventer fontCachePurgePreventer; |
| RenderLayer* layer; |
| { |
| TemporaryChange<bool> changeSchedulingEnabled(m_layoutSchedulingEnabled, false); |
| |
| m_nestedLayoutCount++; |
| if (!inSubtreeLayout) { |
| Document* document = m_frame->document(); |
| Node* body = document->body(); |
| if (body && body->renderer()) { |
| if (isHTMLFrameSetElement(*body)) { |
| body->renderer()->setChildNeedsLayout(); |
| } else if (isHTMLBodyElement(*body)) { |
| if (!m_firstLayout && m_size.height() != layoutSize().height() && body->renderer()->enclosingBox()->stretchesToViewport()) |
| body->renderer()->setChildNeedsLayout(); |
| } |
| } |
| } |
| updateCounters(); |
| autoSizeIfEnabled(); |
| |
| ScrollbarMode hMode; |
| ScrollbarMode vMode; |
| calculateScrollbarModesForLayoutAndSetViewportRenderer(hMode, vMode); |
| |
| if (!inSubtreeLayout) { |
| // Now set our scrollbar state for the layout. |
| ScrollbarMode currentHMode = horizontalScrollbarMode(); |
| ScrollbarMode currentVMode = verticalScrollbarMode(); |
| |
| if (m_firstLayout) { |
| setScrollbarsSuppressed(true); |
| |
| m_doFullPaintInvalidation = true; |
| m_firstLayout = false; |
| m_firstLayoutCallbackPending = true; |
| m_lastViewportSize = layoutSize(IncludeScrollbars); |
| m_lastZoomFactor = rootForThisLayout->style()->zoom(); |
| |
| // Set the initial vMode to AlwaysOn if we're auto. |
| if (vMode == ScrollbarAuto) |
| setVerticalScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear. |
| // Set the initial hMode to AlwaysOff if we're auto. |
| if (hMode == ScrollbarAuto) |
| setHorizontalScrollbarMode(ScrollbarAlwaysOff); // This causes a horizontal scrollbar to disappear. |
| |
| setScrollbarModes(hMode, vMode); |
| setScrollbarsSuppressed(false, true); |
| } else if (hMode != currentHMode || vMode != currentVMode) { |
| setScrollbarModes(hMode, vMode); |
| } |
| |
| LayoutSize oldSize = m_size; |
| |
| m_size = LayoutSize(layoutSize().width(), layoutSize().height()); |
| |
| if (oldSize != m_size && !m_firstLayout) { |
| RenderBox* rootRenderer = document->documentElement() ? document->documentElement()->renderBox() : 0; |
| RenderBox* bodyRenderer = rootRenderer && document->body() ? document->body()->renderBox() : 0; |
| if (bodyRenderer && bodyRenderer->stretchesToViewport()) |
| bodyRenderer->setChildNeedsLayout(); |
| else if (rootRenderer && rootRenderer->stretchesToViewport()) |
| rootRenderer->setChildNeedsLayout(); |
| } |
| |
| // We need to set m_doFullPaintInvalidation before triggering layout as RenderObject::checkForPaintInvalidation |
| // checks the boolean to disable local paint invalidations. |
| m_doFullPaintInvalidation |= renderView()->shouldDoFullRepaintForNextLayout(); |
| } |
| |
| layer = rootForThisLayout->enclosingLayer(); |
| |
| performLayout(rootForThisLayout, inSubtreeLayout); |
| |
| m_layoutSubtreeRoot = 0; |
| } // Reset m_layoutSchedulingEnabled to its previous value. |
| |
| if (!inSubtreeLayout && !toRenderView(rootForThisLayout)->document().printing()) |
| adjustViewSize(); |
| |
| layer->updateLayerPositionsAfterLayout(renderView()->layer(), updateLayerPositionFlags(layer, inSubtreeLayout, m_doFullPaintInvalidation)); |
| renderView()->compositor()->didLayout(); |
| |
| m_layoutCount++; |
| |
| if (AXObjectCache* cache = rootForThisLayout->document().axObjectCache()) { |
| const KURL& url = rootForThisLayout->document().url(); |
| if (url.isValid() && !url.isAboutBlankURL()) |
| cache->handleLayoutComplete(rootForThisLayout); |
| } |
| updateAnnotatedRegions(); |
| |
| ASSERT(!rootForThisLayout->needsLayout()); |
| |
| if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER)) |
| updateOverflowStatus(layoutSize().width() < contentsWidth(), layoutSize().height() < contentsHeight()); |
| |
| scheduleOrPerformPostLayoutTasks(); |
| |
| TRACE_EVENT_END1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Layout", "endData", InspectorLayoutEvent::endData(rootForThisLayout)); |
| // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing. |
| InspectorInstrumentation::didLayout(cookie, rootForThisLayout); |
| |
| m_nestedLayoutCount--; |
| if (m_nestedLayoutCount) |
| return; |
| |
| if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled()) { |
| invalidateTree(rootForThisLayout); |
| } else if (m_doFullPaintInvalidation) { |
| // FIXME: This isn't really right, since the RenderView doesn't fully encompass |
| // the visibleContentRect(). It just happens to work out most of the time, |
| // since first layouts and printing don't have you scrolled anywhere. |
| renderView()->paintInvalidationForWholeRenderer(); |
| } |
| |
| m_doFullPaintInvalidation = false; |
| |
| #ifndef NDEBUG |
| // Post-layout assert that nobody was re-marked as needing layout during layout. |
| document->renderView()->assertSubtreeIsLaidOut(); |
| #endif |
| |
| // FIXME: It should be not possible to remove the FrameView from the frame/page during layout |
| // however m_inPerformLayout is not set for most of this function, so none of our RELEASE_ASSERTS |
| // in LocalFrame/Page will fire. One of the post-layout tasks is disconnecting the LocalFrame from |
| // the page in fast/frames/crash-remove-iframe-during-object-beforeload-2.html |
| // necessitating this check here. |
| // ASSERT(frame()->page()); |
| if (frame().page()) |
| frame().page()->chrome().client().layoutUpdated(m_frame.get()); |
| } |
| |
| // The plan is to move to compositor-queried paint invalidation, in which case this |
| // method would setNeedsRedraw on the GraphicsLayers with invalidations and |
| // let the compositor pick which to actually draw. |
| // See http://crbug.com/306706 |
| void FrameView::invalidateTree(RenderObject* root) |
| { |
| ASSERT(RuntimeEnabledFeatures::repaintAfterLayoutEnabled()); |
| ASSERT(!root->needsLayout()); |
| // We should only invalidate paints for the outer most layout. This works as |
| // we continue to track paint invalidation rects until this function is called. |
| ASSERT(!m_nestedLayoutCount); |
| |
| TRACE_EVENT1("blink", "FrameView::invalidateTree", "root", root->debugName().ascii()); |
| |
| // FIXME: really, we're in the paint invalidation phase here, and the compositing queries are legal. |
| // Until those states are fully fledged, I'll just disable the ASSERTS. |
| DisableCompositingQueryAsserts compositingQueryAssertsDisabler; |
| |
| LayoutState rootLayoutState(*root); |
| |
| root->invalidateTreeAfterLayout(*root->containerForPaintInvalidation()); |
| |
| // Invalidate the paint of the frameviews scrollbars if needed |
| if (hasVerticalBarDamage()) |
| invalidateRect(verticalBarDamage()); |
| if (hasHorizontalBarDamage()) |
| invalidateRect(horizontalBarDamage()); |
| resetScrollbarDamage(); |
| } |
| |
| DocumentLifecycle& FrameView::lifecycle() const |
| { |
| return m_frame->document()->lifecycle(); |
| } |
| |
| void FrameView::gatherDebugLayoutRects(RenderObject* layoutRoot) |
| { |
| bool isTracing; |
| TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("blink.debug.layout"), &isTracing); |
| if (!isTracing) |
| return; |
| if (!layoutRoot->enclosingLayer()->hasCompositedLayerMapping()) |
| return; |
| GraphicsLayer* graphicsLayer = layoutRoot->enclosingLayer()->compositedLayerMapping()->mainGraphicsLayer(); |
| if (!graphicsLayer) |
| return; |
| |
| GraphicsLayerDebugInfo& debugInfo = graphicsLayer->debugInfo(); |
| |
| debugInfo.currentLayoutRects().clear(); |
| for (RenderObject* renderer = layoutRoot; renderer; renderer = renderer->nextInPreOrder()) { |
| if (renderer->layoutDidGetCalled()) { |
| FloatQuad quad = renderer->localToAbsoluteQuad(FloatQuad(renderer->previousPaintInvalidationRect())); |
| LayoutRect rect = quad.enclosingBoundingBox(); |
| debugInfo.currentLayoutRects().append(rect); |
| renderer->setLayoutDidGetCalled(false); |
| } |
| } |
| } |
| |
| RenderBox* FrameView::embeddedContentBox() const |
| { |
| RenderView* renderView = this->renderView(); |
| if (!renderView) |
| return 0; |
| |
| RenderObject* firstChild = renderView->firstChild(); |
| if (!firstChild || !firstChild->isBox()) |
| return 0; |
| |
| // Curently only embedded SVG documents participate in the size-negotiation logic. |
| if (firstChild->isSVGRoot()) |
| return toRenderBox(firstChild); |
| |
| return 0; |
| } |
| |
| |
| void FrameView::addWidget(RenderWidget* object) |
| { |
| m_widgets.add(object); |
| } |
| |
| void FrameView::removeWidget(RenderWidget* object) |
| { |
| m_widgets.remove(object); |
| } |
| |
| void FrameView::updateWidgetPositions() |
| { |
| Vector<RefPtr<RenderWidget> > widgets; |
| copyToVector(m_widgets, widgets); |
| |
| // Script or plugins could detach the frame so abort processing if that happens. |
| |
| for (size_t i = 0; i < widgets.size() && renderView(); ++i) |
| widgets[i]->updateWidgetPosition(); |
| |
| for (size_t i = 0; i < widgets.size() && renderView(); ++i) |
| widgets[i]->widgetPositionsUpdated(); |
| } |
| |
| void FrameView::addWidgetToUpdate(RenderEmbeddedObject& object) |
| { |
| ASSERT(isInPerformLayout()); |
| // Tell the DOM element that it needs a widget update. |
| Node* node = object.node(); |
| ASSERT(node); |
| if (isHTMLObjectElement(*node) || isHTMLEmbedElement(*node)) |
| toHTMLPlugInElement(node)->setNeedsWidgetUpdate(true); |
| |
| m_widgetUpdateSet.add(&object); |
| } |
| |
| void FrameView::setMediaType(const AtomicString& mediaType) |
| { |
| ASSERT(m_frame->document()); |
| m_frame->document()->mediaQueryAffectingValueChanged(); |
| m_mediaType = mediaType; |
| } |
| |
| AtomicString FrameView::mediaType() const |
| { |
| // See if we have an override type. |
| String overrideType; |
| InspectorInstrumentation::applyEmulatedMedia(m_frame.get(), &overrideType); |
| if (!overrideType.isNull()) |
| return AtomicString(overrideType); |
| return m_mediaType; |
| } |
| |
| void FrameView::adjustMediaTypeForPrinting(bool printing) |
| { |
| if (printing) { |
| if (m_mediaTypeWhenNotPrinting.isNull()) |
| m_mediaTypeWhenNotPrinting = mediaType(); |
| setMediaType("print"); |
| } else { |
| if (!m_mediaTypeWhenNotPrinting.isNull()) |
| setMediaType(m_mediaTypeWhenNotPrinting); |
| m_mediaTypeWhenNotPrinting = nullAtom; |
| } |
| } |
| |
| bool FrameView::useSlowRepaints(bool considerOverlap) const |
| { |
| // FIXME: It is incorrect to determine blit-scrolling eligibility using dirty compositing state. |
| // https://code.google.com/p/chromium/issues/detail?id=357345 |
| DisableCompositingQueryAsserts disabler; |
| |
| if (m_slowRepaintObjectCount > 0) |
| return true; |
| |
| if (contentsInCompositedLayer()) |
| return false; |
| |
| // The chromium compositor does not support scrolling a non-composited frame within a composited page through |
| // the fast scrolling path, so force slow scrolling in that case. |
| if (m_frame->owner() && !hasCompositedContent() && m_frame->page() && m_frame->page()->mainFrame()->isLocalFrame() && m_frame->page()->deprecatedLocalMainFrame()->view()->hasCompositedContent()) |
| return true; |
| |
| if (m_isOverlapped && considerOverlap) |
| return true; |
| |
| if (m_cannotBlitToWindow) |
| return true; |
| |
| if (!m_contentIsOpaque) |
| return true; |
| |
| if (FrameView* parentView = parentFrameView()) |
| return parentView->useSlowRepaints(considerOverlap); |
| |
| return false; |
| } |
| |
| bool FrameView::useSlowRepaintsIfNotOverlapped() const |
| { |
| return useSlowRepaints(false); |
| } |
| |
| bool FrameView::shouldAttemptToScrollUsingFastPath() const |
| { |
| return !useSlowRepaints(); |
| } |
| |
| bool FrameView::contentsInCompositedLayer() const |
| { |
| RenderView* renderView = this->renderView(); |
| if (renderView && renderView->compositingState() == PaintsIntoOwnBacking) { |
| GraphicsLayer* layer = renderView->layer()->compositedLayerMapping()->mainGraphicsLayer(); |
| if (layer && layer->drawsContent()) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| void FrameView::setCannotBlitToWindow() |
| { |
| m_cannotBlitToWindow = true; |
| } |
| |
| void FrameView::addSlowRepaintObject() |
| { |
| if (!m_slowRepaintObjectCount++) { |
| if (Page* page = m_frame->page()) { |
| if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator()) |
| scrollingCoordinator->frameViewHasSlowRepaintObjectsDidChange(this); |
| } |
| } |
| } |
| |
| void FrameView::removeSlowRepaintObject() |
| { |
| ASSERT(m_slowRepaintObjectCount > 0); |
| m_slowRepaintObjectCount--; |
| if (!m_slowRepaintObjectCount) { |
| if (Page* page = m_frame->page()) { |
| if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator()) |
| scrollingCoordinator->frameViewHasSlowRepaintObjectsDidChange(this); |
| } |
| } |
| } |
| |
| void FrameView::addViewportConstrainedObject(RenderObject* object) |
| { |
| if (!m_viewportConstrainedObjects) |
| m_viewportConstrainedObjects = adoptPtr(new ViewportConstrainedObjectSet); |
| |
| if (!m_viewportConstrainedObjects->contains(object)) { |
| m_viewportConstrainedObjects->add(object); |
| |
| if (Page* page = m_frame->page()) { |
| if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator()) |
| scrollingCoordinator->frameViewFixedObjectsDidChange(this); |
| } |
| } |
| } |
| |
| void FrameView::removeViewportConstrainedObject(RenderObject* object) |
| { |
| if (m_viewportConstrainedObjects && m_viewportConstrainedObjects->contains(object)) { |
| m_viewportConstrainedObjects->remove(object); |
| |
| if (Page* page = m_frame->page()) { |
| if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator()) |
| scrollingCoordinator->frameViewFixedObjectsDidChange(this); |
| } |
| } |
| } |
| |
| LayoutRect FrameView::viewportConstrainedVisibleContentRect() const |
| { |
| LayoutRect viewportRect = visibleContentRect(); |
| // Ignore overhang. No-op when not using rubber banding. |
| viewportRect.setLocation(clampScrollPosition(scrollPosition())); |
| return viewportRect; |
| } |
| |
| void FrameView::viewportConstrainedVisibleContentSizeChanged(bool widthChanged, bool heightChanged) |
| { |
| if (!hasViewportConstrainedObjects()) |
| return; |
| |
| // If viewport is not enabled, frameRect change will cause layout size change and then layout. |
| // Otherwise, viewport constrained objects need their layout flags set separately to ensure |
| // they are positioned correctly. In the virtual-viewport pinch mode frame rect changes wont |
| // necessarily cause a layout size change so only take this early-out if we're in old-style |
| // pinch. |
| if (m_frame->settings() |
| && !m_frame->settings()->viewportEnabled() |
| && !m_frame->settings()->pinchVirtualViewportEnabled()) |
| return; |
| |
| ViewportConstrainedObjectSet::const_iterator end = m_viewportConstrainedObjects->end(); |
| for (ViewportConstrainedObjectSet::const_iterator it = m_viewportConstrainedObjects->begin(); it != end; ++it) { |
| RenderObject* renderer = *it; |
| RenderStyle* style = renderer->style(); |
| if (widthChanged) { |
| if (style->width().isFixed() && (style->left().isAuto() || style->right().isAuto())) |
| renderer->setNeedsPositionedMovementLayout(); |
| else |
| renderer->setNeedsLayoutAndFullPaintInvalidation(); |
| } |
| if (heightChanged) { |
| if (style->height().isFixed() && (style->top().isAuto() || style->bottom().isAuto())) |
| renderer->setNeedsPositionedMovementLayout(); |
| else |
| renderer->setNeedsLayoutAndFullPaintInvalidation(); |
| } |
| } |
| } |
| |
| IntSize FrameView::scrollOffsetForFixedPosition() const |
| { |
| return toIntSize(clampScrollPosition(scrollPosition())); |
| } |
| |
| IntPoint FrameView::lastKnownMousePosition() const |
| { |
| return m_frame->eventHandler().lastKnownMousePosition(); |
| } |
| |
| bool FrameView::shouldSetCursor() const |
| { |
| Page* page = frame().page(); |
| return page && page->visibilityState() != PageVisibilityStateHidden && page->focusController().isActive() && page->settings().deviceSupportsMouse(); |
| } |
| |
| void FrameView::scrollContentsIfNeededRecursive() |
| { |
| scrollContentsIfNeeded(); |
| |
| for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) { |
| if (!child->isLocalFrame()) |
| continue; |
| if (FrameView* view = toLocalFrame(child)->view()) |
| view->scrollContentsIfNeededRecursive(); |
| } |
| } |
| |
| void FrameView::scrollContentsIfNeeded() |
| { |
| bool didScroll = !pendingScrollDelta().isZero(); |
| ScrollView::scrollContentsIfNeeded(); |
| if (didScroll) |
| updateFixedElementPaintInvalidationRectsAfterScroll(); |
| } |
| |
| bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect) |
| { |
| if (!m_viewportConstrainedObjects || m_viewportConstrainedObjects->isEmpty()) { |
| hostWindow()->scroll(scrollDelta, rectToScroll, clipRect); |
| return true; |
| } |
| |
| const bool isCompositedContentLayer = contentsInCompositedLayer(); |
| |
| // Get the rects of the fixed objects visible in the rectToScroll |
| Region regionToUpdate; |
| ViewportConstrainedObjectSet::const_iterator end = m_viewportConstrainedObjects->end(); |
| for (ViewportConstrainedObjectSet::const_iterator it = m_viewportConstrainedObjects->begin(); it != end; ++it) { |
| RenderObject* renderer = *it; |
| // m_viewportConstrainedObjects should not contain non-viewport constrained objects. |
| ASSERT(renderer->style()->hasViewportConstrainedPosition()); |
| |
| // Fixed items should always have layers. |
| ASSERT(renderer->hasLayer()); |
| RenderLayer* layer = toRenderBoxModelObject(renderer)->layer(); |
| |
| // Layers that paint into their ancestor or into a grouped backing will still need |
| // to apply a paint invalidation. If the layer paints into its own backing, then |
| // it does not need paint invalidation just to scroll. |
| if (layer->compositingState() == PaintsIntoOwnBacking) |
| continue; |
| |
| if (layer->viewportConstrainedNotCompositedReason() == RenderLayer::NotCompositedForBoundsOutOfView |
| || layer->viewportConstrainedNotCompositedReason() == RenderLayer::NotCompositedForNoVisibleContent) { |
| // Don't invalidate for invisible fixed layers. |
| continue; |
| } |
| |
| if (layer->hasAncestorWithFilterOutsets()) { |
| // If the fixed layer has a blur/drop-shadow filter applied on at least one of its parents, we cannot |
| // scroll using the fast path, otherwise the outsets of the filter will be moved around the page. |
| return false; |
| } |
| |
| IntRect updateRect = pixelSnappedIntRect(layer->repainter().repaintRectIncludingNonCompositingDescendants()); |
| |
| const RenderLayerModelObject* repaintContainer = layer->renderer()->containerForPaintInvalidation(); |
| if (repaintContainer && !repaintContainer->isRenderView()) { |
| // If the fixed-position layer is contained by a composited layer that is not its containing block, |
| // then we have to invalidate that enclosing layer, not the RenderView. |
| // FIXME: Why do we need to issue this invalidation? Won't the fixed position element just scroll |
| // with the enclosing layer. |
| updateRect.moveBy(scrollPosition()); |
| IntRect previousRect = updateRect; |
| previousRect.move(scrollDelta); |
| updateRect.unite(previousRect); |
| layer->renderer()->invalidatePaintUsingContainer(repaintContainer, updateRect, InvalidationScroll); |
| } else { |
| // Coalesce the paint invalidations that will be issued to the renderView. |
| updateRect = contentsToRootView(updateRect); |
| if (!isCompositedContentLayer && clipsPaintInvalidations()) |
| updateRect.intersect(rectToScroll); |
| if (!updateRect.isEmpty()) |
| regionToUpdate.unite(updateRect); |
| } |
| } |
| |
| // 1) scroll |
| hostWindow()->scroll(scrollDelta, rectToScroll, clipRect); |
| |
| // 2) update the area of fixed objects that has been invalidated |
| Vector<IntRect> subRectsToUpdate = regionToUpdate.rects(); |
| size_t viewportConstrainedObjectsCount = subRectsToUpdate.size(); |
| for (size_t i = 0; i < viewportConstrainedObjectsCount; ++i) { |
| IntRect updateRect = subRectsToUpdate[i]; |
| IntRect scrolledRect = updateRect; |
| scrolledRect.move(-scrollDelta); |
| updateRect.unite(scrolledRect); |
| if (isCompositedContentLayer) { |
| updateRect = rootViewToContents(updateRect); |
| ASSERT(renderView()); |
| renderView()->layer()->repainter().setBackingNeedsRepaintInRect(updateRect); |
| continue; |
| } |
| if (clipsPaintInvalidations()) |
| updateRect.intersect(rectToScroll); |
| hostWindow()->invalidateContentsAndRootView(updateRect); |
| } |
| |
| return true; |
| } |
| |
| void FrameView::scrollContentsSlowPath(const IntRect& updateRect) |
| { |
| if (contentsInCompositedLayer()) { |
| IntRect updateRect = visibleContentRect(); |
| ASSERT(renderView()); |
| renderView()->layer()->repainter().setBackingNeedsRepaintInRect(updateRect); |
| } |
| if (RenderPart* frameRenderer = m_frame->ownerRenderer()) { |
| if (isEnclosedInCompositingLayer()) { |
| LayoutRect rect(frameRenderer->borderLeft() + frameRenderer->paddingLeft(), |
| frameRenderer->borderTop() + frameRenderer->paddingTop(), |
| visibleWidth(), visibleHeight()); |
| frameRenderer->invalidatePaintRectangle(rect); |
| return; |
| } |
| } |
| |
| ScrollView::scrollContentsSlowPath(updateRect); |
| } |
| |
| // Note that this gets called at painting time. |
| void FrameView::setIsOverlapped(bool isOverlapped) |
| { |
| m_isOverlapped = isOverlapped; |
| } |
| |
| void FrameView::setContentIsOpaque(bool contentIsOpaque) |
| { |
| m_contentIsOpaque = contentIsOpaque; |
| } |
| |
| void FrameView::restoreScrollbar() |
| { |
| setScrollbarsSuppressed(false); |
| } |
| |
| bool FrameView::scrollToFragment(const KURL& url) |
| { |
| // If our URL has no ref, then we have no place we need to jump to. |
| // OTOH If CSS target was set previously, we want to set it to 0, recalc |
| // and possibly paint invalidation because :target pseudo class may have been |
| // set (see bug 11321). |
| if (!url.hasFragmentIdentifier() && !m_frame->document()->cssTarget()) |
| return false; |
| |
| String fragmentIdentifier = url.fragmentIdentifier(); |
| if (scrollToAnchor(fragmentIdentifier)) |
| return true; |
| |
| // Try again after decoding the ref, based on the document's encoding. |
| if (m_frame->document()->encoding().isValid()) |
| return scrollToAnchor(decodeURLEscapeSequences(fragmentIdentifier, m_frame->document()->encoding())); |
| |
| return false; |
| } |
| |
| bool FrameView::scrollToAnchor(const String& name) |
| { |
| ASSERT(m_frame->document()); |
| |
| if (!m_frame->document()->isRenderingReady()) { |
| m_frame->document()->setGotoAnchorNeededAfterStylesheetsLoad(true); |
| return false; |
| } |
| |
| m_frame->document()->setGotoAnchorNeededAfterStylesheetsLoad(false); |
| |
| Element* anchorNode = m_frame->document()->findAnchor(name); |
| |
| // Setting to null will clear the current target. |
| m_frame->document()->setCSSTarget(anchorNode); |
| |
| if (m_frame->document()->isSVGDocument()) { |
| if (SVGSVGElement* svg = SVGDocumentExtensions::rootElement(*m_frame->document())) { |
| svg->setupInitialView(name, anchorNode); |
| if (!anchorNode) |
| return true; |
| } |
| } |
| |
| // Implement the rule that "" and "top" both mean top of page as in other browsers. |
| if (!anchorNode && !(name.isEmpty() || equalIgnoringCase(name, "top"))) |
| return false; |
| |
| maintainScrollPositionAtAnchor(anchorNode ? static_cast<Node*>(anchorNode) : m_frame->document()); |
| |
| // If the anchor accepts keyboard focus, move focus there to aid users relying on keyboard navigation. |
| if (anchorNode && anchorNode->isFocusable()) |
| m_frame->document()->setFocusedElement(anchorNode); |
| |
| return true; |
| } |
| |
| void FrameView::maintainScrollPositionAtAnchor(Node* anchorNode) |
| { |
| m_maintainScrollPositionAnchor = anchorNode; |
| if (!m_maintainScrollPositionAnchor) |
| return; |
| |
| // We need to update the layout before scrolling, otherwise we could |
| // really mess things up if an anchor scroll comes at a bad moment. |
| m_frame->document()->updateRenderTreeIfNeeded(); |
| // Only do a layout if changes have occurred that make it necessary. |
| RenderView* renderView = this->renderView(); |
| if (renderView && renderView->needsLayout()) |
| layout(); |
| else |
| scrollToAnchor(); |
| } |
| |
| void FrameView::scrollElementToRect(Element* element, const IntRect& rect) |
| { |
| // FIXME(http://crbug.com/371896) - This method shouldn't be manually doing |
| // coordinate transformations to the PinchViewport. |
| IntRect targetRect(rect); |
| |
| m_frame->document()->updateLayoutIgnorePendingStylesheets(); |
| |
| bool pinchVirtualViewportEnabled = m_frame->settings()->pinchVirtualViewportEnabled(); |
| |
| if (pinchVirtualViewportEnabled) { |
| PinchViewport& pinchViewport = m_frame->page()->frameHost().pinchViewport(); |
| |
| IntSize pinchViewportSize = expandedIntSize(pinchViewport.visibleRect().size()); |
| targetRect.moveBy(ceiledIntPoint(pinchViewport.visibleRect().location())); |
| targetRect.setSize(pinchViewportSize.shrunkTo(targetRect.size())); |
| } |
| |
| LayoutRect bounds = element->boundingBox(); |
| int centeringOffsetX = (targetRect.width() - bounds.width()) / 2; |
| int centeringOffsetY = (targetRect.height() - bounds.height()) / 2; |
| |
| IntPoint targetOffset( |
| bounds.x() - centeringOffsetX - targetRect.x(), |
| bounds.y() - centeringOffsetY - targetRect.y()); |
| |
| setScrollPosition(targetOffset); |
| |
| if (pinchVirtualViewportEnabled) { |
| IntPoint remainder = IntPoint(targetOffset - scrollPosition()); |
| m_frame->page()->frameHost().pinchViewport().move(remainder); |
| } |
| } |
| |
| void FrameView::setScrollPosition(const IntPoint& scrollPoint) |
| { |
| TemporaryChange<bool> changeInProgrammaticScroll(m_inProgrammaticScroll, true); |
| m_maintainScrollPositionAnchor = nullptr; |
| |
| IntPoint newScrollPosition = adjustScrollPositionWithinRange(scrollPoint); |
| |
| if (newScrollPosition == scrollPosition()) |
| return; |
| |
| ScrollView::setScrollPosition(newScrollPosition); |
| } |
| |
| void FrameView::setScrollPositionNonProgrammatically(const IntPoint& scrollPoint) |
| { |
| IntPoint newScrollPosition = adjustScrollPositionWithinRange(scrollPoint); |
| |
| if (newScrollPosition == scrollPosition()) |
| return; |
| |
| TemporaryChange<bool> changeInProgrammaticScroll(m_inProgrammaticScroll, false); |
| notifyScrollPositionChanged(newScrollPosition); |
| } |
| |
| IntSize FrameView::layoutSize(IncludeScrollbarsInRect scrollbarInclusion) const |
| { |
| return scrollbarInclusion == ExcludeScrollbars ? excludeScrollbars(m_layoutSize) : m_layoutSize; |
| } |
| |
| void FrameView::setLayoutSize(const IntSize& size) |
| { |
| ASSERT(!layoutSizeFixedToFrameSize()); |
| |
| setLayoutSizeInternal(size); |
| } |
| |
| void FrameView::scrollPositionChanged() |
| { |
| setWasScrolledByUser(true); |
| |
| Document* document = m_frame->document(); |
| document->enqueueScrollEventForNode(document); |
| |
| m_frame->eventHandler().dispatchFakeMouseMoveEventSoon(); |
| |
| if (RenderView* renderView = document->renderView()) { |
| if (renderView->usesCompositing()) |
| renderView->compositor()->frameViewDidScroll(); |
| } |
| |
| if (m_didScrollTimer.isActive()) |
| m_didScrollTimer.stop(); |
| m_didScrollTimer.startOneShot(resourcePriorityUpdateDelayAfterScroll, FROM_HERE); |
| |
| if (AXObjectCache* cache = m_frame->document()->existingAXObjectCache()) |
| cache->handleScrollPositionChanged(this); |
| |
| frame().loader().saveScrollState(); |
| } |
| |
| void FrameView::didScrollTimerFired(Timer<FrameView>*) |
| { |
| if (m_frame->document() && m_frame->document()->renderView()) { |
| ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->updateAllImageResourcePriorities(); |
| } |
| } |
| |
| void FrameView::updateLayersAndCompositingAfterScrollIfNeeded() |
| { |
| // Nothing to do after scrolling if there are no fixed position elements. |
| if (!hasViewportConstrainedObjects()) |
| return; |
| |
| RefPtr<FrameView> protect(this); |
| |
| // If there fixed position elements, scrolling may cause compositing layers to change. |
| // Update widget and layer positions after scrolling, but only if we're not inside of |
| // layout. |
| if (!m_nestedLayoutCount) { |
| updateWidgetPositions(); |
| if (RenderView* renderView = this->renderView()) { |
| renderView->layer()->updateLayerPositionsAfterDocumentScroll(); |
| renderView->layer()->setNeedsCompositingInputsUpdate(); |
| renderView->compositor()->setNeedsCompositingUpdate(CompositingUpdateAfterCompositingInputChange); |
| } |
| } |
| } |
| |
| void FrameView::updateFixedElementPaintInvalidationRectsAfterScroll() |
| { |
| if (!hasViewportConstrainedObjects()) |
| return; |
| |
| // Update the paint invalidation rects for fixed elements after scrolling and invalidation to reflect |
| // the new scroll position. |
| ViewportConstrainedObjectSet::const_iterator end = m_viewportConstrainedObjects->end(); |
| for (ViewportConstrainedObjectSet::const_iterator it = m_viewportConstrainedObjects->begin(); it != end; ++it) { |
| RenderObject* renderer = *it; |
| // m_viewportConstrainedObjects should not contain non-viewport constrained objects. |
| ASSERT(renderer->style()->hasViewportConstrainedPosition()); |
| |
| // Fixed items should always have layers. |
| ASSERT(renderer->hasLayer()); |
| |
| RenderLayer* layer = toRenderBoxModelObject(renderer)->layer(); |
| |
| // Don't need to do this for composited fixed items. |
| if (layer->compositingState() == PaintsIntoOwnBacking) |
| continue; |
| |
| // Also don't need to do this for invisible items. |
| if (layer->viewportConstrainedNotCompositedReason() == RenderLayer::NotCompositedForBoundsOutOfView |
| || layer->viewportConstrainedNotCompositedReason() == RenderLayer::NotCompositedForNoVisibleContent) |
| continue; |
| |
| layer->repainter().computeRepaintRectsIncludingNonCompositingDescendants(); |
| } |
| } |
| |
| bool FrameView::isRubberBandInProgress() const |
| { |
| if (scrollbarsSuppressed()) |
| return false; |
| |
| // If the main thread updates the scroll position for this FrameView, we should return |
| // ScrollAnimator::isRubberBandInProgress(). |
| if (ScrollAnimator* scrollAnimator = existingScrollAnimator()) |
| return scrollAnimator->isRubberBandInProgress(); |
| |
| return false; |
| } |
| |
| HostWindow* FrameView::hostWindow() const |
| { |
| Page* page = frame().page(); |
| if (!page) |
| return 0; |
| return &page->chrome(); |
| } |
| |
| void FrameView::contentRectangleForPaintInvalidation(const IntRect& r) |
| { |
| ASSERT(paintInvalidationIsAllowed()); |
| ASSERT(!m_frame->owner()); |
| |
| if (m_isTrackingPaintInvalidations) { |
| IntRect paintInvalidationRect = r; |
| paintInvalidationRect.move(-scrollOffset()); |
| m_trackedPaintInvalidationRects.append(paintInvalidationRect); |
| // FIXME: http://crbug.com/368518. Eventually, invalidateContentRectangleForPaint |
| // is going away entirely once all layout tests are FCM. In the short |
| // term, no code should be tracking non-composited FrameView paint invalidations. |
| RELEASE_ASSERT_NOT_REACHED(); |
| } |
| |
| ScrollView::contentRectangleForPaintInvalidation(r); |
| } |
| |
| void FrameView::contentsResized() |
| { |
| if (m_frame->isMainFrame() && m_frame->document()) { |
| if (FastTextAutosizer* textAutosizer = m_frame->document()->fastTextAutosizer()) |
| textAutosizer->updatePageInfoInAllFrames(); |
| } |
| |
| ScrollView::contentsResized(); |
| setNeedsLayout(); |
| } |
| |
| void FrameView::scrollbarExistenceDidChange() |
| { |
| // We check to make sure the view is attached to a frame() as this method can |
| // be triggered before the view is attached by LocalFrame::createView(...) setting |
| // various values such as setScrollBarModes(...) for example. An ASSERT is |
| // triggered when a view is layout before being attached to a frame(). |
| if (!frame().view()) |
| return; |
| |
| // Note that simply having overlay scrollbars is not sufficient to be |
| // certain that scrollbars' presence does not impact layout. This should |
| // also check if custom scrollbars (as reported by shouldUseCustomScrollbars) |
| // are in use as well. |
| // http://crbug.com/269692 |
| bool useOverlayScrollbars = ScrollbarTheme::theme()->usesOverlayScrollbars(); |
| |
| if (!useOverlayScrollbars && needsLayout()) |
| layout(); |
| |
| if (renderView() && renderView()->usesCompositing()) { |
| renderView()->compositor()->frameViewScrollbarsExistenceDidChange(); |
| |
| if (!useOverlayScrollbars) |
| renderView()->compositor()->frameViewDidChangeSize(); |
| } |
| } |
| |
| void FrameView::handleLoadCompleted() |
| { |
| // Once loading has completed, allow autoSize one last opportunity to |
| // reduce the size of the frame. |
| autoSizeIfEnabled(); |
| } |
| |
| void FrameView::scheduleRelayout() |
| { |
| ASSERT(m_frame->view() == this); |
| |
| if (isSubtreeLayout()) { |
| m_layoutSubtreeRoot->markContainingBlocksForLayout(false); |
| m_layoutSubtreeRoot = 0; |
| } |
| if (!m_layoutSchedulingEnabled) |
| return; |
| if (!needsLayout()) |
| return; |
| if (!m_frame->document()->shouldScheduleLayout()) |
| return; |
| TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "InvalidateLayout", "frame", m_frame.get()); |
| TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"), "CallStack", "stack", InspectorCallStackEvent::currentCallStack()); |
| // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing. |
| InspectorInstrumentation::didInvalidateLayout(m_frame.get()); |
| |
| if (m_hasPendingLayout) |
| return; |
| m_hasPendingLayout = true; |
| |
| page()->animator().scheduleVisualUpdate(); |
| lifecycle().ensureStateAtMost(DocumentLifecycle::StyleClean); |
| } |
| |
| static bool isObjectAncestorContainerOf(RenderObject* ancestor, RenderObject* descendant) |
| { |
| for (RenderObject* r = descendant; r; r = r->container()) { |
| if (r == ancestor) |
| return true; |
| } |
| return false; |
| } |
| |
| void FrameView::scheduleRelayoutOfSubtree(RenderObject* relayoutRoot) |
| { |
| ASSERT(m_frame->view() == this); |
| |
| // FIXME: Should this call shouldScheduleLayout instead? |
| if (!m_frame->document()->isActive()) |
| return; |
| |
| RenderView* renderView = this->renderView(); |
| if (renderView && renderView->needsLayout()) { |
| if (relayoutRoot) |
| relayoutRoot->markContainingBlocksForLayout(false); |
| return; |
| } |
| |
| if (layoutPending() || !m_layoutSchedulingEnabled) { |
| if (m_layoutSubtreeRoot != relayoutRoot) { |
| if (isObjectAncestorContainerOf(m_layoutSubtreeRoot, relayoutRoot)) { |
| // Keep the current root |
| relayoutRoot->markContainingBlocksForLayout(false, m_layoutSubtreeRoot); |
| ASSERT(!m_layoutSubtreeRoot->container() || !m_layoutSubtreeRoot->container()->needsLayout()); |
| } else if (isSubtreeLayout() && isObjectAncestorContainerOf(relayoutRoot, m_layoutSubtreeRoot)) { |
| // Re-root at relayoutRoot |
| m_layoutSubtreeRoot->markContainingBlocksForLayout(false, relayoutRoot); |
| m_layoutSubtreeRoot = relayoutRoot; |
| ASSERT(!m_layoutSubtreeRoot->container() || !m_layoutSubtreeRoot->container()->needsLayout()); |
| } else { |
| // Just do a full relayout |
| if (isSubtreeLayout()) |
| m_layoutSubtreeRoot->markContainingBlocksForLayout(false); |
| m_layoutSubtreeRoot = 0; |
| relayoutRoot->markContainingBlocksForLayout(false); |
| } |
| } |
| } else if (m_layoutSchedulingEnabled) { |
| m_layoutSubtreeRoot = relayoutRoot; |
| ASSERT(!m_layoutSubtreeRoot->container() || !m_layoutSubtreeRoot->container()->needsLayout()); |
| m_hasPendingLayout = true; |
| |
| page()->animator().scheduleVisualUpdate(); |
| lifecycle().ensureStateAtMost(DocumentLifecycle::StyleClean); |
| } |
| TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "InvalidateLayout", "frame", m_frame.get()); |
| TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"), "CallStack", "stack", InspectorCallStackEvent::currentCallStack()); |
| // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing. |
| InspectorInstrumentation::didInvalidateLayout(m_frame.get()); |
| } |
| |
| bool FrameView::layoutPending() const |
| { |
| // FIXME: This should check Document::lifecycle instead. |
| return m_hasPendingLayout; |
| } |
| |
| bool FrameView::isInPerformLayout() const |
| { |
| ASSERT(m_inPerformLayout == (lifecycle().state() == DocumentLifecycle::InPerformLayout)); |
| return m_inPerformLayout; |
| } |
| |
| bool FrameView::needsLayout() const |
| { |
| // This can return true in cases where the document does not have a body yet. |
| // Document::shouldScheduleLayout takes care of preventing us from scheduling |
| // layout in that case. |
| |
| RenderView* renderView = this->renderView(); |
| return layoutPending() |
| || (renderView && renderView->needsLayout()) |
| || isSubtreeLayout(); |
| } |
| |
| void FrameView::setNeedsLayout() |
| { |
| if (RenderView* renderView = this->renderView()) |
| renderView->setNeedsLayout(); |
| } |
| |
| bool FrameView::isTransparent() const |
| { |
| return m_isTransparent; |
| } |
| |
| void FrameView::setTransparent(bool isTransparent) |
| { |
| m_isTransparent = isTransparent; |
| DisableCompositingQueryAsserts disabler; |
| if (renderView() && renderView()->layer()->hasCompositedLayerMapping()) |
| renderView()->layer()->compositedLayerMapping()->updateContentsOpaque(); |
| } |
| |
| bool FrameView::hasOpaqueBackground() const |
| { |
| return !m_isTransparent && !m_baseBackgroundColor.hasAlpha(); |
| } |
| |
| Color FrameView::baseBackgroundColor() const |
| { |
| return m_baseBackgroundColor; |
| } |
| |
| void FrameView::setBaseBackgroundColor(const Color& backgroundColor) |
| { |
| m_baseBackgroundColor = backgroundColor; |
| |
| if (renderView() && renderView()->layer()->hasCompositedLayerMapping()) { |
| CompositedLayerMappingPtr compositedLayerMapping = renderView()->layer()->compositedLayerMapping(); |
| compositedLayerMapping->updateContentsOpaque(); |
| if (compositedLayerMapping->mainGraphicsLayer()) |
| compositedLayerMapping->mainGraphicsLayer()->setNeedsDisplay(); |
| } |
| recalculateScrollbarOverlayStyle(); |
| } |
| |
| void FrameView::updateBackgroundRecursively(const Color& backgroundColor, bool transparent) |
| { |
| for (Frame* frame = m_frame.get(); frame; frame = frame->tree().traverseNext(m_frame.get())) { |
| if (!frame->isLocalFrame()) |
| continue; |
| if (FrameView* view = toLocalFrame(frame)->view()) { |
| view->setTransparent(transparent); |
| view->setBaseBackgroundColor(backgroundColor); |
| } |
| } |
| } |
| |
| void FrameView::scrollToAnchor() |
| { |
| RefPtrWillBeRawPtr<Node> anchorNode = m_maintainScrollPositionAnchor; |
| if (!anchorNode) |
| return; |
| |
| if (!anchorNode->renderer()) |
| return; |
| |
| LayoutRect rect; |
| if (anchorNode != m_frame->document()) |
| rect = anchorNode->boundingBox(); |
| |
| // Scroll nested layers and frames to reveal the anchor. |
| // Align to the top and to the closest side (this matches other browsers). |
| anchorNode->renderer()->scrollRectToVisible(rect, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways); |
| |
| if (AXObjectCache* cache = m_frame->document()->existingAXObjectCache()) |
| cache->handleScrolledToAnchor(anchorNode.get()); |
| |
| // scrollRectToVisible can call into setScrollPosition(), which resets m_maintainScrollPositionAnchor. |
| m_maintainScrollPositionAnchor = anchorNode; |
| } |
| |
| bool FrameView::updateWidgets() |
| { |
| // This is always called from updateWidgetsTimerFired. |
| // m_updateWidgetsTimer should only be scheduled if we have widgets to update. |
| // Thus I believe we can stop checking isEmpty here, and just ASSERT isEmpty: |
| ASSERT(!m_widgetUpdateSet.isEmpty()); |
| if (m_nestedLayoutCount > 1 || m_widgetUpdateSet.isEmpty()) |
| return true; |
| |
| // Need to swap because script will run inside the below loop and invalidate the iterator. |
| EmbeddedObjectSet objects; |
| objects.swap(m_widgetUpdateSet); |
| |
| for (EmbeddedObjectSet::iterator it = objects.begin(); it != objects.end(); ++it) { |
| RenderEmbeddedObject& object = **it; |
| HTMLPlugInElement* element = toHTMLPlugInElement(object.node()); |
| |
| // The object may have already been destroyed (thus node cleared), |
| // but FrameView holds a manual ref, so it won't have been deleted. |
| if (!element) |
| continue; |
| |
| // No need to update if it's already crashed or known to be missing. |
| if (object.showsUnavailablePluginIndicator()) |
| continue; |
| |
| if (element->needsWidgetUpdate()) |
| element->updateWidget(); |
| object.updateWidgetPosition(); |
| |
| // Prevent plugins from causing infinite updates of themselves. |
| // FIXME: Do we really need to prevent this? |
| m_widgetUpdateSet.remove(&object); |
| } |
| |
| return m_widgetUpdateSet.isEmpty(); |
| } |
| |
| void FrameView::updateWidgetsTimerFired(Timer<FrameView>*) |
| { |
| ASSERT(!isInPerformLayout()); |
| RefPtr<FrameView> protect(this); |
| m_updateWidgetsTimer.stop(); |
| for (unsigned i = 0; i < maxUpdateWidgetsIterations; ++i) { |
| if (updateWidgets()) |
| return; |
| } |
| } |
| |
| void FrameView::flushAnyPendingPostLayoutTasks() |
| { |
| ASSERT(!isInPerformLayout()); |
| if (m_postLayoutTasksTimer.isActive()) |
| performPostLayoutTasks(); |
| if (m_updateWidgetsTimer.isActive()) |
| updateWidgetsTimerFired(0); |
| } |
| |
| void FrameView::scheduleUpdateWidgetsIfNecessary() |
| { |
| ASSERT(!isInPerformLayout()); |
| if (m_updateWidgetsTimer.isActive() || m_widgetUpdateSet.isEmpty()) |
| return; |
| m_updateWidgetsTimer.startOneShot(0, FROM_HERE); |
| } |
| |
| void FrameView::performPostLayoutTasks() |
| { |
| // FIXME: We can reach here, even when the page is not active! |
| // http/tests/inspector/elements/html-link-import.html and many other |
| // tests hit that case. |
| // We should ASSERT(isActive()); or at least return early if we can! |
| ASSERT(!isInPerformLayout()); // Always before or after performLayout(), part of the highest-level layout() call. |
| TRACE_EVENT0("webkit", "FrameView::performPostLayoutTasks"); |
| RefPtr<FrameView> protect(this); |
| |
| m_postLayoutTasksTimer.stop(); |
| |
| m_frame->selection().setCaretRectNeedsUpdate(); |
| |
| { |
| // Hits in compositing/overflow/do-not-repaint-if-scrolling-composited-layers.html |
| DisableCompositingQueryAsserts disabler; |
| m_frame->selection().updateAppearance(); |
| } |
| |
| ASSERT(m_frame->document()); |
| if (m_nestedLayoutCount <= 1) { |
| if (m_firstLayoutCallbackPending) |
| m_firstLayoutCallbackPending = false; |
| |
| // Ensure that we always send this eventually. |
| if (!m_frame->document()->parsing() && m_frame->loader().stateMachine()->committedFirstRealDocumentLoad()) |
| m_isVisuallyNonEmpty = true; |
| |
| // If the layout was done with pending sheets, we are not in fact visually non-empty yet. |
| if (m_isVisuallyNonEmpty && !m_frame->document()->didLayoutWithPendingStylesheets() && m_firstVisuallyNonEmptyLayoutCallbackPending) { |
| m_firstVisuallyNonEmptyLayoutCallbackPending = false; |
| // FIXME: This callback is probably not needed, but is currently used |
| // by android for setting the background color. |
| m_frame->loader().client()->dispatchDidFirstVisuallyNonEmptyLayout(); |
| } |
| } |
| |
| FontFaceSet::didLayout(*m_frame->document()); |
| |
| updateWidgetPositions(); |
| |
| // Plugins could have torn down the page inside updateWidgetPositions(). |
| if (!renderView()) |
| return; |
| |
| scheduleUpdateWidgetsIfNecessary(); |
| |
| if (Page* page = m_frame->page()) { |
| if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator()) |
| scrollingCoordinator->notifyLayoutUpdated(); |
| } |
| |
| scrollToAnchor(); |
| |
| sendResizeEventIfNeeded(); |
| } |
| |
| void FrameView::sendResizeEventIfNeeded() |
| { |
| ASSERT(m_frame); |
| |
| RenderView* renderView = this->renderView(); |
| if (!renderView || renderView->document().printing()) |
| return; |
| |
| IntSize currentSize = layoutSize(IncludeScrollbars); |
| float currentZoomFactor = renderView->style()->zoom(); |
| |
| bool shouldSendResizeEvent = currentSize != m_lastViewportSize || currentZoomFactor != m_lastZoomFactor; |
| |
| m_lastViewportSize = currentSize; |
| m_lastZoomFactor = currentZoomFactor; |
| |
| if (!shouldSendResizeEvent) |
| return; |
| |
| m_frame->document()->enqueueResizeEvent(); |
| |
| if (m_frame->isMainFrame()) |
| InspectorInstrumentation::didResizeMainFrame(m_frame->page()); |
| } |
| |
| void FrameView::postLayoutTimerFired(Timer<FrameView>*) |
| { |
| performPostLayoutTasks(); |
| } |
| |
| void FrameView::updateCounters() |
| { |
| RenderView* view = renderView(); |
| if (!view->hasRenderCounters()) |
| return; |
| |
| for (RenderObject* renderer = view; renderer; renderer = renderer->nextInPreOrder()) { |
| if (!renderer->isCounter()) |
| continue; |
| |
| toRenderCounter(renderer)->updateCounter(); |
| } |
| } |
| |
| void FrameView::autoSizeIfEnabled() |
| { |
| if (!m_shouldAutoSize) |
| return; |
| |
| if (m_inAutoSize) |
| return; |
| |
| TemporaryChange<bool> changeInAutoSize(m_inAutoSize, true); |
| |
| Document* document = frame().document(); |
| if (!document || !document->isActive()) |
| return; |
| |
| Element* documentElement = document->documentElement(); |
| if (!documentElement) |
| return; |
| |
| // If this is the first time we run autosize, start from small height and |
| // allow it to grow. |
| if (!m_didRunAutosize) |
| resize(frameRect().width(), m_minAutoSize.height()); |
| |
| IntSize size = frameRect().size(); |
| |
| // Do the resizing twice. The first time is basically a rough calculation using the preferred width |
| // which may result in a height change during the second iteration. |
| for (int i = 0; i < 2; i++) { |
| // Update various sizes including contentsSize, scrollHeight, etc. |
| document->updateLayoutIgnorePendingStylesheets(); |
| |
| RenderView* renderView = document->renderView(); |
| if (!renderView) |
| return; |
| |
| int width = renderView->minPreferredLogicalWidth(); |
| |
| RenderBox* documentRenderBox = documentElement->renderBox(); |
| if (!documentRenderBox) |
| return; |
| |
| int height = documentRenderBox->scrollHeight(); |
| IntSize newSize(width, height); |
| |
| // Check to see if a scrollbar is needed for a given dimension and |
| // if so, increase the other dimension to account for the scrollbar. |
| // Since the dimensions are only for the view rectangle, once a |
| // dimension exceeds the maximum, there is no need to increase it further. |
| if (newSize.width() > m_maxAutoSize.width()) { |
| RefPtr<Scrollbar> localHorizontalScrollbar = horizontalScrollbar(); |
| if (!localHorizontalScrollbar) |
| localHorizontalScrollbar = createScrollbar(HorizontalScrollbar); |
| if (!localHorizontalScrollbar->isOverlayScrollbar()) |
| newSize.setHeight(newSize.height() + localHorizontalScrollbar->height()); |
| |
| // Don't bother checking for a vertical scrollbar because the width is at |
| // already greater the maximum. |
| } else if (newSize.height() > m_maxAutoSize.height()) { |
| RefPtr<Scrollbar> localVerticalScrollbar = verticalScrollbar(); |
| if (!localVerticalScrollbar) |
| localVerticalScrollbar = createScrollbar(VerticalScrollbar); |
| if (!localVerticalScrollbar->isOverlayScrollbar()) |
| newSize.setWidth(newSize.width() + localVerticalScrollbar->width()); |
| |
| // Don't bother checking for a horizontal scrollbar because the height is |
| // already greater the maximum. |
| } |
| |
| // Ensure the size is at least the min bounds. |
| newSize = newSize.expandedTo(m_minAutoSize); |
| |
| // Bound the dimensions by the max bounds and determine what scrollbars to show. |
| ScrollbarMode horizonalScrollbarMode = ScrollbarAlwaysOff; |
| if (newSize.width() > m_maxAutoSize.width()) { |
| newSize.setWidth(m_maxAutoSize.width()); |
| horizonalScrollbarMode = ScrollbarAlwaysOn; |
| } |
| ScrollbarMode verticalScrollbarMode = ScrollbarAlwaysOff; |
| if (newSize.height() > m_maxAutoSize.height()) { |
| newSize.setHeight(m_maxAutoSize.height()); |
| verticalScrollbarMode = ScrollbarAlwaysOn; |
| } |
| |
| if (newSize == size) |
| continue; |
| |
| // While loading only allow the size to increase (to avoid twitching during intermediate smaller states) |
| // unless autoresize has just been turned on or the maximum size is smaller than the current size. |
| if (m_didRunAutosize && size.height() <= m_maxAutoSize.height() && size.width() <= m_maxAutoSize.width() |
| && !m_frame->document()->loadEventFinished() && (newSize.height() < size.height() || newSize.width() < size.width())) |
| break; |
| |
| resize(newSize.width(), newSize.height()); |
| // Force the scrollbar state to avoid the scrollbar code adding them and causing them to be needed. For example, |
| // a vertical scrollbar may cause text to wrap and thus increase the height (which is the only reason the scollbar is needed). |
| setVerticalScrollbarLock(false); |
| setHorizontalScrollbarLock(false); |
| setScrollbarModes(horizonalScrollbarMode, verticalScrollbarMode, true, true); |
| } |
| m_didRunAutosize = true; |
| } |
| |
| void FrameView::updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow) |
| { |
| if (!m_viewportRenderer) |
| return; |
| |
| if (m_overflowStatusDirty) { |
| m_horizontalOverflow = horizontalOverflow; |
| m_verticalOverflow = verticalOverflow; |
| m_overflowStatusDirty = false; |
| return; |
| } |
| |
| bool horizontalOverflowChanged = (m_horizontalOverflow != horizontalOverflow); |
| bool verticalOverflowChanged = (m_verticalOverflow != verticalOverflow); |
| |
| if (horizontalOverflowChanged || verticalOverflowChanged) { |
| m_horizontalOverflow = horizontalOverflow; |
| m_verticalOverflow = verticalOverflow; |
| |
| RefPtrWillBeRawPtr<OverflowEvent> event = OverflowEvent::create(horizontalOverflowChanged, horizontalOverflow, verticalOverflowChanged, verticalOverflow); |
| event->setTarget(m_viewportRenderer->node()); |
| m_frame->document()->enqueueAnimationFrameEvent(event.release()); |
| } |
| |
| } |
| |
| IntRect FrameView::windowClipRect(IncludeScrollbarsInRect scrollbarInclusion) const |
| { |
| ASSERT(m_frame->view() == this); |
| |
| if (paintsEntireContents()) |
| return IntRect(IntPoint(), contentsSize()); |
| |
| // Set our clip rect to be our contents. |
| IntRect clipRect = contentsToWindow(visibleContentRect(scrollbarInclusion)); |
| if (!m_frame->deprecatedLocalOwner()) |
| return clipRect; |
| |
| // Take our owner element and get its clip rect. |
| // FIXME: Do we need to do this for remote frames? |
| HTMLFrameOwnerElement* ownerElement = m_frame->deprecatedLocalOwner(); |
| FrameView* parentView = ownerElement->document().view(); |
| if (parentView) |
| clipRect.intersect(parentView->windowClipRectForFrameOwner(ownerElement)); |
| return clipRect; |
| } |
| |
| IntRect FrameView::windowClipRectForFrameOwner(const HTMLFrameOwnerElement* ownerElement) const |
| { |
| // The renderer can sometimes be null when style="display:none" interacts |
| // with external content and plugins. |
| if (!ownerElement->renderer()) |
| return windowClipRect(); |
| |
| // If we have no layer, just return our window clip rect. |
| const RenderLayer* enclosingLayer = ownerElement->renderer()->enclosingLayer(); |
| if (!enclosingLayer) |
| return windowClipRect(); |
| |
| // FIXME: childrenClipRect relies on compositingState, which is not necessarily up to date. |
| // https://code.google.com/p/chromium/issues/detail?id=343769 |
| DisableCompositingQueryAsserts disabler; |
| |
| // Apply the clip from the layer. |
| IntRect clipRect = contentsToWindow(pixelSnappedIntRect(enclosingLayer->clipper().childrenClipRect())); |
| return intersection(clipRect, windowClipRect()); |
| } |
| |
| bool FrameView::isActive() const |
| { |
| Page* page = frame().page(); |
| return page && page->focusController().isActive(); |
| } |
| |
| void FrameView::scrollTo(const IntSize& newOffset) |
| { |
| LayoutSize offset = scrollOffset(); |
| ScrollView::scrollTo(newOffset); |
| if (offset != scrollOffset()) { |
| updateLayersAndCompositingAfterScrollIfNeeded(); |
| scrollPositionChanged(); |
| } |
| frame().loader().client()->didChangeScrollOffset(); |
| } |
| |
| void FrameView::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect) |
| { |
| // Add in our offset within the FrameView. |
| IntRect dirtyRect = rect; |
| dirtyRect.moveBy(scrollbar->location()); |
| |
| if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled() && isInPerformLayout()) { |
| if (scrollbar == verticalScrollbar()) { |
| m_verticalBarDamage = dirtyRect; |
| m_hasVerticalBarDamage = true; |
| } else { |
| m_horizontalBarDamage = dirtyRect; |
| m_hasHorizontalBarDamage = true; |
| } |
| } else { |
| invalidateRect(dirtyRect); |
| } |
| } |
| |
| void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const |
| { |
| if (!m_tickmarks.isEmpty()) |
| tickmarks = m_tickmarks; |
| else |
| tickmarks = frame().document()->markers().renderedRectsForMarkers(DocumentMarker::TextMatch); |
| } |
| |
| IntRect FrameView::windowResizerRect() const |
| { |
| Page* page = frame().page(); |
| if (!page) |
| return IntRect(); |
| return page->chrome().windowResizerRect(); |
| } |
| |
| void FrameView::setVisibleContentScaleFactor(float visibleContentScaleFactor) |
| { |
| if (m_visibleContentScaleFactor == visibleContentScaleFactor) |
| return; |
| |
| m_visibleContentScaleFactor = visibleContentScaleFactor; |
| updateScrollbars(scrollOffset()); |
| } |
| |
| void FrameView::setInputEventsTransformForEmulation(const IntSize& offset, float contentScaleFactor) |
| { |
| m_inputEventsOffsetForEmulation = offset; |
| m_inputEventsScaleFactorForEmulation = contentScaleFactor; |
| } |
| |
| IntSize FrameView::inputEventsOffsetForEmulation() const |
| { |
| return m_inputEventsOffsetForEmulation; |
| } |
| |
| float FrameView::inputEventsScaleFactor() const |
| { |
| float pageScale = m_frame->settings()->pinchVirtualViewportEnabled() |
| ? m_frame->page()->frameHost().pinchViewport().scale() |
| : visibleContentScaleFactor(); |
| return pageScale * m_inputEventsScaleFactorForEmulation; |
| } |
| |
| bool FrameView::scrollbarsCanBeActive() const |
| { |
| if (m_frame->view() != this) |
| return false; |
| |
| return !!m_frame->document(); |
| } |
| |
| IntRect FrameView::scrollableAreaBoundingBox() const |
| { |
| RenderPart* ownerRenderer = frame().ownerRenderer(); |
| if (!ownerRenderer) |
| return frameRect(); |
| |
| return ownerRenderer->absoluteContentQuad().enclosingBoundingBox(); |
| } |
| |
| bool FrameView::isScrollable() |
| { |
| // Check for: |
| // 1) If there an actual overflow. |
| // 2) display:none or visibility:hidden set to self or inherited. |
| // 3) overflow{-x,-y}: hidden; |
| // 4) scrolling: no; |
| |
| // Covers #1 |
| IntSize contentsSize = this->contentsSize(); |
| IntSize visibleContentSize = visibleContentRect().size(); |
| if ((contentsSize.height() <= visibleContentSize.height() && contentsSize.width() <= visibleContentSize.width())) |
| return false; |
| |
| // Covers #2. |
| // FIXME: Do we need to fix this for OOPI? |
| HTMLFrameOwnerElement* owner = m_frame->deprecatedLocalOwner(); |
| if (owner && (!owner->renderer() || !owner->renderer()->visibleToHitTesting())) |
| return false; |
| |
| // Cover #3 and #4. |
| ScrollbarMode horizontalMode; |
| ScrollbarMode verticalMode; |
| calculateScrollbarModesForLayoutAndSetViewportRenderer(horizontalMode, verticalMode, RulesFromWebContentOnly); |
| if (horizontalMode == ScrollbarAlwaysOff && verticalMode == ScrollbarAlwaysOff) |
| return false; |
| |
| return true; |
| } |
| |
| void FrameView::updateScrollableAreaSet() |
| { |
| // That ensures that only inner frames are cached. |
| FrameView* parentFrameView = this->parentFrameView(); |
| if (!parentFrameView) |
| return; |
| |
| if (!isScrollable()) { |
| parentFrameView->removeScrollableArea(this); |
| return; |
| } |
| |
| parentFrameView->addScrollableArea(this); |
| } |
| |
| bool FrameView::shouldSuspendScrollAnimations() const |
| { |
| return m_frame->loader().state() != FrameStateComplete; |
| } |
| |
| void FrameView::scrollbarStyleChanged() |
| { |
| // FIXME: Why does this only apply to the main frame? |
| if (!m_frame->isMainFrame()) |
| return; |
| ScrollView::scrollbarStyleChanged(); |
| } |
| |
| void FrameView::notifyPageThatContentAreaWillPaint() const |
| { |
| Page* page = m_frame->page(); |
| if (!page) |
| return; |
| |
| contentAreaWillPaint(); |
| |
| if (!m_scrollableAreas) |
| return; |
| |
| for (HashSet<ScrollableArea*>::const_iterator it = m_scrollableAreas->begin(), end = m_scrollableAreas->end(); it != end; ++it) { |
| ScrollableArea* scrollableArea = *it; |
| |
| if (!scrollableArea->scrollbarsCanBeActive()) |
| continue; |
| |
| scrollableArea->contentAreaWillPaint(); |
| } |
| } |
| |
| bool FrameView::scrollAnimatorEnabled() const |
| { |
| return m_frame->settings() && m_frame->settings()->scrollAnimatorEnabled(); |
| } |
| |
| void FrameView::updateAnnotatedRegions() |
| { |
| Document* document = m_frame->document(); |
| if (!document->hasAnnotatedRegions()) |
| return; |
| Vector<AnnotatedRegionValue> newRegions; |
| document->renderBox()->collectAnnotatedRegions(newRegions); |
| if (newRegions == document->annotatedRegions()) |
| return; |
| document->setAnnotatedRegions(newRegions); |
| if (Page* page = m_frame->page()) |
| page->chrome().client().annotatedRegionsChanged(); |
| } |
| |
| void FrameView::updateScrollCorner() |
| { |
| RefPtr<RenderStyle> cornerStyle; |
| IntRect cornerRect = scrollCornerRect(); |
| Document* doc = m_frame->document(); |
| |
| if (doc && !cornerRect.isEmpty()) { |
| // Try the <body> element first as a scroll corner source. |
| if (Element* body = doc->body()) { |
| if (RenderObject* renderer = body->renderer()) |
| cornerStyle = renderer->getUncachedPseudoStyle(PseudoStyleRequest(SCROLLBAR_CORNER), renderer->style()); |
| } |
| |
| if (!cornerStyle) { |
| // If the <body> didn't have a custom style, then the root element might. |
| if (Element* docElement = doc->documentElement()) { |
| if (RenderObject* renderer = docElement->renderer()) |
| cornerStyle = renderer->getUncachedPseudoStyle(PseudoStyleRequest(SCROLLBAR_CORNER), renderer->style()); |
| } |
| } |
| |
| if (!cornerStyle) { |
| // If we have an owning ipage/LocalFrame element, then it can set the custom scrollbar also. |
| if (RenderPart* renderer = m_frame->ownerRenderer()) |
| cornerStyle = renderer->getUncachedPseudoStyle(PseudoStyleRequest(SCROLLBAR_CORNER), renderer->style()); |
| } |
| } |
| |
| if (cornerStyle) { |
| if (!m_scrollCorner) |
| m_scrollCorner = RenderScrollbarPart::createAnonymous(doc); |
| m_scrollCorner->setStyle(cornerStyle.release()); |
| invalidateScrollCorner(cornerRect); |
| } else if (m_scrollCorner) { |
| m_scrollCorner->destroy(); |
| m_scrollCorner = 0; |
| } |
| |
| ScrollView::updateScrollCorner(); |
| } |
| |
| void FrameView::paintScrollCorner(GraphicsContext* context, const IntRect& cornerRect) |
| { |
| if (context->updatingControlTints()) { |
| updateScrollCorner(); |
| return; |
| } |
| |
| if (m_scrollCorner) { |
| bool needsBackgorund = m_frame->isMainFrame(); |
| if (needsBackgorund) |
| context->fillRect(cornerRect, baseBackgroundColor()); |
| m_scrollCorner->paintIntoRect(context, cornerRect.location(), cornerRect); |
| return; |
| } |
| |
| ScrollView::paintScrollCorner(context, cornerRect); |
| } |
| |
| void FrameView::paintScrollbar(GraphicsContext* context, Scrollbar* bar, const IntRect& rect) |
| { |
| bool needsBackgorund = bar->isCustomScrollbar() && m_frame->isMainFrame(); |
| if (needsBackgorund) { |
| IntRect toFill = bar->frameRect(); |
| toFill.intersect(rect); |
| context->fillRect(toFill, baseBackgroundColor()); |
| } |
| |
| ScrollView::paintScrollbar(context, bar, rect); |
| } |
| |
| Color FrameView::documentBackgroundColor() const |
| { |
| // <https://bugs.webkit.org/show_bug.cgi?id=59540> We blend the background color of |
| // the document and the body against the base background color of the frame view. |
| // Background images are unfortunately impractical to include. |
| |
| Color result = baseBackgroundColor(); |
| if (!frame().document()) |
| return result; |
| |
| Element* htmlElement = frame().document()->documentElement(); |
| Element* bodyElement = frame().document()->body(); |
| |
| // We take the aggregate of the base background color |
| // the <html> background color, and the <body> |
| // background color to find the document color. The |
| // addition of the base background color is not |
| // technically part of the document background, but it |
| // otherwise poses problems when the aggregate is not |
| // fully opaque. |
| if (htmlElement && htmlElement->renderer()) |
| result = result.blend(htmlElement->renderer()->style()->visitedDependentColor(CSSPropertyBackgroundColor)); |
| if (bodyElement && bodyElement->renderer()) |
| result = result.blend(bodyElement->renderer()->style()->visitedDependentColor(CSSPropertyBackgroundColor)); |
| |
| return result; |
| } |
| |
| bool FrameView::hasCustomScrollbars() const |
| { |
| const HashSet<RefPtr<Widget> >* viewChildren = children(); |
| HashSet<RefPtr<Widget> >::const_iterator end = viewChildren->end(); |
| for (HashSet<RefPtr<Widget> >::const_iterator current = viewChildren->begin(); current != end; ++current) { |
| Widget* widget = current->get(); |
| if (widget->isFrameView()) { |
| if (toFrameView(widget)->hasCustomScrollbars()) |
| return true; |
| } else if (widget->isScrollbar()) { |
| Scrollbar* scrollbar = static_cast<Scrollbar*>(widget); |
| if (scrollbar->isCustomScrollbar()) |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| FrameView* FrameView::parentFrameView() const |
| { |
| if (!parent()) |
| return 0; |
| |
| Frame* parentFrame = m_frame->tree().parent(); |
| if (parentFrame && parentFrame->isLocalFrame()) |
| return toLocalFrame(parentFrame)->view(); |
| |
| return 0; |
| } |
| |
| void FrameView::updateControlTints() |
| { |
| // This is called when control tints are changed from aqua/graphite to clear and vice versa. |
| // We do a "fake" paint, and when the theme gets a paint call, it can then do an invalidate. |
| // This is only done if the theme supports control tinting. It's up to the theme and platform |
| // to define when controls get the tint and to call this function when that changes. |
| |
| // Optimize the common case where we bring a window to the front while it's still empty. |
| if (m_frame->document()->url().isEmpty()) |
| return; |
| |
| // FIXME: We shouldn't rely on the paint code to implement :window-inactive on custom scrollbars. |
| if (!RenderTheme::theme().supportsControlTints() && !hasCustomScrollbars()) |
| return; |
| |
| // Updating layout can run script, which can tear down the FrameView. |
| RefPtr<FrameView> protector(this); |
| updateLayoutAndStyleForPainting(); |
| |
| // FIXME: The use of paint seems like overkill: crbug.com/236892 |
| GraphicsContext context(0); // NULL canvas to get a non-painting context. |
| context.setUpdatingControlTints(true); |
| paint(&context, frameRect()); |
| } |
| |
| bool FrameView::wasScrolledByUser() const |
| { |
| return m_wasScrolledByUser; |
| } |
| |
| void FrameView::setWasScrolledByUser(bool wasScrolledByUser) |
| { |
| if (m_inProgrammaticScroll) |
| return; |
| m_maintainScrollPositionAnchor = nullptr; |
| m_wasScrolledByUser = wasScrolledByUser; |
| } |
| |
| void FrameView::paintContents(GraphicsContext* p, const IntRect& rect) |
| { |
| Document* document = m_frame->document(); |
| |
| #ifndef NDEBUG |
| bool fillWithRed; |
| if (document->printing()) |
| fillWithRed = false; // Printing, don't fill with red (can't remember why). |
| else if (m_frame->owner()) |
| fillWithRed = false; // Subframe, don't fill with red. |
| else if (isTransparent()) |
| fillWithRed = false; // Transparent, don't fill with red. |
| else if (m_paintBehavior & PaintBehaviorSelectionOnly) |
| fillWithRed = false; // Selections are transparent, don't fill with red. |
| else if (m_nodeToDraw) |
| fillWithRed = false; // Element images are transparent, don't fill with red. |
| else |
| fillWithRed = true; |
| |
| if (fillWithRed) |
| p->fillRect(rect, Color(0xFF, 0, 0)); |
| #endif |
| |
| RenderView* renderView = this->renderView(); |
| if (!renderView) { |
| WTF_LOG_ERROR("called FrameView::paint with nil renderer"); |
| return; |
| } |
| |
| ASSERT(!needsLayout()); |
| if (needsLayout()) |
| return; |
| |
| TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Paint", "data", InspectorPaintEvent::data(renderView, rect, 0)); |
| TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"), "CallStack", "stack", InspectorCallStackEvent::currentCallStack()); |
| // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing. |
| InspectorInstrumentation::willPaint(renderView, 0); |
| |
| bool isTopLevelPainter = !s_inPaintContents; |
| s_inPaintContents = true; |
| |
| FontCachePurgePreventer fontCachePurgePreventer; |
| |
| PaintBehavior oldPaintBehavior = m_paintBehavior; |
| |
| if (FrameView* parentView = parentFrameView()) { |
| if (parentView->paintBehavior() & PaintBehaviorFlattenCompositingLayers) |
| m_paintBehavior |= PaintBehaviorFlattenCompositingLayers; |
| } |
| |
| if (m_paintBehavior == PaintBehaviorNormal) |
| document->markers().invalidateRenderedRectsForMarkersInRect(rect); |
| |
| if (document->printing()) |
| m_paintBehavior |= PaintBehaviorFlattenCompositingLayers; |
| |
| ASSERT(!m_isPainting); |
| m_isPainting = true; |
| |
| // m_nodeToDraw is used to draw only one element (and its descendants) |
| RenderObject* renderer = m_nodeToDraw ? m_nodeToDraw->renderer() : 0; |
| RenderLayer* rootLayer = renderView->layer(); |
| |
| #ifndef NDEBUG |
| renderView->assertSubtreeIsLaidOut(); |
| RenderObject::SetLayoutNeededForbiddenScope forbidSetNeedsLayout(*rootLayer->renderer()); |
| #endif |
| |
| rootLayer->paint(p, rect, m_paintBehavior, renderer); |
| |
| if (rootLayer->containsDirtyOverlayScrollbars()) |
| rootLayer->paintOverlayScrollbars(p, rect, m_paintBehavior, renderer); |
| |
| m_isPainting = false; |
| |
| m_paintBehavior = oldPaintBehavior; |
| m_lastPaintTime = currentTime(); |
| |
| // Regions may have changed as a result of the visibility/z-index of element changing. |
| if (document->annotatedRegionsDirty()) |
| updateAnnotatedRegions(); |
| |
| if (isTopLevelPainter) { |
| // Everythin that happens after paintContents completions is considered |
| // to be part of the next frame. |
| s_currentFrameTimeStamp = currentTime(); |
| s_inPaintContents = false; |
| } |
| |
| InspectorInstrumentation::didPaint(renderView, 0, p, rect); |
| } |
| |
| void FrameView::setPaintBehavior(PaintBehavior behavior) |
| { |
| m_paintBehavior = behavior; |
| } |
| |
| PaintBehavior FrameView::paintBehavior() const |
| { |
| return m_paintBehavior; |
| } |
| |
| bool FrameView::isPainting() const |
| { |
| return m_isPainting; |
| } |
| |
| void FrameView::setNodeToDraw(Node* node) |
| { |
| m_nodeToDraw = node; |
| } |
| |
| void FrameView::paintOverhangAreas(GraphicsContext* context, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect) |
| { |
| if (context->paintingDisabled()) |
| return; |
| |
| if (m_frame->document()->printing()) |
| return; |
| |
| if (m_frame->isMainFrame()) { |
| if (m_frame->page()->chrome().client().paintCustomOverhangArea(context, horizontalOverhangArea, verticalOverhangArea, dirtyRect)) |
| return; |
| } |
| |
| ScrollView::paintOverhangAreas(context, horizontalOverhangArea, verticalOverhangArea, dirtyRect); |
| } |
| |
| void FrameView::updateLayoutAndStyleForPainting() |
| { |
| // Updating layout can run script, which can tear down the FrameView. |
| RefPtr<FrameView> protector(this); |
| |
| updateLayoutAndStyleIfNeededRecursive(); |
| |
| if (RenderView* view = renderView()) { |
| InspectorInstrumentation::willUpdateLayerTree(view->frame()); |
| |
| view->compositor()->updateIfNeededRecursive(); |
| |
| if (view->compositor()->inCompositingMode() && m_frame->isMainFrame()) |
| m_frame->page()->scrollingCoordinator()->updateAfterCompositingChangeIfNeeded(); |
| |
| InspectorInstrumentation::didUpdateLayerTree(view->frame()); |
| } |
| |
| scrollContentsIfNeededRecursive(); |
| } |
| |
| void FrameView::updateLayoutAndStyleIfNeededRecursive() |
| { |
| // We have to crawl our entire tree looking for any FrameViews that need |
| // layout and make sure they are up to date. |
| // Mac actually tests for intersection with the dirty region and tries not to |
| // update layout for frames that are outside the dirty region. Not only does this seem |
| // pointless (since those frames will have set a zero timer to layout anyway), but |
| // it is also incorrect, since if two frames overlap, the first could be excluded from the dirty |
| // region but then become included later by the second frame adding rects to the dirty region |
| // when it lays out. |
| |
| m_frame->document()->updateRenderTreeIfNeeded(); |
| |
| if (needsLayout()) |
| layout(); |
| |
| // FIXME: Calling layout() shouldn't trigger scripe execution or have any |
| // observable effects on the frame tree but we're not quite there yet. |
| Vector<RefPtr<FrameView> > frameViews; |
| for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) { |
| if (!child->isLocalFrame()) |
| continue; |
| if (FrameView* view = toLocalFrame(child)->view()) |
| frameViews.append(view); |
| } |
| |
| const Vector<RefPtr<FrameView> >::iterator end = frameViews.end(); |
| for (Vector<RefPtr<FrameView> >::iterator it = frameViews.begin(); it != end; ++it) |
| (*it)->updateLayoutAndStyleIfNeededRecursive(); |
| |
| // When an <iframe> gets composited, it triggers an extra style recalc in its containing FrameView. |
| // To avoid pushing an invalid tree for display, we have to check for this case and do another |
| // style recalc. The extra style recalc needs to happen after our child <iframes> were updated. |
| // FIXME: We shouldn't be triggering an extra style recalc in the first place. |
| if (m_frame->document()->hasSVGFilterElementsRequiringLayerUpdate()) { |
| m_frame->document()->updateRenderTreeIfNeeded(); |
| |
| if (needsLayout()) |
| layout(); |
| } |
| |
| // These asserts ensure that parent frames are clean, when child frames finished updating layout and style. |
| ASSERT(!needsLayout()); |
| ASSERT(!m_frame->document()->hasSVGFilterElementsRequiringLayerUpdate()); |
| #ifndef NDEBUG |
| m_frame->document()->renderView()->assertRendererLaidOut(); |
| #endif |
| |
| } |
| |
| void FrameView::enableAutoSizeMode(bool enable, const IntSize& minSize, const IntSize& maxSize) |
| { |
| ASSERT(!enable || !minSize.isEmpty()); |
| ASSERT(minSize.width() <= maxSize.width()); |
| ASSERT(minSize.height() <= maxSize.height()); |
| |
| if (m_shouldAutoSize == enable && m_minAutoSize == minSize && m_maxAutoSize == maxSize) |
| return; |
| |
| |
| m_shouldAutoSize = enable; |
| m_minAutoSize = minSize; |
| m_maxAutoSize = maxSize; |
| m_didRunAutosize = false; |
| |
| setLayoutSizeFixedToFrameSize(enable); |
| setNeedsLayout(); |
| scheduleRelayout(); |
| if (m_shouldAutoSize) |
| return; |
| |
| // Since autosize mode forces the scrollbar mode, change them to being auto. |
| setVerticalScrollbarLock(false); |
| setHorizontalScrollbarLock(false); |
| setScrollbarModes(ScrollbarAuto, ScrollbarAuto); |
| } |
| |
| void FrameView::forceLayout(bool allowSubtree) |
| { |
| layout(allowSubtree); |
| } |
| |
| void FrameView::forceLayoutForPagination(const FloatSize& pageSize, const FloatSize& originalPageSize, float maximumShrinkFactor) |
| { |
| // Dumping externalRepresentation(m_frame->renderer()).ascii() is a good trick to see |
| // the state of things before and after the layout |
| if (RenderView* renderView = this->renderView()) { |
| float pageLogicalWidth = renderView->style()->isHorizontalWritingMode() ? pageSize.width() : pageSize.height(); |
| float pageLogicalHeight = renderView->style()->isHorizontalWritingMode() ? pageSize.height() : pageSize.width(); |
| |
| LayoutUnit flooredPageLogicalWidth = static_cast<LayoutUnit>(pageLogicalWidth); |
| LayoutUnit flooredPageLogicalHeight = static_cast<LayoutUnit>(pageLogicalHeight); |
| renderView->setLogicalWidth(flooredPageLogicalWidth); |
| renderView->setPageLogicalHeight(flooredPageLogicalHeight); |
| renderView->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(); |
| forceLayout(); |
| |
| // If we don't fit in the given page width, we'll lay out again. If we don't fit in the |
| // page width when shrunk, we will lay out at maximum shrink and clip extra content. |
| // FIXME: We are assuming a shrink-to-fit printing implementation. A cropping |
| // implementation should not do this! |
| bool horizontalWritingMode = renderView->style()->isHorizontalWritingMode(); |
| const LayoutRect& documentRect = renderView->documentRect(); |
| LayoutUnit docLogicalWidth = horizontalWritingMode ? documentRect.width() : documentRect.height(); |
| if (docLogicalWidth > pageLogicalWidth) { |
| FloatSize expectedPageSize(std::min<float>(documentRect.width().toFloat(), pageSize.width() * maximumShrinkFactor), std::min<float>(documentRect.height().toFloat(), pageSize.height() * maximumShrinkFactor)); |
| FloatSize maxPageSize = m_frame->resizePageRectsKeepingRatio(FloatSize(originalPageSize.width(), originalPageSize.height()), expectedPageSize); |
| pageLogicalWidth = horizontalWritingMode ? maxPageSize.width() : maxPageSize.height(); |
| pageLogicalHeight = horizontalWritingMode ? maxPageSize.height() : maxPageSize.width(); |
| |
| flooredPageLogicalWidth = static_cast<LayoutUnit>(pageLogicalWidth); |
| flooredPageLogicalHeight = static_cast<LayoutUnit>(pageLogicalHeight); |
| renderView->setLogicalWidth(flooredPageLogicalWidth); |
| renderView->setPageLogicalHeight(flooredPageLogicalHeight); |
| renderView->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(); |
| forceLayout(); |
| |
| const LayoutRect& updatedDocumentRect = renderView->documentRect(); |
| LayoutUnit docLogicalHeight = horizontalWritingMode ? updatedDocumentRect.height() : updatedDocumentRect.width(); |
| LayoutUnit docLogicalTop = horizontalWritingMode ? updatedDocumentRect.y() : updatedDocumentRect.x(); |
| LayoutUnit docLogicalRight = horizontalWritingMode ? updatedDocumentRect.maxX() : updatedDocumentRect.maxY(); |
| LayoutUnit clippedLogicalLeft = 0; |
| if (!renderView->style()->isLeftToRightDirection()) |
| clippedLogicalLeft = docLogicalRight - pageLogicalWidth; |
| LayoutRect overflow(clippedLogicalLeft, docLogicalTop, pageLogicalWidth, docLogicalHeight); |
| |
| if (!horizontalWritingMode) |
| overflow = overflow.transposedRect(); |
| renderView->clearLayoutOverflow(); |
| renderView->addLayoutOverflow(overflow); // This is how we clip in case we overflow again. |
| } |
| } |
| |
| adjustViewSize(); |
| } |
| |
| IntRect FrameView::convertFromRenderer(const RenderObject& renderer, const IntRect& rendererRect) const |
| { |
| IntRect rect = pixelSnappedIntRect(enclosingLayoutRect(renderer.localToAbsoluteQuad(FloatRect(rendererRect)).boundingBox())); |
| |
| // Convert from page ("absolute") to FrameView coordinates. |
| rect.moveBy(-scrollPosition()); |
| |
| return rect; |
| } |
| |
| IntRect FrameView::convertToRenderer(const RenderObject& renderer, const IntRect& viewRect) const |
| { |
| IntRect rect = viewRect; |
| |
| // Convert from FrameView coords into page ("absolute") coordinates. |
| rect.moveBy(scrollPosition()); |
| |
| // FIXME: we don't have a way to map an absolute rect down to a local quad, so just |
| // move the rect for now. |
| rect.setLocation(roundedIntPoint(renderer.absoluteToLocal(rect.location(), UseTransforms))); |
| return rect; |
| } |
| |
| IntPoint FrameView::convertFromRenderer(const RenderObject& renderer, const IntPoint& rendererPoint) const |
| { |
| IntPoint point = roundedIntPoint(renderer.localToAbsolute(rendererPoint, UseTransforms)); |
| |
| // Convert from page ("absolute") to FrameView coordinates. |
| point.moveBy(-scrollPosition()); |
| return point; |
| } |
| |
| IntPoint FrameView::convertToRenderer(const RenderObject& renderer, const IntPoint& viewPoint) const |
| { |
| IntPoint point = viewPoint; |
| |
| // Convert from FrameView coords into page ("absolute") coordinates. |
| point += IntSize(scrollX(), scrollY()); |
| |
| return roundedIntPoint(renderer.absoluteToLocal(point, UseTransforms)); |
| } |
| |
| IntRect FrameView::convertToContainingView(const IntRect& localRect) const |
| { |
| if (const ScrollView* parentScrollView = toScrollView(parent())) { |
| if (parentScrollView->isFrameView()) { |
| const FrameView* parentView = toFrameView(parentScrollView); |
| // Get our renderer in the parent view |
| RenderPart* renderer = m_frame->ownerRenderer(); |
| if (!renderer) |
| return localRect; |
| |
| IntRect rect(localRect); |
| // Add borders and padding?? |
| rect.move(renderer->borderLeft() + renderer->paddingLeft(), |
| renderer->borderTop() + renderer->paddingTop()); |
| return parentView->convertFromRenderer(*renderer, rect); |
| } |
| |
| return Widget::convertToContainingView(localRect); |
| } |
| |
| return localRect; |
| } |
| |
| IntRect FrameView::convertFromContainingView(const IntRect& parentRect) const |
| { |
| if (const ScrollView* parentScrollView = toScrollView(parent())) { |
| if (parentScrollView->isFrameView()) { |
| const FrameView* parentView = toFrameView(parentScrollView); |
| |
| // Get our renderer in the parent view |
| RenderPart* renderer = m_frame->ownerRenderer(); |
| if (!renderer) |
| return parentRect; |
| |
| IntRect rect = parentView->convertToRenderer(*renderer, parentRect); |
| // Subtract borders and padding |
| rect.move(-renderer->borderLeft() - renderer->paddingLeft(), |
| -renderer->borderTop() - renderer->paddingTop()); |
| return rect; |
| } |
| |
| return Widget::convertFromContainingView(parentRect); |
| } |
| |
| return parentRect; |
| } |
| |
| IntPoint FrameView::convertToContainingView(const IntPoint& localPoint) const |
| { |
| if (const ScrollView* parentScrollView = toScrollView(parent())) { |
| if (parentScrollView->isFrameView()) { |
| const FrameView* parentView = toFrameView(parentScrollView); |
| |
| // Get our renderer in the parent view |
| RenderPart* renderer = m_frame->ownerRenderer(); |
| if (!renderer) |
| return localPoint; |
| |
| IntPoint point(localPoint); |
| |
| // Add borders and padding |
| point.move(renderer->borderLeft() + renderer->paddingLeft(), |
| renderer->borderTop() + renderer->paddingTop()); |
| return parentView->convertFromRenderer(*renderer, point); |
| } |
| |
| return Widget::convertToContainingView(localPoint); |
| } |
| |
| return localPoint; |
| } |
| |
| IntPoint FrameView::convertFromContainingView(const IntPoint& parentPoint) const |
| { |
| if (const ScrollView* parentScrollView = toScrollView(parent())) { |
| if (parentScrollView->isFrameView()) { |
| const FrameView* parentView = toFrameView(parentScrollView); |
| |
| // Get our renderer in the parent view |
| RenderPart* renderer = m_frame->ownerRenderer(); |
| if (!renderer) |
| return parentPoint; |
| |
| IntPoint point = parentView->convertToRenderer(*renderer, parentPoint); |
| // Subtract borders and padding |
| point.move(-renderer->borderLeft() - renderer->paddingLeft(), |
| -renderer->borderTop() - renderer->paddingTop()); |
| return point; |
| } |
| |
| return Widget::convertFromContainingView(parentPoint); |
| } |
| |
| return parentPoint; |
| } |
| |
| void FrameView::setTracksPaintInvalidations(bool trackPaintInvalidations) |
| { |
| if (trackPaintInvalidations == m_isTrackingPaintInvalidations) |
| return; |
| |
| for (Frame* frame = m_frame->tree().top(); frame; frame = frame->tree().traverseNext()) { |
| if (!frame->isLocalFrame()) |
| continue; |
| if (RenderView* renderView = toLocalFrame(frame)->contentRenderer()) |
| renderView->compositor()->setTracksRepaints(trackPaintInvalidations); |
| } |
| |
| TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), |
| "FrameView::setTracksPaintInvalidations", "enabled", trackPaintInvalidations); |
| |
| resetTrackedPaintInvalidations(); |
| m_isTrackingPaintInvalidations = trackPaintInvalidations; |
| } |
| |
| void FrameView::resetTrackedPaintInvalidations() |
| { |
| m_trackedPaintInvalidationRects.clear(); |
| if (RenderView* renderView = this->renderView()) |
| renderView->compositor()->resetTrackedRepaintRects(); |
| } |
| |
| String FrameView::trackedPaintInvalidationRectsAsText() const |
| { |
| TextStream ts; |
| if (!m_trackedPaintInvalidationRects.isEmpty()) { |
| ts << "(repaint rects\n"; |
| for (size_t i = 0; i < m_trackedPaintInvalidationRects.size(); ++i) |
| ts << " (rect " << m_trackedPaintInvalidationRects[i].x() << " " << m_trackedPaintInvalidationRects[i].y() << " " << m_trackedPaintInvalidationRects[i].width() << " " << m_trackedPaintInvalidationRects[i].height() << ")\n"; |
| ts << ")\n"; |
| } |
| return ts.release(); |
| } |
| |
| void FrameView::addResizerArea(RenderBox& resizerBox) |
| { |
| if (!m_resizerAreas) |
| m_resizerAreas = adoptPtr(new ResizerAreaSet); |
| m_resizerAreas->add(&resizerBox); |
| } |
| |
| void FrameView::removeResizerArea(RenderBox& resizerBox) |
| { |
| if (!m_resizerAreas) |
| return; |
| |
| ResizerAreaSet::iterator it = m_resizerAreas->find(&resizerBox); |
| if (it != m_resizerAreas->end()) |
| m_resizerAreas->remove(it); |
| } |
| |
| void FrameView::addScrollableArea(ScrollableArea* scrollableArea) |
| { |
| ASSERT(scrollableArea); |
| if (!m_scrollableAreas) |
| m_scrollableAreas = adoptPtr(new ScrollableAreaSet); |
| m_scrollableAreas->add(scrollableArea); |
| } |
| |
| void FrameView::removeScrollableArea(ScrollableArea* scrollableArea) |
| { |
| if (!m_scrollableAreas) |
| return; |
| m_scrollableAreas->remove(scrollableArea); |
| } |
| |
| void FrameView::removeChild(Widget* widget) |
| { |
| if (widget->isFrameView()) |
| removeScrollableArea(toFrameView(widget)); |
| |
| ScrollView::removeChild(widget); |
| } |
| |
| bool FrameView::wheelEvent(const PlatformWheelEvent& wheelEvent) |
| { |
| bool allowScrolling = userInputScrollable(HorizontalScrollbar) || userInputScrollable(VerticalScrollbar); |
| |
| // Note that to allow for rubber-band over-scroll behavior, even non-scrollable views |
| // should handle wheel events. |
| #if !USE(RUBBER_BANDING) |
| if (!isScrollable()) |
| allowScrolling = false; |
| #endif |
| |
| if (allowScrolling && ScrollableArea::handleWheelEvent(wheelEvent)) |
| return true; |
| |
| // If the frame didn't handle the event, give the pinch-zoom viewport a chance to |
| // process the scroll event. |
| if (m_frame->settings()->pinchVirtualViewportEnabled() && m_frame->isMainFrame()) |
| return page()->frameHost().pinchViewport().handleWheelEvent(wheelEvent); |
| |
| return false; |
| } |
| |
| bool FrameView::isVerticalDocument() const |
| { |
| RenderView* renderView = this->renderView(); |
| if (!renderView) |
| return true; |
| |
| return renderView->style()->isHorizontalWritingMode(); |
| } |
| |
| bool FrameView::isFlippedDocument() const |
| { |
| RenderView* renderView = this->renderView(); |
| if (!renderView) |
| return false; |
| |
| return renderView->style()->isFlippedBlocksWritingMode(); |
| } |
| |
| AXObjectCache* FrameView::axObjectCache() const |
| { |
| if (frame().document()) |
| return frame().document()->existingAXObjectCache(); |
| return 0; |
| } |
| |
| void FrameView::setCursor(const Cursor& cursor) |
| { |
| Page* page = frame().page(); |
| if (!page || !page->settings().deviceSupportsMouse()) |
| return; |
| page->chrome().setCursor(cursor); |
| } |
| |
| void FrameView::frameRectsChanged() |
| { |
| if (layoutSizeFixedToFrameSize()) |
| setLayoutSizeInternal(frameRect().size()); |
| |
| ScrollView::frameRectsChanged(); |
| } |
| |
| void FrameView::setLayoutSizeInternal(const IntSize& size) |
| { |
| if (m_layoutSize == size) |
| return; |
| |
| m_layoutSize = size; |
| contentsResized(); |
| } |
| |
| void FrameView::didAddScrollbar(Scrollbar* scrollbar, ScrollbarOrientation orientation) |
| { |
| ScrollableArea::didAddScrollbar(scrollbar, orientation); |
| if (AXObjectCache* cache = axObjectCache()) |
| cache->handleScrollbarUpdate(this); |
| } |
| |
| void FrameView::willRemoveScrollbar(Scrollbar* scrollbar, ScrollbarOrientation orientation) |
| { |
| ScrollableArea::willRemoveScrollbar(scrollbar, orientation); |
| if (AXObjectCache* cache = axObjectCache()) { |
| cache->remove(scrollbar); |
| cache->handleScrollbarUpdate(this); |
| } |
| } |
| |
| } // namespace WebCore |