96e905f4d167b79be3df094de6e0efde25bbae4d
[WebKit-https.git] / Source / WebCore / page / FrameView.h
1 /*
2    Copyright (C) 1997 Martin Jones (mjones@kde.org)
3              (C) 1998 Waldo Bastian (bastian@kde.org)
4              (C) 1998, 1999 Torben Weis (weis@kde.org)
5              (C) 1999 Lars Knoll (knoll@kde.org)
6              (C) 1999 Antti Koivisto (koivisto@kde.org)
7    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
8
9    This library is free software; you can redistribute it and/or
10    modify it under the terms of the GNU Library General Public
11    License as published by the Free Software Foundation; either
12    version 2 of the License, or (at your option) any later version.
13
14    This library is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17    Library General Public License for more details.
18
19    You should have received a copy of the GNU Library General Public License
20    along with this library; see the file COPYING.LIB.  If not, write to
21    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22    Boston, MA 02110-1301, USA.
23 */
24
25 #ifndef FrameView_h
26 #define FrameView_h
27
28 #include "AdjustViewSizeOrNot.h"
29 #include "Color.h"
30 #include "LayoutMilestones.h"
31 #include "LayoutRect.h"
32 #include "Pagination.h"
33 #include "PaintPhase.h"
34 #include "RenderPtr.h"
35 #include "ScrollView.h"
36 #include <wtf/Forward.h>
37 #include <wtf/ListHashSet.h>
38 #include <wtf/OwnPtr.h>
39 #include <wtf/text/WTFString.h>
40
41 namespace WebCore {
42
43 class AXObjectCache;
44 class Element;
45 class FloatSize;
46 class Frame;
47 class HTMLFrameOwnerElement;
48 class URL;
49 class Node;
50 class Page;
51 class RenderBox;
52 class RenderElement;
53 class RenderEmbeddedObject;
54 class RenderLayer;
55 class RenderObject;
56 class RenderScrollbarPart;
57 class RenderStyle;
58 class RenderView;
59 class RenderWidget;
60
61 Pagination::Mode paginationModeForRenderStyle(const RenderStyle&);
62
63 typedef unsigned long long DOMTimeStamp;
64
65 class FrameView final : public ScrollView {
66 public:
67     friend class RenderView;
68     friend class Internals;
69
70     static PassRefPtr<FrameView> create(Frame&);
71     static PassRefPtr<FrameView> create(Frame&, const IntSize& initialSize);
72
73     virtual ~FrameView();
74
75     virtual HostWindow* hostWindow() const override;
76     
77     virtual void invalidateRect(const IntRect&) override;
78     virtual void setFrameRect(const IntRect&) override;
79
80 #if ENABLE(REQUEST_ANIMATION_FRAME)
81     virtual bool scheduleAnimation() override;
82 #endif
83
84     Frame& frame() const { return *m_frame; }
85
86     RenderView* renderView() const;
87
88     int mapFromLayoutToCSSUnits(LayoutUnit) const;
89     LayoutUnit mapFromCSSToLayoutUnits(int) const;
90
91     LayoutUnit marginWidth() const { return m_margins.width(); } // -1 means default
92     LayoutUnit marginHeight() const { return m_margins.height(); } // -1 means default
93     void setMarginWidth(LayoutUnit);
94     void setMarginHeight(LayoutUnit);
95
96     virtual void setCanHaveScrollbars(bool) override;
97     void updateCanHaveScrollbars();
98
99     virtual PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation) override;
100
101     virtual bool avoidScrollbarCreation() const override;
102
103     virtual void setContentsSize(const IntSize&) override;
104
105     void layout(bool allowSubtree = true);
106     bool didFirstLayout() const;
107     void layoutTimerFired(Timer<FrameView>&);
108     void scheduleRelayout();
109     void scheduleRelayoutOfSubtree(RenderElement&);
110     void unscheduleRelayout();
111     bool layoutPending() const;
112     bool isInLayout() const { return m_layoutPhase == InLayout; }
113
114     RenderObject* layoutRoot(bool onlyDuringLayout = false) const;
115     void clearLayoutRoot() { m_layoutRoot = nullptr; }
116     int layoutCount() const { return m_layoutCount; }
117
118     bool needsLayout() const;
119     void setNeedsLayout();
120     void setViewportConstrainedObjectsNeedLayout();
121
122     bool needsFullRepaint() const { return m_needsFullRepaint; }
123
124     bool renderedCharactersExceed(unsigned threshold);
125
126 #if PLATFORM(IOS)
127     bool useCustomFixedPositionLayoutRect() const { return m_useCustomFixedPositionLayoutRect; }
128     void setUseCustomFixedPositionLayoutRect(bool);
129     IntRect customFixedPositionLayoutRect() const { return m_customFixedPositionLayoutRect; }
130     void setCustomFixedPositionLayoutRect(const IntRect&);
131     bool updateFixedPositionLayoutRect();
132 #else
133     bool useCustomFixedPositionLayoutRect() const { return false; }
134 #endif
135
136 #if ENABLE(REQUEST_ANIMATION_FRAME)
137     void serviceScriptedAnimations(double monotonicAnimationStartTime);
138 #endif
139
140     void updateCompositingLayersAfterStyleChange();
141     void updateCompositingLayersAfterLayout();
142     bool flushCompositingStateForThisFrame(Frame* rootFrameForFlush);
143
144     void clearBackingStores();
145     void restoreBackingStores();
146
147     // Called when changes to the GraphicsLayer hierarchy have to be synchronized with
148     // content rendered via the normal painting path.
149     void setNeedsOneShotDrawingSynchronization();
150
151     GraphicsLayer* graphicsLayerForPlatformWidget(PlatformWidget);
152     void scheduleLayerFlushAllowingThrottling();
153
154     virtual TiledBacking* tiledBacking() const override;
155
156     // In the future when any ScrollableArea can have a node in th ScrollingTree, this should
157     // become a virtual function on ScrollableArea.
158     uint64_t scrollLayerID() const;
159     ScrollableArea* scrollableAreaForScrollLayerID(uint64_t) const;
160
161     bool hasCompositedContent() const;
162     bool hasCompositedContentIncludingDescendants() const;
163     bool hasCompositingAncestor() const;
164     void enterCompositingMode();
165     bool isEnclosedInCompositingLayer() const;
166
167     // Only used with accelerated compositing, but outside the #ifdef to make linkage easier.
168     // Returns true if the flush was completed.
169     bool flushCompositingStateIncludingSubframes();
170
171     // Returns true when a paint with the PaintBehaviorFlattenCompositingLayers flag set gives
172     // a faithful representation of the content.
173     bool isSoftwareRenderable() const;
174
175     void didMoveOnscreen();
176     void willMoveOffscreen();
177     void setIsInWindow(bool);
178
179     void resetScrollbars();
180     void resetScrollbarsAndClearContentsSize();
181     void prepareForDetach();
182     void detachCustomScrollbars();
183     void recalculateScrollbarOverlayStyle();
184
185     void clear();
186
187     bool isTransparent() const;
188     void setTransparent(bool isTransparent);
189     
190     // True if the FrameView is not transparent, and the base background color is opaque.
191     bool hasOpaqueBackground() const;
192
193     Color baseBackgroundColor() const;
194     void setBaseBackgroundColor(const Color&);
195     void updateBackgroundRecursively(const Color&, bool);
196
197     // setBackgroundExtendsBeyondPage() is controlled by Settings::setBackgroundShouldExtendBeyondPage(). Some
198     // extended backgrounds require an extended background rect for painting, (at this time, that corresponds
199     // to documents with background images) and needsExtendedBackgroundRectForPainting() determines if this
200     // FrameView is one of those special FrameViews that does require an extended rect for painting. Since
201     // needing an extended background rect for painting is something that can change in the course of a FrameView's
202     // life, the extended rect is set and unset using setHasExtendedBackgroundRectForPainting(). The
203     // extendedBackgroundRectForPainting() is in the viewport's coordinate space.
204     void setBackgroundExtendsBeyondPage(bool);
205     bool needsExtendedBackgroundRectForPainting() const;
206     void setHasExtendedBackgroundRectForPainting(bool shouldHaveExtendedBackgroundRect);
207     bool hasExtendedBackgroundRectForPainting() const;
208     IntRect extendedBackgroundRectForPainting() const;
209
210     bool shouldUpdateWhileOffscreen() const;
211     void setShouldUpdateWhileOffscreen(bool);
212     bool shouldUpdate() const;
213
214     void adjustViewSize();
215     
216     virtual IntRect windowClipRect(bool clipToContents = true) const override;
217     IntRect windowClipRectForFrameOwner(const HTMLFrameOwnerElement*, bool clipToLayerContents) const;
218
219     virtual IntRect windowResizerRect() const override;
220
221     virtual float visibleContentScaleFactor() const override;
222
223 #if USE(TILED_BACKING_STORE)
224     virtual void setFixedVisibleContentRect(const IntRect&) override;
225 #endif
226     virtual void setScrollPosition(const IntPoint&) override;
227     void scrollPositionChangedViaPlatformWidget(const IntPoint& oldPosition, const IntPoint& newPosition);
228     virtual void updateLayerPositionsAfterScrolling() override;
229     virtual void updateCompositingLayersAfterScrolling() override;
230     virtual bool requestScrollPositionUpdate(const IntPoint&) override;
231     virtual bool isRubberBandInProgress() const override;
232     virtual IntPoint minimumScrollPosition() const override;
233     virtual IntPoint maximumScrollPosition() const override;
234
235     // This is different than visibleContentRect() in that it ignores negative (or overly positive)
236     // offsets from rubber-banding, and it takes zooming into account. 
237     LayoutRect viewportConstrainedVisibleContentRect() const;
238
239     // A rectangle in content coordinates that is used to clip layers for fixed-position objects.
240     LayoutRect viewportConstrainedExtentRect() const;
241
242     String mediaType() const;
243     void setMediaType(const String&);
244     void adjustMediaTypeForPrinting(bool printing);
245
246     void setCannotBlitToWindow();
247     void setIsOverlapped(bool);
248     bool isOverlapped() const { return m_isOverlapped; }
249     bool isOverlappedIncludingAncestors() const;
250     void setContentIsOpaque(bool);
251
252     void addSlowRepaintObject(RenderElement*);
253     void removeSlowRepaintObject(RenderElement*);
254     bool hasSlowRepaintObject(RenderElement* o) const { return m_slowRepaintObjects && m_slowRepaintObjects->contains(o); }
255     bool hasSlowRepaintObjects() const { return m_slowRepaintObjects && m_slowRepaintObjects->size(); }
256
257     // Includes fixed- and sticky-position objects.
258     typedef HashSet<RenderElement*> ViewportConstrainedObjectSet;
259     void addViewportConstrainedObject(RenderElement*);
260     void removeViewportConstrainedObject(RenderElement*);
261     const ViewportConstrainedObjectSet* viewportConstrainedObjects() const { return m_viewportConstrainedObjects.get(); }
262     bool hasViewportConstrainedObjects() const { return m_viewportConstrainedObjects && m_viewportConstrainedObjects->size() > 0; }
263
264     // Functions for querying the current scrolled position, negating the effects of overhang
265     // and adjusting for page scale.
266     LayoutSize scrollOffsetForFixedPosition() const;
267     // Static function can be called from another thread.
268     static LayoutSize scrollOffsetForFixedPosition(const LayoutRect& visibleContentRect, const LayoutSize& totalContentsSize, const LayoutPoint& scrollPosition, const LayoutPoint& scrollOrigin, float frameScaleFactor, bool fixedElementsLayoutRelativeToFrame, ScrollBehaviorForFixedElements, int headerHeight, int footerHeight);
269     
270 #if PLATFORM(IOS)
271     LayoutRect viewportConstrainedObjectsRect() const;
272     // Static function can be called from another thread.
273     static LayoutRect rectForViewportConstrainedObjects(const LayoutRect& visibleContentRect, const LayoutSize& totalContentsSize, float frameScaleFactor, bool fixedElementsLayoutRelativeToFrame, ScrollBehaviorForFixedElements);
274 #endif
275     
276     bool fixedElementsLayoutRelativeToFrame() const;
277
278     void disableLayerFlushThrottlingTemporarilyForInteraction();
279     void updateLayerFlushThrottlingInAllFrames();
280     void adjustTiledBackingCoverage();
281     bool speculativeTilingEnabled() const { return m_speculativeTilingEnabled; }
282
283 #if ENABLE(DASHBOARD_SUPPORT)
284     void updateAnnotatedRegions();
285 #endif
286     void updateControlTints();
287
288     void restoreScrollbar();
289
290     void postLayoutTimerFired(Timer<FrameView>&);
291
292     bool wasScrolledByUser() const;
293     void setWasScrolledByUser(bool);
294
295     bool safeToPropagateScrollToParent() const { return m_safeToPropagateScrollToParent; }
296     void setSafeToPropagateScrollToParent(bool isSafe) { m_safeToPropagateScrollToParent = isSafe; }
297
298     void addEmbeddedObjectToUpdate(RenderEmbeddedObject&);
299     void removeEmbeddedObjectToUpdate(RenderEmbeddedObject&);
300
301     virtual void paintContents(GraphicsContext*, const IntRect& dirtyRect) override;
302
303     struct PaintingState {
304         PaintBehavior paintBehavior;
305         bool isTopLevelPainter;
306         bool isFlatteningPaintOfRootFrame;
307         PaintingState()
308             : paintBehavior()
309             , isTopLevelPainter(false)
310             , isFlatteningPaintOfRootFrame(false)
311         {
312         }
313     };
314
315     void willPaintContents(GraphicsContext*, const IntRect& dirtyRect, PaintingState&);
316     void didPaintContents(GraphicsContext*, const IntRect& dirtyRect, PaintingState&);
317
318     void setPaintBehavior(PaintBehavior);
319     PaintBehavior paintBehavior() const;
320     bool isPainting() const;
321     bool hasEverPainted() const { return m_lastPaintTime; }
322     void setLastPaintTime(double lastPaintTime) { m_lastPaintTime = lastPaintTime; }
323     void setNodeToDraw(Node*);
324
325     enum SelectionInSnapshot { IncludeSelection, ExcludeSelection };
326     enum CoordinateSpaceForSnapshot { DocumentCoordinates, ViewCoordinates };
327     void paintContentsForSnapshot(GraphicsContext*, const IntRect& imageRect, SelectionInSnapshot shouldPaintSelection, CoordinateSpaceForSnapshot);
328
329     virtual void paintOverhangAreas(GraphicsContext*, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect) override;
330     virtual void paintScrollCorner(GraphicsContext*, const IntRect& cornerRect) override;
331     virtual void paintScrollbar(GraphicsContext*, Scrollbar*, const IntRect&) override;
332
333     Color documentBackgroundColor() const;
334
335     bool isInChildFrameWithFrameFlattening() const;
336
337     static double currentPaintTimeStamp() { return sCurrentPaintTimeStamp; } // returns 0 if not painting
338     
339     void updateLayoutAndStyleIfNeededRecursive();
340
341     void incrementVisuallyNonEmptyCharacterCount(unsigned);
342     void incrementVisuallyNonEmptyPixelCount(const IntSize&);
343     void updateIsVisuallyNonEmpty();
344     bool isVisuallyNonEmpty() const { return m_isVisuallyNonEmpty; }
345     void enableAutoSizeMode(bool enable, const IntSize& minSize, const IntSize& maxSize);
346     void setAutoSizeFixedMinimumHeight(int fixedMinimumHeight);
347     IntSize autoSizingIntrinsicContentSize() const { return m_autoSizeContentSize; }
348
349     void forceLayout(bool allowSubtree = false);
350     void forceLayoutForPagination(const FloatSize& pageSize, const FloatSize& originalPageSize, float maximumShrinkFactor, AdjustViewSizeOrNot);
351
352     // FIXME: This method is retained because of embedded WebViews in AppKit.  When a WebView is embedded inside
353     // some enclosing view with auto-pagination, no call happens to resize the view.  The new pagination model
354     // needs the view to resize as a result of the breaks, but that means that the enclosing view has to potentially
355     // resize around that view.  Auto-pagination uses the bounds of the actual view that's being printed to determine
356     // the edges of the print operation, so the resize is necessary if the enclosing view's bounds depend on the
357     // web document's bounds.
358     // 
359     // This is already a problem if the view needs to be a different size because of printer fonts or because of print stylesheets.
360     // Mail/Dictionary work around this problem by using the _layoutForPrinting SPI
361     // to at least get print stylesheets and printer fonts into play, but since WebKit doesn't know about the page offset or
362     // page size, it can't actually paginate correctly during _layoutForPrinting.
363     //
364     // We can eventually move Mail to a newer SPI that would let them opt in to the layout-time pagination model,
365     // but that doesn't solve the general problem of how other AppKit views could opt in to the better model.
366     //
367     // NO OTHER PLATFORM BESIDES MAC SHOULD USE THIS METHOD.
368     void adjustPageHeightDeprecated(float* newBottom, float oldTop, float oldBottom, float bottomLimit);
369
370     bool scrollToFragment(const URL&);
371     bool scrollToAnchor(const String&);
372     void maintainScrollPositionAtAnchor(Node*);
373     void scrollElementToRect(Element*, const IntRect&);
374
375     // Methods to convert points and rects between the coordinate space of the renderer, and this view.
376     IntRect convertFromRenderer(const RenderElement*, const IntRect&) const;
377     IntRect convertToRenderer(const RenderElement*, const IntRect&) const;
378     IntPoint convertFromRenderer(const RenderElement*, const IntPoint&) const;
379     IntPoint convertToRenderer(const RenderElement*, const IntPoint&) const;
380
381     bool isFrameViewScrollCorner(RenderScrollbarPart* scrollCorner) const { return m_scrollCorner == scrollCorner; }
382
383     bool isScrollable();
384
385     enum ScrollbarModesCalculationStrategy { RulesFromWebContentOnly, AnyRule };
386     void calculateScrollbarModesForLayout(ScrollbarMode& hMode, ScrollbarMode& vMode, ScrollbarModesCalculationStrategy = AnyRule);
387
388     virtual IntPoint lastKnownMousePosition() const override;
389     virtual bool isHandlingWheelEvent() const override;
390     bool shouldSetCursor() const;
391
392     // FIXME: Remove this method once plugin loading is decoupled from layout.
393     void flushAnyPendingPostLayoutTasks();
394
395     virtual bool shouldSuspendScrollAnimations() const override;
396     virtual void scrollbarStyleChanged(int newStyle, bool forceUpdate) override;
397
398     RenderBox* embeddedContentBox() const;
399     
400     void setTracksRepaints(bool);
401     bool isTrackingRepaints() const { return m_isTrackingRepaints; }
402     void resetTrackedRepaints();
403     const Vector<FloatRect>& trackedRepaintRects() const { return m_trackedRepaintRects; }
404     String trackedRepaintRectsAsText() const;
405
406     typedef HashSet<ScrollableArea*> ScrollableAreaSet;
407     // Returns whether the scrollable area has just been newly added.
408     bool addScrollableArea(ScrollableArea*);
409     // Returns whether the scrollable area has just been removed.
410     bool removeScrollableArea(ScrollableArea*);
411     bool containsScrollableArea(ScrollableArea*) const;
412     const ScrollableAreaSet* scrollableAreas() const { return m_scrollableAreas.get(); }
413
414     virtual void removeChild(Widget*) override;
415
416     // This function exists for ports that need to handle wheel events manually.
417     // On Mac WebKit1 the underlying NSScrollView just does the scrolling, but on most other platforms
418     // we need this function in order to do the scroll ourselves.
419     bool wheelEvent(const PlatformWheelEvent&);
420
421     void setScrollingPerformanceLoggingEnabled(bool);
422
423     // Page and FrameView both store a Pagination value. Page::pagination() is set only by API,
424     // and FrameView::pagination() is set only by CSS. Page::pagination() will affect all
425     // FrameViews in the page cache, but FrameView::pagination() only affects the current
426     // FrameView. FrameView::pagination() will return m_pagination if it has been set. Otherwise,
427     // it will return Page::pagination() since currently there are no callers that need to
428     // distinguish between the two.
429     const Pagination& pagination() const;
430     void setPagination(const Pagination&);
431     
432     bool inProgrammaticScroll() const { return m_inProgrammaticScroll; }
433     void setInProgrammaticScroll(bool programmaticScroll) { m_inProgrammaticScroll = programmaticScroll; }
434
435 #if ENABLE(CSS_DEVICE_ADAPTATION)
436     IntSize initialViewportSize() const { return m_initialViewportSize; }
437     void setInitialViewportSize(const IntSize& size) { m_initialViewportSize = size; }
438 #endif
439
440     virtual bool isActive() const override;
441     virtual bool updatesScrollLayerPositionOnMainThread() const override;
442
443 #if ENABLE(RUBBER_BANDING)
444     GraphicsLayer* setWantsLayerForTopOverHangArea(bool) const;
445     GraphicsLayer* setWantsLayerForBottomOverHangArea(bool) const;
446 #endif
447
448     virtual int headerHeight() const override { return m_headerHeight; }
449     void setHeaderHeight(int);
450     virtual int footerHeight() const override { return m_footerHeight; }
451     void setFooterHeight(int);
452
453     virtual float topContentInset() const override;
454
455     virtual void willStartLiveResize() override;
456     virtual void willEndLiveResize() override;
457
458     void addPaintPendingMilestones(LayoutMilestones);
459     void firePaintRelatedMilestonesIfNeeded();
460     void fireLayoutRelatedMilestonesIfNeeded();
461     LayoutMilestones milestonesPendingPaint() const { return m_milestonesPendingPaint; }
462
463     bool visualUpdatesAllowedByClient() const { return m_visualUpdatesAllowedByClient; }
464     void setVisualUpdatesAllowedByClient(bool);
465
466     void setScrollPinningBehavior(ScrollPinningBehavior);
467
468     ScrollBehaviorForFixedElements scrollBehaviorForFixedElements() const;
469
470     void updateWidgetPositions();
471     void didAddWidgetToRenderTree(Widget&);
472     void willRemoveWidgetFromRenderTree(Widget&);
473
474     void addTrackedRepaintRect(const FloatRect&);
475
476     // exposedRect represents WebKit's understanding of what part
477     // of the view is actually exposed on screen (taking into account
478     // clipping by other UI elements), whereas visibleContentRect is
479     // internal to WebCore and doesn't respect those things.
480     void setExposedRect(FloatRect);
481     FloatRect exposedRect() const { return m_exposedRect; }
482
483 protected:
484     virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect) override;
485     virtual void scrollContentsSlowPath(const IntRect& updateRect) override;
486     
487     void repaintSlowRepaintObjects();
488
489     virtual bool isVerticalDocument() const override;
490     virtual bool isFlippedDocument() const override;
491
492 private:
493     explicit FrameView(Frame&);
494
495     void reset();
496     void init();
497
498     enum LayoutPhase {
499         OutsideLayout,
500         InPreLayout,
501         InPreLayoutStyleUpdate,
502         InLayout,
503         InViewSizeAdjust,
504         InPostLayout,
505     };
506     LayoutPhase layoutPhase() const { return m_layoutPhase; }
507
508     bool inPreLayoutStyleUpdate() const { return m_layoutPhase == InPreLayoutStyleUpdate; }
509
510     virtual bool isFrameView() const override { return true; }
511
512     friend class RenderWidget;
513     bool useSlowRepaints(bool considerOverlap = true) const;
514     bool useSlowRepaintsIfNotOverlapped() const;
515     void updateCanBlitOnScrollRecursively();
516     bool contentsInCompositedLayer() const;
517     bool shouldLayoutAfterContentsResized() const;
518
519     bool shouldUpdateCompositingLayersAfterScrolling() const;
520
521     void applyOverflowToViewport(RenderElement*, ScrollbarMode& hMode, ScrollbarMode& vMode);
522     void applyPaginationToViewport();
523
524     void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
525
526     void paintControlTints();
527
528     void forceLayoutParentViewIfNeeded();
529     void performPostLayoutTasks();
530     void autoSizeIfEnabled();
531
532     virtual void repaintContentRectangle(const IntRect&) override;
533     virtual void contentsResized() override;
534     virtual void visibleContentsResized() override;
535     virtual void addedOrRemovedScrollbar() override;
536     virtual void fixedLayoutSizeChanged() override;
537
538     virtual void delegatesScrollingDidChange() override;
539
540     // Override ScrollView methods to do point conversion via renderers, in order to
541     // take transforms into account.
542     virtual IntRect convertToContainingView(const IntRect&) const override;
543     virtual IntRect convertFromContainingView(const IntRect&) const override;
544     virtual IntPoint convertToContainingView(const IntPoint&) const override;
545     virtual IntPoint convertFromContainingView(const IntPoint&) const override;
546
547     // ScrollableArea interface
548     virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) override;
549     virtual void scrollTo(const IntSize&) override;
550     virtual void setVisibleScrollerThumbRect(const IntRect&) override;
551     virtual ScrollableArea* enclosingScrollableArea() const override;
552     virtual IntRect scrollableAreaBoundingBox() const override;
553     virtual bool scrollAnimatorEnabled() const override;
554     virtual bool usesCompositedScrolling() const override;
555     virtual GraphicsLayer* layerForScrolling() const override;
556     virtual GraphicsLayer* layerForHorizontalScrollbar() const override;
557     virtual GraphicsLayer* layerForVerticalScrollbar() const override;
558     virtual GraphicsLayer* layerForScrollCorner() const override;
559 #if ENABLE(RUBBER_BANDING)
560     virtual GraphicsLayer* layerForOverhangAreas() const override;
561 #endif
562
563     // Override scrollbar notifications to update the AXObject cache.
564     virtual void didAddScrollbar(Scrollbar*, ScrollbarOrientation) override;
565     virtual void willRemoveScrollbar(Scrollbar*, ScrollbarOrientation) override;
566
567     void sendResizeEventIfNeeded();
568
569     void updateScrollableAreaSet();
570
571     virtual void notifyPageThatContentAreaWillPaint() const override;
572
573     void enableSpeculativeTilingIfNeeded();
574     void speculativeTilingEnableTimerFired(Timer<FrameView>&);
575
576     bool updateEmbeddedObjects();
577     void updateEmbeddedObject(RenderEmbeddedObject&);
578     void scrollToAnchor();
579     void scrollPositionChanged(const IntPoint& oldPosition, const IntPoint& newPosition);
580
581     bool hasCustomScrollbars() const;
582
583     virtual void updateScrollCorner() override;
584
585     FrameView* parentFrameView() const;
586
587     void startLayoutAtMainFrameViewIfNeeded(bool allowSubtree);
588     bool frameFlatteningEnabled() const;
589     bool isFrameFlatteningValidForThisFrame() const;
590
591     bool qualifiesAsVisuallyNonEmpty() const;
592
593     AXObjectCache* axObjectCache() const;
594     void notifyWidgetsInAllFrames(WidgetNotification);
595     void removeFromAXObjectCache();
596     void notifyWidgets(WidgetNotification);
597
598     HashSet<Widget*> m_widgetsInRenderTree;
599
600     static double sCurrentPaintTimeStamp; // used for detecting decoded resource thrash in the cache
601
602     LayoutSize m_size;
603     LayoutSize m_margins;
604
605     OwnPtr<ListHashSet<RenderEmbeddedObject*>> m_embeddedObjectsToUpdate;
606     const RefPtr<Frame> m_frame;
607
608     OwnPtr<HashSet<RenderElement*>> m_slowRepaintObjects;
609
610     bool m_needsFullRepaint;
611     
612     bool m_canHaveScrollbars;
613     bool m_cannotBlitToWindow;
614     bool m_isOverlapped;
615     bool m_contentIsOpaque;
616
617     int m_borderX;
618     int m_borderY;
619
620     Timer<FrameView> m_layoutTimer;
621     bool m_delayedLayout;
622     RenderElement* m_layoutRoot;
623
624     LayoutPhase m_layoutPhase;
625     bool m_layoutSchedulingEnabled;
626     bool m_inSynchronousPostLayout;
627     int m_layoutCount;
628     unsigned m_nestedLayoutCount;
629     Timer<FrameView> m_postLayoutTasksTimer;
630     bool m_firstLayoutCallbackPending;
631
632     bool m_firstLayout;
633     bool m_isTransparent;
634     Color m_baseBackgroundColor;
635     IntSize m_lastViewportSize;
636     float m_lastZoomFactor;
637
638     String m_mediaType;
639     String m_mediaTypeWhenNotPrinting;
640
641     bool m_overflowStatusDirty;
642     bool m_horizontalOverflow;
643     bool m_verticalOverflow;    
644     RenderElement* m_viewportRenderer;
645
646     Pagination m_pagination;
647
648     bool m_wasScrolledByUser;
649     bool m_inProgrammaticScroll;
650     bool m_safeToPropagateScrollToParent;
651
652     double m_lastPaintTime;
653
654     bool m_isTrackingRepaints; // Used for testing.
655     Vector<FloatRect> m_trackedRepaintRects;
656
657     bool m_shouldUpdateWhileOffscreen;
658
659     FloatRect m_exposedRect;
660
661     unsigned m_deferSetNeedsLayouts;
662     bool m_setNeedsLayoutWasDeferred;
663
664     RefPtr<Node> m_nodeToDraw;
665     PaintBehavior m_paintBehavior;
666     bool m_isPainting;
667
668     unsigned m_visuallyNonEmptyCharacterCount;
669     unsigned m_visuallyNonEmptyPixelCount;
670     bool m_isVisuallyNonEmpty;
671     bool m_firstVisuallyNonEmptyLayoutCallbackPending;
672
673     RefPtr<Node> m_maintainScrollPositionAnchor;
674
675     // Renderer to hold our custom scroll corner.
676     RenderPtr<RenderScrollbarPart> m_scrollCorner;
677
678     bool m_speculativeTilingEnabled;
679     Timer<FrameView> m_speculativeTilingEnableTimer;
680
681 #if PLATFORM(IOS)
682     bool m_useCustomFixedPositionLayoutRect;
683     IntRect m_customFixedPositionLayoutRect;
684 #endif
685
686     // If true, automatically resize the frame view around its content.
687     bool m_shouldAutoSize;
688     bool m_inAutoSize;
689     // True if autosize has been run since m_shouldAutoSize was set.
690     bool m_didRunAutosize;
691     // The lower bound on the size when autosizing.
692     IntSize m_minAutoSize;
693     // The upper bound on the size when autosizing.
694     IntSize m_maxAutoSize;
695     // The fixed height to resize the view to after autosizing is complete.
696     int m_autoSizeFixedMinimumHeight;
697     // The intrinsic content size decided by autosizing.
698     IntSize m_autoSizeContentSize;
699
700     OwnPtr<ScrollableAreaSet> m_scrollableAreas;
701     OwnPtr<ViewportConstrainedObjectSet> m_viewportConstrainedObjects;
702
703     int m_headerHeight;
704     int m_footerHeight;
705
706     LayoutMilestones m_milestonesPendingPaint;
707
708     static const unsigned visualCharacterThreshold = 200;
709     static const unsigned visualPixelThreshold = 32 * 32;
710
711 #if ENABLE(CSS_DEVICE_ADAPTATION)
712     // Size of viewport before any UA or author styles have overridden
713     // the viewport given by the window or viewing area of the UA.
714     IntSize m_initialViewportSize;
715 #endif
716
717     bool m_visualUpdatesAllowedByClient;
718     
719     ScrollPinningBehavior m_scrollPinningBehavior;
720 };
721
722 inline void FrameView::incrementVisuallyNonEmptyCharacterCount(unsigned count)
723 {
724     if (m_isVisuallyNonEmpty)
725         return;
726     m_visuallyNonEmptyCharacterCount += count;
727     if (m_visuallyNonEmptyCharacterCount <= visualCharacterThreshold)
728         return;
729     updateIsVisuallyNonEmpty();
730 }
731
732 inline void FrameView::incrementVisuallyNonEmptyPixelCount(const IntSize& size)
733 {
734     if (m_isVisuallyNonEmpty)
735         return;
736     m_visuallyNonEmptyPixelCount += size.width() * size.height();
737     if (m_visuallyNonEmptyPixelCount <= visualPixelThreshold)
738         return;
739     updateIsVisuallyNonEmpty();
740 }
741
742 WIDGET_TYPE_CASTS(FrameView, isFrameView());
743
744 } // namespace WebCore
745
746 #endif // FrameView_h