#ifndef FrameView_h
#define FrameView_h
-#include "core/frame/AdjustViewSizeOrNot.h"
-#include "core/platform/ScrollView.h"
-#include "core/rendering/Pagination.h"
+#include "core/frame/FrameViewAutoSizeInfo.h"
#include "core/rendering/PaintPhase.h"
-#include "core/rendering/PartialLayoutState.h"
+#include "platform/RuntimeEnabledFeatures.h"
#include "platform/geometry/LayoutRect.h"
#include "platform/graphics/Color.h"
+#include "platform/scroll/ScrollView.h"
#include "wtf/Forward.h"
#include "wtf/OwnPtr.h"
#include "wtf/text/WTFString.h"
-namespace WebCore {
+namespace blink {
+class AXObjectCache;
+class DocumentLifecycle;
+class Cursor;
class Element;
class FloatSize;
-class Frame;
+class HTMLFrameOwnerElement;
+class LocalFrame;
class KURL;
class Node;
-class OverflowEvent;
class Page;
class RenderBox;
class RenderEmbeddedObject;
class RenderObject;
class RenderScrollbarPart;
-class RenderStyle;
-
-Pagination::Mode paginationModeForRenderStyle(RenderStyle*);
+class RenderView;
+class RenderWidget;
+struct CompositedSelectionBound;
typedef unsigned long long DOMTimeStamp;
-class FrameView : public ScrollView {
+// FIXME: Oilpan: move Widget (and thereby FrameView) to the heap.
+class FrameView FINAL : public ScrollView {
public:
friend class RenderView;
friend class Internals;
- static PassRefPtr<FrameView> create(Frame*);
- static PassRefPtr<FrameView> create(Frame*, const IntSize& initialSize);
+ static PassRefPtr<FrameView> create(LocalFrame*);
+ static PassRefPtr<FrameView> create(LocalFrame*, const IntSize& initialSize);
virtual ~FrameView();
- virtual HostWindow* hostWindow() const;
+ virtual HostWindow* hostWindow() const OVERRIDE;
- virtual void invalidateRect(const IntRect&);
- virtual void setFrameRect(const IntRect&);
+ virtual void invalidateRect(const IntRect&) OVERRIDE;
+ virtual void setFrameRect(const IntRect&) OVERRIDE;
- virtual bool scheduleAnimation();
+ LocalFrame& frame() const
+ {
+ ASSERT(m_frame);
+ return *m_frame;
+ }
- Frame& frame() const { return *m_frame; }
+ Page* page() const;
RenderView* renderView() const;
- int mapFromLayoutToCSSUnits(LayoutUnit) const;
- LayoutUnit mapFromCSSToLayoutUnits(int) const;
-
- LayoutUnit marginWidth() const { return m_margins.width(); } // -1 means default
- LayoutUnit marginHeight() const { return m_margins.height(); } // -1 means default
- void setMarginWidth(LayoutUnit);
- void setMarginHeight(LayoutUnit);
-
- virtual void setCanHaveScrollbars(bool);
- void updateCanHaveScrollbars();
+ virtual void setCanHaveScrollbars(bool) OVERRIDE;
- virtual PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
+ virtual PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation) OVERRIDE;
- virtual void setContentsSize(const IntSize&);
+ virtual void setContentsSize(const IntSize&) OVERRIDE;
+ IntPoint clampOffsetAtScale(const IntPoint& offset, float scale) const;
void layout(bool allowSubtree = true);
bool didFirstLayout() const;
- void layoutTimerFired(Timer<FrameView>*);
void scheduleRelayout();
void scheduleRelayoutOfSubtree(RenderObject*);
- void unscheduleRelayout();
bool layoutPending() const;
- bool isInLayout() const { return m_inLayout; }
+ bool isInPerformLayout() const;
+
+ void setCanInvalidatePaintDuringPerformLayout(bool b) { m_canInvalidatePaintDuringPerformLayout = b; }
+ bool canInvalidatePaintDuringPerformLayout() const { return m_canInvalidatePaintDuringPerformLayout; }
RenderObject* layoutRoot(bool onlyDuringLayout = false) const;
- void clearLayoutRoot() { m_layoutRoot = 0; }
+ void clearLayoutSubtreeRoot() { m_layoutSubtreeRoot = 0; }
int layoutCount() const { return m_layoutCount; }
bool needsLayout() const;
void setNeedsLayout();
- void setViewportConstrainedObjectsNeedLayout();
+
+ void setNeedsUpdateWidgetPositions() { m_needsUpdateWidgetPositions = true; }
// Methods for getting/setting the size Blink should use to layout the contents.
IntSize layoutSize(IncludeScrollbarsInRect = ExcludeScrollbars) const;
void setLayoutSizeFixedToFrameSize(bool isFixed) { m_layoutSizeFixedToFrameSize = isFixed; }
bool layoutSizeFixedToFrameSize() { return m_layoutSizeFixedToFrameSize; }
- bool needsFullRepaint() const { return m_doFullRepaint; }
+ bool needsFullPaintInvalidation() const { return m_doFullPaintInvalidation; }
- void serviceScriptedAnimations(double monotonicAnimationStartTime);
+ void updateAcceleratedCompositingSettings();
- void updateCompositingLayersAfterStyleChange();
- void updateCompositingLayersAfterLayout();
+ void recalcOverflowAfterStyleChange();
- bool hasCompositedContent() const;
bool isEnclosedInCompositingLayer() const;
- // Returns true when a paint with the PaintBehaviorFlattenCompositingLayers flag set gives
- // a faithful representation of the content.
- bool isSoftwareRenderable() const;
-
void resetScrollbars();
void prepareForDetach();
void detachCustomScrollbars();
void setBaseBackgroundColor(const Color&);
void updateBackgroundRecursively(const Color&, bool);
- bool shouldUpdateWhileOffscreen() const;
- void setShouldUpdateWhileOffscreen(bool);
- bool shouldUpdate() const;
-
void adjustViewSize();
- virtual IntRect windowClipRect(bool clipToContents = true) const;
- IntRect windowClipRectForFrameOwner(const HTMLFrameOwnerElement*, bool clipToLayerContents) const;
+ virtual IntRect windowClipRect(IncludeScrollbarsInRect = ExcludeScrollbars) const OVERRIDE;
+ IntRect windowClipRectForFrameOwner(const HTMLFrameOwnerElement*) const;
- virtual IntRect windowResizerRect() const;
+ virtual IntRect windowResizerRect() const OVERRIDE;
virtual float visibleContentScaleFactor() const OVERRIDE { return m_visibleContentScaleFactor; }
void setVisibleContentScaleFactor(float);
virtual IntSize inputEventsOffsetForEmulation() const OVERRIDE;
void setInputEventsTransformForEmulation(const IntSize&, float);
- virtual void setScrollPosition(const IntPoint&) OVERRIDE;
- virtual void repaintFixedElementsAfterScrolling();
- virtual void updateFixedElementsAfterScrolling();
- virtual bool shouldRubberBandInDirection(ScrollDirection) const;
+ virtual void setScrollPosition(const IntPoint&, ScrollBehavior = ScrollBehaviorInstant) OVERRIDE;
virtual bool isRubberBandInProgress() const OVERRIDE;
void setScrollPositionNonProgrammatically(const IntPoint&);
// This is different than visibleContentRect() in that it ignores negative (or overly positive)
// offsets from rubber-banding, and it takes zooming into account.
LayoutRect viewportConstrainedVisibleContentRect() const;
+ void viewportConstrainedVisibleContentSizeChanged(bool widthChanged, bool heightChanged);
AtomicString mediaType() const;
void setMediaType(const AtomicString&);
void adjustMediaTypeForPrinting(bool printing);
- void setCannotBlitToWindow();
- void setIsOverlapped(bool);
- bool isOverlapped() const { return m_isOverlapped; }
- bool isOverlappedIncludingAncestors() const;
- void setContentIsOpaque(bool);
-
void addSlowRepaintObject();
void removeSlowRepaintObject();
bool hasSlowRepaintObjects() const { return m_slowRepaintObjectCount; }
- // Includes fixed- and sticky-position objects.
+ // Fixed-position objects.
typedef HashSet<RenderObject*> ViewportConstrainedObjectSet;
void addViewportConstrainedObject(RenderObject*);
void removeViewportConstrainedObject(RenderObject*);
bool hasViewportConstrainedObjects() const { return m_viewportConstrainedObjects && m_viewportConstrainedObjects->size() > 0; }
void handleLoadCompleted();
- void resetDeferredRepaintDelay();
void updateAnnotatedRegions();
- void updateControlTints();
void restoreScrollbar();
- void suspendOverflowEvents();
- void resumeOverflowEvents();
- void scheduleOverflowEvent(PassRefPtr<OverflowEvent>);
-
void postLayoutTimerFired(Timer<FrameView>*);
bool wasScrolledByUser() const;
bool safeToPropagateScrollToParent() const { return m_safeToPropagateScrollToParent; }
void setSafeToPropagateScrollToParent(bool isSafe) { m_safeToPropagateScrollToParent = isSafe; }
- void addWidgetToUpdate(RenderObject*);
- void removeWidgetToUpdate(RenderObject*);
+ void addWidget(RenderWidget*);
+ void removeWidget(RenderWidget*);
+ void updateWidgetPositions();
+
+ void addWidgetToUpdate(RenderEmbeddedObject&);
- virtual void paintContents(GraphicsContext*, const IntRect& damageRect);
+ virtual void paintContents(GraphicsContext*, const IntRect& damageRect) OVERRIDE;
void setPaintBehavior(PaintBehavior);
PaintBehavior paintBehavior() const;
bool isPainting() const;
bool hasEverPainted() const { return m_lastPaintTime; }
- void setLastPaintTime(double lastPaintTime) { m_lastPaintTime = lastPaintTime; }
void setNodeToDraw(Node*);
- virtual void paintOverhangAreas(GraphicsContext*, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect);
- virtual void paintScrollCorner(GraphicsContext*, const IntRect& cornerRect);
+ virtual void paintOverhangAreas(GraphicsContext*, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect) OVERRIDE;
+ virtual void paintScrollCorner(GraphicsContext*, const IntRect& cornerRect) OVERRIDE;
virtual void paintScrollbar(GraphicsContext*, Scrollbar*, const IntRect&) OVERRIDE;
Color documentBackgroundColor() const;
static double currentFrameTimeStamp() { return s_currentFrameTimeStamp; }
+ void updateLayoutAndStyleForPainting();
void updateLayoutAndStyleIfNeededRecursive();
+ void invalidateTreeIfNeededRecursive();
+
void incrementVisuallyNonEmptyCharacterCount(unsigned);
void incrementVisuallyNonEmptyPixelCount(const IntSize&);
void setIsVisuallyNonEmpty() { m_isVisuallyNonEmpty = true; }
- bool isVisuallyNonEmpty() const { return m_isVisuallyNonEmpty; }
- void enableAutoSizeMode(bool enable, const IntSize& minSize, const IntSize& maxSize);
+ void enableAutoSizeMode(const IntSize& minSize, const IntSize& maxSize);
+ void disableAutoSizeMode() { m_autoSizeInfo.clear(); }
void forceLayout(bool allowSubtree = false);
- void forceLayoutForPagination(const FloatSize& pageSize, const FloatSize& originalPageSize, float maximumShrinkFactor, AdjustViewSizeOrNot);
+ void forceLayoutForPagination(const FloatSize& pageSize, const FloatSize& originalPageSize, float maximumShrinkFactor);
bool scrollToFragment(const KURL&);
bool scrollToAnchor(const String&);
void maintainScrollPositionAtAnchor(Node*);
void scrollElementToRect(Element*, const IntRect&);
+ void scrollContentsIfNeededRecursive();
// Methods to convert points and rects between the coordinate space of the renderer, and this view.
- virtual IntRect convertFromRenderer(const RenderObject*, const IntRect&) const;
- virtual IntRect convertToRenderer(const RenderObject*, const IntRect&) const;
- virtual IntPoint convertFromRenderer(const RenderObject*, const IntPoint&) const;
- virtual IntPoint convertToRenderer(const RenderObject*, const IntPoint&) const;
+ IntRect convertFromRenderer(const RenderObject&, const IntRect&) const;
+ IntRect convertToRenderer(const RenderObject&, const IntRect&) const;
+ IntPoint convertFromRenderer(const RenderObject&, const IntPoint&) const;
+ IntPoint convertToRenderer(const RenderObject&, const IntPoint&) const;
bool isFrameViewScrollCorner(RenderScrollbarPart* scrollCorner) const { return m_scrollCorner == scrollCorner; }
bool isScrollable();
enum ScrollbarModesCalculationStrategy { RulesFromWebContentOnly, AnyRule };
- void calculateScrollbarModesForLayout(ScrollbarMode& hMode, ScrollbarMode& vMode, ScrollbarModesCalculationStrategy = AnyRule);
-
- // Normal delay
- static void setRepaintThrottlingDeferredRepaintDelay(double);
- // Negative value would mean that first few repaints happen without a delay
- static void setRepaintThrottlingnInitialDeferredRepaintDelayDuringLoading(double);
- // The delay grows on each repaint to this maximum value
- static void setRepaintThrottlingMaxDeferredRepaintDelayDuringLoading(double);
- // On each repaint the delay increses by this amount
- static void setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double);
-
- virtual IntPoint lastKnownMousePosition() const;
+ void calculateScrollbarModesForLayoutAndSetViewportRenderer(ScrollbarMode& hMode, ScrollbarMode& vMode, ScrollbarModesCalculationStrategy = AnyRule);
+
+ virtual IntPoint lastKnownMousePosition() const OVERRIDE;
bool shouldSetCursor() const;
void setCursor(const Cursor&);
// FIXME: Remove this method once plugin loading is decoupled from layout.
void flushAnyPendingPostLayoutTasks();
- virtual bool shouldSuspendScrollAnimations() const;
- virtual void scrollbarStyleChanged(int newStyle, bool forceUpdate);
-
- void setAnimatorsAreActive();
+ virtual bool shouldSuspendScrollAnimations() const OVERRIDE;
+ virtual void scrollbarStyleChanged() OVERRIDE;
RenderBox* embeddedContentBox() const;
- void setTracksRepaints(bool);
- bool isTrackingRepaints() const { return m_isTrackingRepaints; }
- void resetTrackedRepaints();
- const Vector<IntRect>& trackedRepaintRects() const { return m_trackedRepaintRects; }
- String trackedRepaintRectsAsText() const;
+ void setTracksPaintInvalidations(bool);
+ bool isTrackingPaintInvalidations() const { return m_isTrackingPaintInvalidations; }
+ void resetTrackedPaintInvalidations();
+
+ String trackedPaintInvalidationRectsAsText() const;
typedef HashSet<ScrollableArea*> ScrollableAreaSet;
- // Returns whether the scrollable area has just been newly added.
- bool addScrollableArea(ScrollableArea*);
- // Returns whether the scrollable area has just been removed.
- bool removeScrollableArea(ScrollableArea*);
- bool containsScrollableArea(const ScrollableArea*) const;
+ void addScrollableArea(ScrollableArea*);
+ void removeScrollableArea(ScrollableArea*);
const ScrollableAreaSet* scrollableAreas() const { return m_scrollableAreas.get(); }
// With CSS style "resize:" enabled, a little resizer handle will appear at the bottom
// right of the object. We keep track of these resizer areas for checking if touches
// (implemented using Scroll gesture) are targeting the resizer.
typedef HashSet<RenderBox*> ResizerAreaSet;
- void addResizerArea(RenderBox*);
- void removeResizerArea(RenderBox*);
+ void addResizerArea(RenderBox&);
+ void removeResizerArea(RenderBox&);
const ResizerAreaSet* resizerAreas() const { return m_resizerAreas.get(); }
+ virtual void setParent(Widget*) OVERRIDE;
virtual void removeChild(Widget*) OVERRIDE;
// This function exists for ports that need to handle wheel events manually.
// we need this function in order to do the scroll ourselves.
bool wheelEvent(const PlatformWheelEvent&);
- // Page and FrameView both store a Pagination value. Page::pagination() is set only by API,
- // and FrameView::pagination() is set only by CSS. Page::pagination() will affect all
- // FrameViews in the page cache, but FrameView::pagination() only affects the current
- // FrameView. FrameView::pagination() will return m_pagination if it has been set. Otherwise,
- // it will return Page::pagination() since currently there are no callers that need to
- // distinguish between the two.
- const Pagination& pagination() const;
- void setPagination(const Pagination&);
-
bool inProgrammaticScroll() const { return m_inProgrammaticScroll; }
void setInProgrammaticScroll(bool programmaticScroll) { m_inProgrammaticScroll = programmaticScroll; }
- void setHasSoftwareFilters(bool hasSoftwareFilters) { m_hasSoftwareFilters = hasSoftwareFilters; }
- bool hasSoftwareFilters() const { return m_hasSoftwareFilters; }
-
virtual bool isActive() const OVERRIDE;
// DEPRECATED: Use viewportConstrainedVisibleContentRect() instead.
IntSize scrollOffsetForFixedPosition() const;
- PartialLayoutState& partialLayout() { return m_partialLayout; }
+ // Override scrollbar notifications to update the AXObject cache.
+ virtual void didAddScrollbar(Scrollbar*, ScrollbarOrientation) OVERRIDE;
+ virtual void willRemoveScrollbar(Scrollbar*, ScrollbarOrientation) OVERRIDE;
+
+ // FIXME: This should probably be renamed as the 'inSubtreeLayout' parameter
+ // passed around the FrameView layout methods can be true while this returns
+ // false.
+ bool isSubtreeLayout() const { return !!m_layoutSubtreeRoot; }
+
+ // Sets the tickmarks for the FrameView, overriding the default behavior
+ // which is to display the tickmarks corresponding to find results.
+ // If |m_tickmarks| is empty, the default behavior is restored.
+ void setTickmarks(const Vector<IntRect>& tickmarks) { m_tickmarks = tickmarks; }
+
+ // Since the compositor can resize the viewport due to top controls and
+ // commit scroll offsets before a WebView::resize occurs, we need to adjust
+ // our scroll extents to prevent clamping the scroll offsets.
+ void setTopControlsViewportAdjustment(float);
- class DeferredRepaintScope {
- public:
- DeferredRepaintScope(FrameView&);
- ~DeferredRepaintScope();
- private:
- RefPtr<FrameView> m_view;
- };
+ virtual IntPoint maximumScrollPosition() const OVERRIDE;
+
+ // ScrollableArea interface
+ virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) OVERRIDE;
+ virtual void getTickmarks(Vector<IntRect>&) const OVERRIDE;
+ virtual void scrollTo(const IntSize&) OVERRIDE;
+ virtual IntRect scrollableAreaBoundingBox() const OVERRIDE;
+ virtual bool scrollAnimatorEnabled() const OVERRIDE;
+ virtual bool usesCompositedScrolling() const OVERRIDE;
+ virtual GraphicsLayer* layerForScrolling() const OVERRIDE;
+ virtual GraphicsLayer* layerForHorizontalScrollbar() const OVERRIDE;
+ virtual GraphicsLayer* layerForVerticalScrollbar() const OVERRIDE;
+ virtual GraphicsLayer* layerForScrollCorner() const OVERRIDE;
protected:
- virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect);
- virtual void scrollContentsSlowPath(const IntRect& updateRect);
+ virtual bool scrollContentsFastPath(const IntSize& scrollDelta) OVERRIDE;
+ virtual void scrollContentsSlowPath(const IntRect& updateRect) OVERRIDE;
- virtual bool isVerticalDocument() const;
- virtual bool isFlippedDocument() const;
+ virtual bool isVerticalDocument() const OVERRIDE;
+ virtual bool isFlippedDocument() const OVERRIDE;
-private:
- explicit FrameView(Frame*);
+ // Prevents creation of scrollbars. Used to prevent drawing two sets of
+ // overlay scrollbars in the case of the pinch viewport.
+ virtual bool scrollbarsDisabled() const OVERRIDE;
- void beginDeferredRepaints();
- void endDeferredRepaints();
- void flushDeferredRepaints();
- void startDeferredRepaintTimer(double delay);
+private:
+ explicit FrameView(LocalFrame*);
void reset();
void init();
- virtual void frameRectsChanged();
+ virtual void frameRectsChanged() OVERRIDE;
virtual bool isFrameView() const OVERRIDE { return true; }
friend class RenderWidget;
- bool useSlowRepaints(bool considerOverlap = true) const;
- bool useSlowRepaintsIfNotOverlapped() const;
- void updateCanBlitOnScrollRecursively();
- bool contentsInCompositedLayer() const;
- void applyOverflowToViewport(RenderObject*, ScrollbarMode& hMode, ScrollbarMode& vMode);
- void applyPaginationToViewport();
+ bool contentsInCompositedLayer() const;
+ void applyOverflowToViewportAndSetRenderer(RenderObject*, ScrollbarMode& hMode, ScrollbarMode& vMode);
void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
- void paintControlTints();
-
void updateCounters();
- void autoSizeIfEnabled();
void forceLayoutParentViewIfNeeded();
void performPreLayoutTasks();
void performLayout(RenderObject* rootForThisLayout, bool inSubtreeLayout);
void scheduleOrPerformPostLayoutTasks();
void performPostLayoutTasks();
- virtual void repaintContentRectangle(const IntRect&);
+ void invalidateTreeIfNeeded();
+
+ void gatherDebugLayoutRects(RenderObject* layoutRoot);
+
+ DocumentLifecycle& lifecycle() const;
+
+ virtual void contentRectangleForPaintInvalidation(const IntRect&) OVERRIDE;
virtual void contentsResized() OVERRIDE;
- virtual void scrollbarExistenceDidChange();
+ virtual void scrollbarExistenceDidChange() OVERRIDE;
// Override ScrollView methods to do point conversion via renderers, in order to
// take transforms into account.
virtual IntPoint convertToContainingView(const IntPoint&) const OVERRIDE;
virtual IntPoint convertFromContainingView(const IntPoint&) const OVERRIDE;
- // ScrollableArea interface
- virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) OVERRIDE;
- virtual void getTickmarks(Vector<IntRect>&) const OVERRIDE;
- virtual void scrollTo(const IntSize&) OVERRIDE;
- virtual ScrollableArea* enclosingScrollableArea() const OVERRIDE;
- virtual IntRect scrollableAreaBoundingBox() const OVERRIDE;
- virtual bool scrollAnimatorEnabled() const OVERRIDE;
- virtual bool usesCompositedScrolling() const OVERRIDE;
- virtual GraphicsLayer* layerForScrolling() const OVERRIDE;
- virtual GraphicsLayer* layerForHorizontalScrollbar() const OVERRIDE;
- virtual GraphicsLayer* layerForVerticalScrollbar() const OVERRIDE;
- virtual GraphicsLayer* layerForScrollCorner() const OVERRIDE;
+ void updateWidgetPositionsIfNeeded();
+ bool wasViewportResized();
void sendResizeEventIfNeeded();
void updateScrollableAreaSet();
- virtual void notifyPageThatContentAreaWillPaint() const;
-
- bool shouldUseLoadTimeDeferredRepaintDelay() const;
- void deferredRepaintTimerFired(Timer<FrameView>*);
- void doDeferredRepaints();
- void updateDeferredRepaintDelayAfterRepaint();
- double adjustedDeferredRepaintDelay() const;
+ virtual void notifyPageThatContentAreaWillPaint() const OVERRIDE;
+ void scheduleUpdateWidgetsIfNecessary();
+ void updateWidgetsTimerFired(Timer<FrameView>*);
bool updateWidgets();
- void updateWidget(RenderObject*);
+
void scrollToAnchor();
void scrollPositionChanged();
+ void didScrollTimerFired(Timer<FrameView>*);
+
+ void updateLayersAndCompositingAfterScrollIfNeeded();
+
+ static bool computeCompositedSelectionBounds(LocalFrame&, CompositedSelectionBound& start, CompositedSelectionBound& end);
+ void updateCompositedSelectionBoundsIfNeeded();
bool hasCustomScrollbars() const;
+ bool shouldUseCustomScrollbars(Element*& customScrollbarElement, LocalFrame*& customScrollbarFrame);
- virtual void updateScrollCorner();
+ virtual void updateScrollCorner() OVERRIDE;
FrameView* parentFrameView() const;
- virtual AXObjectCache* axObjectCache() const;
+ AXObjectCache* axObjectCache() const;
void removeFromAXObjectCache();
- bool isMainFrame() const;
-
void setLayoutSizeInternal(const IntSize&);
+ bool paintInvalidationIsAllowed() const
+ {
+ return !isInPerformLayout() || canInvalidatePaintDuringPerformLayout();
+ }
+
static double s_currentFrameTimeStamp; // used for detecting decoded resource thrash in the cache
static bool s_inPaintContents;
LayoutSize m_size;
- LayoutSize m_margins;
- typedef HashSet<RenderObject*> RenderObjectSet;
- OwnPtr<RenderObjectSet> m_widgetUpdateSet;
- RefPtr<Frame> m_frame;
+ typedef WillBeHeapHashSet<RefPtrWillBeMember<RenderEmbeddedObject> > EmbeddedObjectSet;
+ WillBePersistentHeapHashSet<RefPtrWillBeMember<RenderEmbeddedObject> > m_widgetUpdateSet;
+
+ // FIXME: These are just "children" of the FrameView and should be RefPtr<Widget> instead.
+ WillBePersistentHeapHashSet<RefPtrWillBeMember<RenderWidget> > m_widgets;
- bool m_doFullRepaint;
+ // Oilpan: the use of a persistent back reference 'emulates' the
+ // RefPtr-cycle that is kept between the two objects non-Oilpan.
+ //
+ // That cycle is broken when a LocalFrame is detached by
+ // FrameLoader::detachFromParent(), it then clears its
+ // FrameView's m_frame reference by calling setView(nullptr).
+ RefPtrWillBePersistent<LocalFrame> m_frame;
+
+ bool m_doFullPaintInvalidation;
bool m_canHaveScrollbars;
- bool m_cannotBlitToWindow;
- bool m_isOverlapped;
- bool m_contentIsOpaque;
unsigned m_slowRepaintObjectCount;
- int m_borderX;
- int m_borderY;
- Timer<FrameView> m_layoutTimer;
- bool m_delayedLayout;
- RenderObject* m_layoutRoot;
+ bool m_hasPendingLayout;
+ RenderObject* m_layoutSubtreeRoot;
bool m_layoutSchedulingEnabled;
- bool m_inLayout;
- bool m_doingPreLayoutStyleUpdate;
+ bool m_inPerformLayout;
+ bool m_canInvalidatePaintDuringPerformLayout;
bool m_inSynchronousPostLayout;
int m_layoutCount;
unsigned m_nestedLayoutCount;
Timer<FrameView> m_postLayoutTasksTimer;
+ Timer<FrameView> m_updateWidgetsTimer;
bool m_firstLayoutCallbackPending;
bool m_firstLayout;
AtomicString m_mediaType;
AtomicString m_mediaTypeWhenNotPrinting;
- unsigned m_overflowEventSuspendCount;
- Vector<RefPtr<OverflowEvent> > m_overflowEventQueue;
-
bool m_overflowStatusDirty;
bool m_horizontalOverflow;
bool m_verticalOverflow;
RenderObject* m_viewportRenderer;
- Pagination m_pagination;
-
bool m_wasScrolledByUser;
bool m_inProgrammaticScroll;
bool m_safeToPropagateScrollToParent;
- unsigned m_deferringRepaints;
- unsigned m_repaintCount;
- Vector<LayoutRect> m_repaintRects;
- Timer<FrameView> m_deferredRepaintTimer;
- double m_deferredRepaintDelay;
double m_lastPaintTime;
- bool m_isTrackingRepaints; // Used for testing.
- Vector<IntRect> m_trackedRepaintRects;
-
- bool m_shouldUpdateWhileOffscreen;
-
- unsigned m_deferSetNeedsLayouts;
- bool m_setNeedsLayoutWasDeferred;
+ bool m_isTrackingPaintInvalidations; // Used for testing.
+ Vector<IntRect> m_trackedPaintInvalidationRects;
- RefPtr<Node> m_nodeToDraw;
+ RefPtrWillBePersistent<Node> m_nodeToDraw;
PaintBehavior m_paintBehavior;
bool m_isPainting;
bool m_isVisuallyNonEmpty;
bool m_firstVisuallyNonEmptyLayoutCallbackPending;
- RefPtr<Node> m_maintainScrollPositionAnchor;
+ RefPtrWillBePersistent<Node> m_maintainScrollPositionAnchor;
// Renderer to hold our custom scroll corner.
- RenderScrollbarPart* m_scrollCorner;
-
- // If true, automatically resize the frame view around its content.
- bool m_shouldAutoSize;
- bool m_inAutoSize;
- // True if autosize has been run since m_shouldAutoSize was set.
- bool m_didRunAutosize;
- // The lower bound on the size when autosizing.
- IntSize m_minAutoSize;
- // The upper bound on the size when autosizing.
- IntSize m_maxAutoSize;
+ RawPtrWillBePersistent<RenderScrollbarPart> m_scrollCorner;
OwnPtr<ScrollableAreaSet> m_scrollableAreas;
OwnPtr<ResizerAreaSet> m_resizerAreas;
OwnPtr<ViewportConstrainedObjectSet> m_viewportConstrainedObjects;
-
- static double s_normalDeferredRepaintDelay;
- static double s_initialDeferredRepaintDelayDuringLoading;
- static double s_maxDeferredRepaintDelayDuringLoading;
- static double s_deferredRepaintDelayIncrementDuringLoading;
-
- bool m_hasSoftwareFilters;
+ OwnPtr<FrameViewAutoSizeInfo> m_autoSizeInfo;
float m_visibleContentScaleFactor;
IntSize m_inputEventsOffsetForEmulation;
float m_inputEventsScaleFactorForEmulation;
- PartialLayoutState m_partialLayout;
IntSize m_layoutSize;
bool m_layoutSizeFixedToFrameSize;
+
+ Timer<FrameView> m_didScrollTimer;
+
+ Vector<IntRect> m_tickmarks;
+
+ bool m_needsUpdateWidgetPositions;
+ float m_topControlsViewportAdjustment;
};
inline void FrameView::incrementVisuallyNonEmptyCharacterCount(unsigned count)
setIsVisuallyNonEmpty();
}
-inline FrameView* toFrameView(Widget* widget)
-{
- ASSERT(!widget || widget->isFrameView());
- return static_cast<FrameView*>(widget);
-}
+DEFINE_TYPE_CASTS(FrameView, Widget, widget, widget->isFrameView(), widget.isFrameView());
-inline const FrameView* toFrameView(const Widget* widget)
-{
- ASSERT(!widget || widget->isFrameView());
- return static_cast<const FrameView*>(widget);
-}
-
-// This will catch anyone doing an unnecessary cast.
-void toFrameView(const FrameView*);
+class AllowPaintInvalidationScope {
+public:
+ explicit AllowPaintInvalidationScope(FrameView* view)
+ : m_view(view)
+ , m_originalValue(view ? view->canInvalidatePaintDuringPerformLayout() : false)
+ {
+ if (!m_view)
+ return;
+
+ m_view->setCanInvalidatePaintDuringPerformLayout(true);
+ }
+
+ ~AllowPaintInvalidationScope()
+ {
+ if (!m_view)
+ return;
+
+ m_view->setCanInvalidatePaintDuringPerformLayout(m_originalValue);
+ }
+private:
+ FrameView* m_view;
+ bool m_originalValue;
+};
-} // namespace WebCore
+} // namespace blink
#endif // FrameView_h
projects / platform / framework / web / crosswalk.git / blobdiff