diff options
Diffstat (limited to 'Source/WebCore/rendering/RenderView.h')
| -rw-r--r-- | Source/WebCore/rendering/RenderView.h | 376 |
1 files changed, 211 insertions, 165 deletions
diff --git a/Source/WebCore/rendering/RenderView.h b/Source/WebCore/rendering/RenderView.h index 0c4f4c3ba..3bacf7b91 100644 --- a/Source/WebCore/rendering/RenderView.h +++ b/Source/WebCore/rendering/RenderView.h @@ -1,6 +1,6 @@ /* * Copyright (C) 1999 Lars Knoll (knoll@kde.org) - * Copyright (C) 2006 Apple Computer, Inc. + * Copyright (C) 2006, 2015-2016 Apple Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -19,45 +19,47 @@ * */ -#ifndef RenderView_h -#define RenderView_h +#pragma once #include "FrameView.h" #include "LayoutState.h" -#include "PODFreeListArena.h" #include "Region.h" #include "RenderBlockFlow.h" -#include <wtf/OwnPtr.h> +#include "RenderWidget.h" +#include "SelectionSubtreeRoot.h" +#include <memory> +#include <wtf/HashSet.h> + +#if ENABLE(SERVICE_CONTROLS) +#include "SelectionRectGatherer.h" +#endif namespace WebCore { class FlowThreadController; class ImageQualityController; -class RenderQuote; - -#if USE(ACCELERATED_COMPOSITING) class RenderLayerCompositor; -#endif +class RenderQuote; -class RenderView final : public RenderBlockFlow { +class RenderView final : public RenderBlockFlow, public SelectionSubtreeRoot { public: - RenderView(Document&, PassRef<RenderStyle>); + RenderView(Document&, RenderStyle&&); virtual ~RenderView(); - bool hitTest(const HitTestRequest&, HitTestResult&); + WEBCORE_EXPORT bool hitTest(const HitTestRequest&, HitTestResult&); bool hitTest(const HitTestRequest&, const HitTestLocation&, HitTestResult&); - virtual const char* renderName() const override { return "RenderView"; } + const char* renderName() const override { return "RenderView"; } - virtual bool requiresLayer() const override { return true; } + bool requiresLayer() const override { return true; } - virtual bool isChildAllowed(const RenderObject&, const RenderStyle&) const override; + bool isChildAllowed(const RenderObject&, const RenderStyle&) const override; - virtual void layout() override; - virtual void updateLogicalWidth() override; - virtual void computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues&) const override; + void layout() override; + void updateLogicalWidth() override; + LogicalExtentComputedValues computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop) const override; - virtual LayoutUnit availableLogicalHeight(AvailableLogicalHeightType) const override; + LayoutUnit availableLogicalHeight(AvailableLogicalHeightType) const override; // The same as the FrameView's layoutHeight/layoutWidth but with null check guards. int viewHeight() const; @@ -72,39 +74,30 @@ public: FrameView& frameView() const { return m_frameView; } - virtual LayoutRect visualOverflowRect() const override; - virtual void computeRectForRepaint(const RenderLayerModelObject* repaintContainer, LayoutRect&, bool fixed = false) const override; + LayoutRect visualOverflowRect() const override; + LayoutRect computeRectForRepaint(const LayoutRect&, const RenderLayerModelObject* repaintContainer, RepaintContext = { }) const override; void repaintRootContents(); - void repaintViewRectangle(const LayoutRect&, bool immediate = false) const; - // Repaint the view, and all composited layers that intersect the given absolute rectangle. - // FIXME: ideally we'd never have to do this, if all repaints are container-relative. - void repaintRectangleInViewAndCompositedLayers(const LayoutRect&, bool immediate = false); + void repaintViewRectangle(const LayoutRect&) const; void repaintViewAndCompositedLayers(); - virtual void paint(PaintInfo&, const LayoutPoint&) override; - virtual void paintBoxDecorations(PaintInfo&, const LayoutPoint&) override; + void paint(PaintInfo&, const LayoutPoint&) override; + void paintBoxDecorations(PaintInfo&, const LayoutPoint&) override; + // Return the renderer whose background style is used to paint the root background. + RenderElement* rendererForRootBackground() const; enum SelectionRepaintMode { RepaintNewXOROld, RepaintNewMinusOld, RepaintNothing }; - void setSelection(RenderObject* start, int startPos, RenderObject* end, int endPos, SelectionRepaintMode = RepaintNewXOROld); - void getSelection(RenderObject*& startRenderer, int& startOffset, RenderObject*& endRenderer, int& endOffset) const; + void setSelection(RenderObject* start, std::optional<unsigned> startPos, RenderObject* endObject, std::optional<unsigned> endPos, SelectionRepaintMode = RepaintNewXOROld); + void getSelection(RenderObject*& startRenderer, std::optional<unsigned>& startOffset, RenderObject*& endRenderer, std::optional<unsigned>& endOffset) const; void clearSelection(); - RenderObject* selectionStart() const { return m_selectionStart; } - RenderObject* selectionEnd() const { return m_selectionEnd; } + RenderObject* selectionUnsplitStart() const { return m_selectionUnsplitStart; } + RenderObject* selectionUnsplitEnd() const { return m_selectionUnsplitEnd; } IntRect selectionBounds(bool clipToVisibleContent = true) const; - void selectionStartEnd(int& startPos, int& endPos) const; void repaintSelection() const; bool printing() const; - virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override; - virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override; - -#if USE(ACCELERATED_COMPOSITING) - void setMaximalOutlineSize(int o); -#else - void setMaximalOutlineSize(int o) { m_maximalOutlineSize = o; } -#endif - int maximalOutlineSize() const { return m_maximalOutlineSize; } + void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override; + void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override; LayoutRect viewRect() const; @@ -119,23 +112,19 @@ public: { if (m_layoutState) { m_layoutState->m_layoutDelta += delta; -#if !ASSERT_DISABLED && ENABLE(SATURATED_LAYOUT_ARITHMETIC) +#if !ASSERT_DISABLED m_layoutState->m_layoutDeltaXSaturated |= m_layoutState->m_layoutDelta.width() == LayoutUnit::max() || m_layoutState->m_layoutDelta.width() == LayoutUnit::min(); m_layoutState->m_layoutDeltaYSaturated |= m_layoutState->m_layoutDelta.height() == LayoutUnit::max() || m_layoutState->m_layoutDelta.height() == LayoutUnit::min(); #endif } } - + #if !ASSERT_DISABLED bool layoutDeltaMatches(const LayoutSize& delta) { if (!m_layoutState) return false; -#if ENABLE(SATURATED_LAYOUT_ARITHMETIC) return (delta.width() == m_layoutState->m_layoutDelta.width() || m_layoutState->m_layoutDeltaXSaturated) && (delta.height() == m_layoutState->m_layoutDelta.height() || m_layoutState->m_layoutDeltaYSaturated); -#else - return delta == m_layoutState->m_layoutDelta; -#endif } #endif @@ -143,15 +132,14 @@ public: // Subtree push/pop void pushLayoutState(RenderObject&); + void pushLayoutStateForPagination(RenderBlockFlow&); void popLayoutState(RenderObject&) { return popLayoutState(); } // Just doing this to keep popLayoutState() private and to make the subtree calls symmetrical. - bool shouldDisableLayoutStateForSubtree(RenderObject*) const; - // Returns true if layoutState should be used for its cached offset and clip. bool layoutStateEnabled() const { return m_layoutStateDisableCount == 0 && m_layoutState; } LayoutState* layoutState() const { return m_layoutState.get(); } - virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&) override; + void updateHitTestResult(HitTestResult&, const LayoutPoint&) override; LayoutUnit pageLogicalHeight() const { return m_pageLogicalHeight; } void setPageLogicalHeight(LayoutUnit height) @@ -163,6 +151,14 @@ public: } LayoutUnit pageOrViewLogicalHeight() const; + // This method is used to assign a page number only when pagination modes have + // a block progression. This happens with vertical-rl books for example, but it + // doesn't happen for normal horizontal-tb books. This is a very specialized + // function and should not be mistaken for a general page number API. + unsigned pageNumberForBlockProgressionOffset(int offset) const; + + unsigned pageCount() const; + // FIXME: These functions are deprecated. No code should be added that uses these. int bestTruncatedAt() const { return m_legacyPrinting.m_bestTruncatedAt; } void setBestTruncatedAt(int y, RenderBoxModelObject* forRenderer, bool forcedBreak = false); @@ -181,15 +177,19 @@ public: // Notification that this view moved into or out of a native window. void setIsInWindow(bool); -#if USE(ACCELERATED_COMPOSITING) - RenderLayerCompositor& compositor(); - bool usesCompositing() const; -#endif + WEBCORE_EXPORT RenderLayerCompositor& compositor(); + WEBCORE_EXPORT bool usesCompositing() const; - IntRect unscaledDocumentRect() const; - LayoutRect backgroundRect(RenderBox* backgroundRenderer) const; + bool usesFirstLineRules() const { return m_usesFirstLineRules; } + bool usesFirstLetterRules() const { return m_usesFirstLetterRules; } + void setUsesFirstLineRules(bool value) { m_usesFirstLineRules = value; } + void setUsesFirstLetterRules(bool value) { m_usesFirstLetterRules = value; } - IntRect documentRect() const; + WEBCORE_EXPORT IntRect unscaledDocumentRect() const; + LayoutRect unextendedBackgroundRect() const; + LayoutRect backgroundRect() const; + + WEBCORE_EXPORT IntRect documentRect() const; // Renderer that paints the root background has background-images which all have background-attachment: fixed. bool rootBackgroundIsEntirelyFixed() const; @@ -198,19 +198,15 @@ public: bool checkTwoPassLayoutForAutoHeightRegions() const; FlowThreadController& flowThreadController(); - virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override; - -#if PLATFORM(IOS) - enum ContainingBlockCheck { CheckContainingBlock, DontCheckContainingBlock }; - bool hasCustomFixedPosition(const RenderObject&, ContainingBlockCheck = CheckContainingBlock) const; -#endif - - IntervalArena* intervalArena(); + void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override; - IntSize viewportSize() const; + IntSize viewportSizeForCSSViewportUnits() const; void setRenderQuoteHead(RenderQuote* head) { m_renderQuoteHead = head; } RenderQuote* renderQuoteHead() const { return m_renderQuoteHead; } + + // FIXME: see class RenderTreeInternalMutation below. + bool renderTreeIsBeingMutatedInternally() const { return !!m_renderTreeInternalMutationCounter; } // FIXME: This is a work around because the current implementation of counters // requires walking the entire tree repeatedly and most pages don't actually use either @@ -220,21 +216,22 @@ public: void removeRenderCounter() { ASSERT(m_renderCounterCount > 0); m_renderCounterCount--; } bool hasRenderCounters() { return m_renderCounterCount; } - virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0) override; - - IntRect pixelSnappedLayoutOverflowRect() const { return pixelSnappedIntRect(layoutOverflowRect()); } - ImageQualityController& imageQualityController(); -#if ENABLE(CSS_FILTERS) void setHasSoftwareFilters(bool hasSoftwareFilters) { m_hasSoftwareFilters = hasSoftwareFilters; } bool hasSoftwareFilters() const { return m_hasSoftwareFilters; } -#endif uint64_t rendererCount() const { return m_rendererCount; } void didCreateRenderer() { ++m_rendererCount; } void didDestroyRenderer() { --m_rendererCount; } + void updateVisibleViewportRect(const IntRect&); + void registerForVisibleInViewportCallback(RenderElement&); + void unregisterForVisibleInViewportCallback(RenderElement&); + void resumePausedImageAnimationsIfNeeded(IntRect visibleRect); + void addRendererWithPausedImageAnimations(RenderElement&); + void removeRendererWithPausedImageAnimations(RenderElement&); + class RepaintRegionAccumulator { WTF_MAKE_NONCOPYABLE(RepaintRegionAccumulator); public: @@ -242,38 +239,50 @@ public: ~RepaintRegionAccumulator(); private: - RenderView* m_rootView; + WeakPtr<RenderView> m_rootView; bool m_wasAccumulatingRepaintRegion; }; + WeakPtr<RenderView> createWeakPtr() { return m_weakFactory.createWeakPtr(); } + + void scheduleLazyRepaint(RenderBox&); + void unscheduleLazyRepaint(RenderBox&); + + void protectRenderWidgetUntilLayoutIsDone(RenderWidget& widget) { m_protectedRenderWidgets.append(&widget); } + void releaseProtectedRenderWidgets() { m_protectedRenderWidgets.clear(); } + +#if ENABLE(CSS_SCROLL_SNAP) + void registerBoxWithScrollSnapPositions(const RenderBox&); + void unregisterBoxWithScrollSnapPositions(const RenderBox&); + const HashSet<const RenderBox*>& boxesWithScrollSnapPositions() { return m_boxesWithScrollSnapPositions; } +#endif + +#if !ASSERT_DISABLED + bool inHitTesting() const { return m_inHitTesting; } +#endif + protected: - virtual void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0) const override; - virtual const RenderObject* pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const override; - virtual void mapAbsoluteToLocalPoint(MapCoordinatesFlags, TransformState&) const override; - virtual bool requiresColumns(int desiredColumnCount) const override; - + void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags, bool* wasFixed) const override; + const RenderObject* pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const override; + void mapAbsoluteToLocalPoint(MapCoordinatesFlags, TransformState&) const override; + bool requiresColumns(int desiredColumnCount) const override; + private: - bool initializeLayoutState(LayoutState&); + void initializeLayoutState(LayoutState&); - virtual void computeColumnCountAndWidth() override; - virtual ColumnInfo::PaginationUnit paginationUnit() const override; + void computeColumnCountAndWidth() override; bool shouldRepaint(const LayoutRect&) const; void flushAccumulatedRepaintRegion() const; // These functions may only be accessed by LayoutStateMaintainer. - bool pushLayoutState(RenderBox& renderer, const LayoutSize& offset, LayoutUnit pageHeight = 0, bool pageHeightChanged = false, ColumnInfo* colInfo = nullptr) + bool pushLayoutState(RenderBox& renderer, const LayoutSize& offset, LayoutUnit pageHeight = 0, bool pageHeightChanged = false) { // We push LayoutState even if layoutState is disabled because it stores layoutDelta too. - if (!doingFullRepaint() || m_layoutState->isPaginated() || renderer.hasColumns() || renderer.flowThreadContainingBlock() - || m_layoutState->lineGrid() || (renderer.style().lineGrid() != RenderStyle::initialLineGrid() && renderer.isRenderBlockFlow()) -#if ENABLE(CSS_SHAPES) - || (renderer.isRenderBlock() && toRenderBlock(renderer).shapeInsideInfo()) - || (m_layoutState->shapeInsideInfo() && renderer.isRenderBlock() && !toRenderBlock(renderer).allowsShapeInsideInfoSharing()) -#endif - ) { + if (!doingFullRepaint() || m_layoutState->isPaginated() || renderer.flowThreadContainingBlock() + || m_layoutState->lineGrid() || (renderer.style().lineGrid() != RenderStyle::initialLineGrid() && renderer.isRenderBlockFlow())) { + m_layoutState = std::make_unique<LayoutState>(WTFMove(m_layoutState), &renderer, offset, pageHeight, pageHeightChanged); pushLayoutStateForCurrentFlowThread(renderer); - m_layoutState = std::make_unique<LayoutState>(std::move(m_layoutState), &renderer, offset, pageHeight, pageHeightChanged, colInfo); return true; } return false; @@ -281,8 +290,19 @@ private: void popLayoutState() { - m_layoutState = std::move(m_layoutState->m_next); popLayoutStateForCurrentFlowThread(); + m_layoutState = WTFMove(m_layoutState->m_next); + } + + enum class RenderTreeInternalMutation { On, Off }; + void setRenderTreeInternalMutation(RenderTreeInternalMutation state) + { + if (state == RenderTreeInternalMutation::On) + ++m_renderTreeInternalMutationCounter; + else { + ASSERT(m_renderTreeInternalMutationCounter); + --m_renderTreeInternalMutationCounter; + } } // Suspends the LayoutState optimization. Used under transforms that cannot be represented by @@ -302,154 +322,180 @@ private: void pushLayoutStateForCurrentFlowThread(const RenderObject&); void popLayoutStateForCurrentFlowThread(); - + friend class LayoutStateMaintainer; friend class LayoutStateDisabler; + friend class SubtreeLayoutStateMaintainer; + friend class RenderTreeInternalMutationScope; + + bool isScrollableOrRubberbandableBox() const override; + + void splitSelectionBetweenSubtrees(const RenderObject* startRenderer, std::optional<unsigned> startPos, const RenderObject* endRenderer, std::optional<unsigned> endPos, SelectionRepaintMode blockRepaintMode); + void clearSubtreeSelection(const SelectionSubtreeRoot&, SelectionRepaintMode, OldSelectionData&) const; + void updateSelectionForSubtrees(RenderSubtreesMap&, SelectionRepaintMode); + void applySubtreeSelection(const SelectionSubtreeRoot&, SelectionRepaintMode, const OldSelectionData&); + LayoutRect subtreeSelectionBounds(const SelectionSubtreeRoot&, bool clipToVisibleContent = true) const; + void repaintSubtreeSelection(const SelectionSubtreeRoot&) const; private: FrameView& m_frameView; - RenderObject* m_selectionStart; - RenderObject* m_selectionEnd; - int m_selectionStartPos; - int m_selectionEndPos; + WeakPtrFactory<RenderView> m_weakFactory; + RenderObject* m_selectionUnsplitStart { nullptr }; + RenderObject* m_selectionUnsplitEnd { nullptr }; + std::optional<unsigned> m_selectionUnsplitStartPos; + std::optional<unsigned> m_selectionUnsplitEndPos; - uint64_t m_rendererCount; + // Include this RenderView. + uint64_t m_rendererCount { 1 }; mutable std::unique_ptr<Region> m_accumulatedRepaintRegion; // FIXME: Only used by embedded WebViews inside AppKit NSViews. Find a way to remove. struct LegacyPrinting { - LegacyPrinting() - : m_bestTruncatedAt(0) - , m_truncatedAt(0) - , m_truncatorWidth(0) - , m_forcedPageBreak(false) - { } - - int m_bestTruncatedAt; - int m_truncatedAt; - int m_truncatorWidth; + int m_bestTruncatedAt { 0 }; + int m_truncatedAt { 0 }; + int m_truncatorWidth { 0 }; IntRect m_printRect; - bool m_forcedPageBreak; + bool m_forcedPageBreak { false }; }; LegacyPrinting m_legacyPrinting; // End deprecated members. - int m_maximalOutlineSize; // Used to apply a fudge factor to dirty-rect checks on blocks/tables. - bool shouldUsePrintingLayout() const; - OwnPtr<ImageQualityController> m_imageQualityController; + void lazyRepaintTimerFired(); + + Timer m_lazyRepaintTimer; + HashSet<RenderBox*> m_renderersNeedingLazyRepaint; + + std::unique_ptr<ImageQualityController> m_imageQualityController; LayoutUnit m_pageLogicalHeight; - bool m_pageLogicalHeightChanged; + bool m_pageLogicalHeightChanged { false }; std::unique_ptr<LayoutState> m_layoutState; - unsigned m_layoutStateDisableCount; -#if USE(ACCELERATED_COMPOSITING) - OwnPtr<RenderLayerCompositor> m_compositor; + unsigned m_layoutStateDisableCount { 0 }; + std::unique_ptr<RenderLayerCompositor> m_compositor; + std::unique_ptr<FlowThreadController> m_flowThreadController; + + RenderQuote* m_renderQuoteHead { nullptr }; + unsigned m_renderCounterCount { 0 }; + unsigned m_renderTreeInternalMutationCounter { 0 }; + + bool m_selectionWasCaret { false }; + bool m_hasSoftwareFilters { false }; + bool m_usesFirstLineRules { false }; + bool m_usesFirstLetterRules { false }; +#if !ASSERT_DISABLED + bool m_inHitTesting { false }; #endif - OwnPtr<FlowThreadController> m_flowThreadController; - RefPtr<IntervalArena> m_intervalArena; - RenderQuote* m_renderQuoteHead; - unsigned m_renderCounterCount; + HashSet<RenderElement*> m_renderersWithPausedImageAnimation; + HashSet<RenderElement*> m_visibleInViewportRenderers; + Vector<RefPtr<RenderWidget>> m_protectedRenderWidgets; - bool m_selectionWasCaret; -#if ENABLE(CSS_FILTERS) - bool m_hasSoftwareFilters; +#if ENABLE(SERVICE_CONTROLS) + SelectionRectGatherer m_selectionRectGatherer; +#endif +#if ENABLE(CSS_SCROLL_SNAP) + HashSet<const RenderBox*> m_boxesWithScrollSnapPositions; #endif }; -RENDER_OBJECT_TYPE_CASTS(RenderView, isRenderView()); - // Stack-based class to assist with LayoutState push/pop class LayoutStateMaintainer { WTF_MAKE_NONCOPYABLE(LayoutStateMaintainer); public: // Constructor to push now. - explicit LayoutStateMaintainer(RenderView& view, RenderBox& root, LayoutSize offset, bool disableState = false, LayoutUnit pageHeight = 0, bool pageHeightChanged = false, ColumnInfo* colInfo = nullptr) + explicit LayoutStateMaintainer(RenderView& view, RenderBox& root, LayoutSize offset, bool disableState = false, LayoutUnit pageHeight = 0, bool pageHeightChanged = false) : m_view(view) , m_disabled(disableState) - , m_didStart(false) - , m_didEnd(false) - , m_didCreateLayoutState(false) { - push(root, offset, pageHeight, pageHeightChanged, colInfo); + push(root, offset, pageHeight, pageHeightChanged); } // Constructor to maybe push later. explicit LayoutStateMaintainer(RenderView& view) : m_view(view) - , m_disabled(false) - , m_didStart(false) - , m_didEnd(false) - , m_didCreateLayoutState(false) { } ~LayoutStateMaintainer() { - ASSERT(m_didStart == m_didEnd); // if this fires, it means that someone did a push(), but forgot to pop(). + ASSERT(!m_didCallPush || m_didCallPush == m_didCallPop); } - void push(RenderBox& root, LayoutSize offset, LayoutUnit pageHeight = 0, bool pageHeightChanged = false, ColumnInfo* colInfo = nullptr) + void push(RenderBox& root, LayoutSize offset, LayoutUnit pageHeight = 0, bool pageHeightChanged = false) { - ASSERT(!m_didStart); + ASSERT(!m_didCallPush); + m_didCallPush = true; // We push state even if disabled, because we still need to store layoutDelta - m_didCreateLayoutState = m_view.pushLayoutState(root, offset, pageHeight, pageHeightChanged, colInfo); - if (m_disabled && m_didCreateLayoutState) + m_didPushLayoutState = m_view.pushLayoutState(root, offset, pageHeight, pageHeightChanged); + if (!m_didPushLayoutState) + return; + if (m_disabled) m_view.disableLayoutState(); - m_didStart = true; } void pop() { - if (m_didStart) { - ASSERT(!m_didEnd); - if (m_didCreateLayoutState) { - m_view.popLayoutState(); - if (m_disabled) - m_view.enableLayoutState(); - } - - m_didEnd = true; - } + ASSERT(!m_didCallPop); + m_didCallPop = true; + if (!m_didCallPush) + return; + if (!m_didPushLayoutState) + return; + m_view.popLayoutState(); + if (m_disabled) + m_view.enableLayoutState(); } - bool didPush() const { return m_didStart; } + bool didPush() const { return m_didCallPush; } private: RenderView& m_view; - bool m_disabled : 1; // true if the offset and clip part of layoutState is disabled - bool m_didStart : 1; // true if we did a push or disable - bool m_didEnd : 1; // true if we popped or re-enabled - bool m_didCreateLayoutState : 1; // true if we actually made a layout state. + bool m_disabled { false }; + bool m_didCallPush { false }; + bool m_didCallPop { false }; + bool m_didPushLayoutState { false }; }; class LayoutStateDisabler { WTF_MAKE_NONCOPYABLE(LayoutStateDisabler); public: - LayoutStateDisabler(RenderView* view) + LayoutStateDisabler(RenderView& view) : m_view(view) { - if (m_view) - m_view->disableLayoutState(); + m_view.disableLayoutState(); } ~LayoutStateDisabler() { - if (m_view) - m_view->enableLayoutState(); + m_view.enableLayoutState(); } + private: - RenderView* m_view; + RenderView& m_view; }; -inline Frame& RenderObject::frame() const -{ - return view().frameView().frame(); -} +// FIXME: This is a temporary workaround to mute unintended activities triggered by render tree mutations. +class RenderTreeInternalMutationScope { + WTF_MAKE_NONCOPYABLE(RenderTreeInternalMutationScope); +public: + RenderTreeInternalMutationScope(RenderView& view) + : m_view(view) + { + m_view.setRenderTreeInternalMutation(RenderView::RenderTreeInternalMutation::On); + } + + ~RenderTreeInternalMutationScope() + { + m_view.setRenderTreeInternalMutation(RenderView::RenderTreeInternalMutation::Off); + } + +private: + RenderView& m_view; +}; } // namespace WebCore -#endif // RenderView_h +SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderView, isRenderView()) |