Build fix for SubresourceLoader when building with Core Foundation
[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 "LayoutTypes.h"
31 #include "PaintPhase.h"
32 #include "ScrollView.h"
33 #include <wtf/Forward.h>
34 #include <wtf/OwnPtr.h>
35 #include <wtf/text/WTFString.h>
36
37 namespace WebCore {
38
39 class Color;
40 class Element;
41 class Event;
42 class FloatSize;
43 class Frame;
44 class FrameActionScheduler;
45 class KURL;
46 class Node;
47 class Page;
48 class RenderBox;
49 class RenderEmbeddedObject;
50 class RenderLayer;
51 class RenderObject;
52 class RenderScrollbarPart;
53
54 typedef unsigned long long DOMTimeStamp;
55
56 class FrameView : public ScrollView {
57 public:
58     friend class RenderView;
59     friend class Internals;
60
61     static PassRefPtr<FrameView> create(Frame*);
62     static PassRefPtr<FrameView> create(Frame*, const IntSize& initialSize);
63
64     virtual ~FrameView();
65
66     virtual HostWindow* hostWindow() const;
67     
68     virtual void invalidateRect(const IntRect&);
69     virtual void setFrameRect(const IntRect&);
70
71 #if ENABLE(REQUEST_ANIMATION_FRAME)
72     void scheduleAnimation();
73 #endif
74
75     Frame* frame() const { return m_frame.get(); }
76     void clearFrame();
77
78     LayoutUnit marginWidth() const { return m_margins.width(); } // -1 means default
79     LayoutUnit marginHeight() const { return m_margins.height(); } // -1 means default
80     void setMarginWidth(LayoutUnit);
81     void setMarginHeight(LayoutUnit);
82
83     virtual void setCanHaveScrollbars(bool);
84     void updateCanHaveScrollbars();
85
86     virtual PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
87
88     virtual bool avoidScrollbarCreation() const;
89     virtual void didAddHorizontalScrollbar(Scrollbar*);
90     virtual void willRemoveHorizontalScrollbar(Scrollbar*);
91
92     virtual void setContentsSize(const IntSize&);
93
94     void layout(bool allowSubtree = true);
95     bool didFirstLayout() const;
96     void layoutTimerFired(Timer<FrameView>*);
97     void scheduleRelayout();
98     void scheduleRelayoutOfSubtree(RenderObject*);
99     void unscheduleRelayout();
100     bool layoutPending() const;
101     bool isInLayout() const { return m_inLayout; }
102
103     RenderObject* layoutRoot(bool onlyDuringLayout = false) const;
104     int layoutCount() const { return m_layoutCount; }
105
106     bool needsLayout() const;
107     void setNeedsLayout();
108
109     bool needsFullRepaint() const { return m_doFullRepaint; }
110
111 #if ENABLE(REQUEST_ANIMATION_FRAME)
112     void serviceScriptedAnimations(DOMTimeStamp);
113 #endif
114
115 #if USE(ACCELERATED_COMPOSITING)
116     void updateCompositingLayers();
117     bool syncCompositingStateForThisFrame(Frame* rootFrameForSync);
118
119     void clearBackingStores();
120     void restoreBackingStores();
121
122     // Called when changes to the GraphicsLayer hierarchy have to be synchronized with
123     // content rendered via the normal painting path.
124     void setNeedsOneShotDrawingSynchronization();
125 #endif
126
127     bool hasCompositedContent() const;
128     bool hasCompositedContentIncludingDescendants() const;
129     bool hasCompositingAncestor() const;
130     void enterCompositingMode();
131     bool isEnclosedInCompositingLayer() const;
132
133     // Only used with accelerated compositing, but outside the #ifdef to make linkage easier.
134     // Returns true if the sync was completed.
135     bool syncCompositingStateIncludingSubframes();
136
137     // Returns true when a paint with the PaintBehaviorFlattenCompositingLayers flag set gives
138     // a faithful representation of the content.
139     bool isSoftwareRenderable() const;
140
141     void didMoveOnscreen();
142     void willMoveOffscreen();
143
144     void resetScrollbars();
145     void resetScrollbarsAndClearContentsSize();
146     void detachCustomScrollbars();
147     virtual void recalculateScrollbarOverlayStyle();
148
149     void clear();
150
151     bool isTransparent() const;
152     void setTransparent(bool isTransparent);
153
154     Color baseBackgroundColor() const;
155     void setBaseBackgroundColor(const Color&);
156     void updateBackgroundRecursively(const Color&, bool);
157
158     bool shouldUpdateWhileOffscreen() const;
159     void setShouldUpdateWhileOffscreen(bool);
160     bool shouldUpdate(bool = false) const;
161
162     void adjustViewSize();
163     
164     virtual IntRect windowClipRect(bool clipToContents = true) const;
165     IntRect windowClipRectForLayer(const RenderLayer*, bool clipToLayerContents) const;
166
167     virtual IntRect windowResizerRect() const;
168
169     virtual void setFixedVisibleContentRect(const IntRect&) OVERRIDE;
170     void setScrollPosition(const IntPoint&);
171     void scrollPositionChangedViaPlatformWidget();
172     virtual void repaintFixedElementsAfterScrolling();
173     virtual bool shouldRubberBandInDirection(ScrollDirection) const;
174
175     virtual void zoomAnimatorTransformChanged(float, float, float, ZoomAnimationState);
176
177     String mediaType() const;
178     void setMediaType(const String&);
179     void adjustMediaTypeForPrinting(bool printing);
180
181     void setCannotBlitToWindow();
182     void setIsOverlapped(bool);
183     bool isOverlapped() const { return m_isOverlapped; }
184     bool isOverlappedIncludingAncestors() const;
185     void setContentIsOpaque(bool);
186
187     void addSlowRepaintObject();
188     void removeSlowRepaintObject();
189
190     void addFixedObject();
191     void removeFixedObject();
192
193     // Functions for querying the current scrolled position, negating the effects of overhang
194     // and adjusting for page scale.
195     int scrollXForFixedPosition() const;
196     int scrollYForFixedPosition() const;
197     IntSize scrollOffsetForFixedPosition() const;
198
199     void beginDeferredRepaints();
200     void endDeferredRepaints();
201     void checkStopDelayingDeferredRepaints();
202     void resetDeferredRepaintDelay();
203
204 #if ENABLE(DASHBOARD_SUPPORT)
205     void updateDashboardRegions();
206 #endif
207     void updateControlTints();
208
209     void restoreScrollbar();
210
211     void scheduleEvent(PassRefPtr<Event>, PassRefPtr<Node>);
212     void pauseScheduledEvents();
213     void resumeScheduledEvents();
214     void postLayoutTimerFired(Timer<FrameView>*);
215
216     bool wasScrolledByUser() const;
217     void setWasScrolledByUser(bool);
218
219     void addWidgetToUpdate(RenderEmbeddedObject*);
220     void removeWidgetToUpdate(RenderEmbeddedObject*);
221
222     virtual void paintContents(GraphicsContext*, const IntRect& damageRect);
223     void setPaintBehavior(PaintBehavior);
224     PaintBehavior paintBehavior() const;
225     bool isPainting() const;
226     bool hasEverPainted() const { return m_lastPaintTime; }
227     void setNodeToDraw(Node*);
228
229     virtual void paintOverhangAreas(GraphicsContext*, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect);
230     virtual void paintScrollCorner(GraphicsContext*, const IntRect& cornerRect);
231
232     Color documentBackgroundColor() const;
233
234     static double currentPaintTimeStamp() { return sCurrentPaintTimeStamp; } // returns 0 if not painting
235     
236     void updateLayoutAndStyleIfNeededRecursive();
237     void flushDeferredRepaints();
238
239     void incrementVisuallyNonEmptyCharacterCount(unsigned);
240     void incrementVisuallyNonEmptyPixelCount(const IntSize&);
241     void setIsVisuallyNonEmpty() { m_isVisuallyNonEmpty = true; }
242     bool isVisuallyNonEmpty() const { return m_isVisuallyNonEmpty; }
243     void enableAutoSizeMode(bool enable, const IntSize& minSize, const IntSize& maxSize);
244
245     void forceLayout(bool allowSubtree = false);
246     void forceLayoutForPagination(const FloatSize& pageSize, const FloatSize& originalPageSize, float maximumShrinkFactor, AdjustViewSizeOrNot);
247
248     // FIXME: This method is retained because of embedded WebViews in AppKit.  When a WebView is embedded inside
249     // some enclosing view with auto-pagination, no call happens to resize the view.  The new pagination model
250     // needs the view to resize as a result of the breaks, but that means that the enclosing view has to potentially
251     // resize around that view.  Auto-pagination uses the bounds of the actual view that's being printed to determine
252     // the edges of the print operation, so the resize is necessary if the enclosing view's bounds depend on the
253     // web document's bounds.
254     // 
255     // This is already a problem if the view needs to be a different size because of printer fonts or because of print stylesheets.
256     // Mail/Dictionary work around this problem by using the _layoutForPrinting SPI
257     // to at least get print stylesheets and printer fonts into play, but since WebKit doesn't know about the page offset or
258     // page size, it can't actually paginate correctly during _layoutForPrinting.
259     //
260     // We can eventually move Mail to a newer SPI that would let them opt in to the layout-time pagination model,
261     // but that doesn't solve the general problem of how other AppKit views could opt in to the better model.
262     //
263     // NO OTHER PLATFORM BESIDES MAC SHOULD USE THIS METHOD.
264     void adjustPageHeightDeprecated(float* newBottom, float oldTop, float oldBottom, float bottomLimit);
265
266     bool scrollToFragment(const KURL&);
267     bool scrollToAnchor(const String&);
268     void maintainScrollPositionAtAnchor(Node*);
269     void scrollElementToRect(Element*, const IntRect&);
270
271     // Methods to convert points and rects between the coordinate space of the renderer, and this view.
272     virtual IntRect convertFromRenderer(const RenderObject*, const IntRect&) const;
273     virtual IntRect convertToRenderer(const RenderObject*, const IntRect&) const;
274     virtual IntPoint convertFromRenderer(const RenderObject*, const IntPoint&) const;
275     virtual IntPoint convertToRenderer(const RenderObject*, const IntPoint&) const;
276
277     bool isFrameViewScrollCorner(RenderScrollbarPart* scrollCorner) const { return m_scrollCorner == scrollCorner; }
278
279     void calculateScrollbarModesForLayout(ScrollbarMode& hMode, ScrollbarMode& vMode);
280
281     // Normal delay
282     static void setRepaintThrottlingDeferredRepaintDelay(double p);
283     // Negative value would mean that first few repaints happen without a delay
284     static void setRepaintThrottlingnInitialDeferredRepaintDelayDuringLoading(double p);
285     // The delay grows on each repaint to this maximum value
286     static void setRepaintThrottlingMaxDeferredRepaintDelayDuringLoading(double p);
287     // On each repaint the delay increses by this amount
288     static void setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double p);
289
290     virtual IntPoint currentMousePosition() const;
291
292     // FIXME: Remove this method once plugin loading is decoupled from layout.
293     void flushAnyPendingPostLayoutTasks();
294
295     virtual bool shouldSuspendScrollAnimations() const;
296     virtual void scrollbarStyleChanged(int newStyle, bool forceUpdate);
297
298     void setAnimatorsAreActive();
299
300     RenderBox* embeddedContentBox() const;
301
302     void clearOwningRendererForCustomScrollbars(RenderBox*);
303     
304     void setTracksRepaints(bool);
305     bool isTrackingRepaints() const { return m_isTrackingRepaints; }
306     void resetTrackedRepaints() { m_trackedRepaintRects.clear(); }
307     const Vector<IntRect>& trackedRepaintRects() const { return m_trackedRepaintRects; }
308
309 protected:
310     virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect);
311     virtual void scrollContentsSlowPath(const IntRect& updateRect);
312
313     virtual bool isVerticalDocument() const;
314     virtual bool isFlippedDocument() const;
315
316 private:
317     FrameView(Frame*);
318
319     void reset();
320     void init();
321
322     virtual bool isFrameView() const;
323
324     friend class RenderWidget;
325     bool useSlowRepaints(bool considerOverlap = true) const;
326     bool useSlowRepaintsIfNotOverlapped() const;
327     void updateCanBlitOnScrollRecursively();
328     bool contentsInCompositedLayer() const;
329
330     bool hasFixedObjects() const { return m_fixedObjectCount > 0; }
331
332     void applyOverflowToViewport(RenderObject*, ScrollbarMode& hMode, ScrollbarMode& vMode);
333
334     void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
335
336     void paintControlTints();
337
338     void forceLayoutParentViewIfNeeded();
339     void performPostLayoutTasks();
340     void autoSizeIfEnabled();
341
342     virtual void repaintContentRectangle(const IntRect&, bool immediate);
343     virtual void contentsResized();
344     virtual void visibleContentsResized();
345
346     // Override ScrollView methods to do point conversion via renderers, in order to
347     // take transforms into account.
348     virtual IntRect convertToContainingView(const IntRect&) const;
349     virtual IntRect convertFromContainingView(const IntRect&) const;
350     virtual IntPoint convertToContainingView(const IntPoint&) const;
351     virtual IntPoint convertFromContainingView(const IntPoint&) const;
352
353     // ScrollableArea interface
354     virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&);
355     virtual bool isActive() const;
356     virtual void getTickmarks(Vector<IntRect>&) const;
357     virtual void scrollTo(const IntSize&);
358     virtual void didStartRubberBand(const IntSize&) const;
359     virtual void didCompleteRubberBand(const IntSize&) const;
360     virtual void didStartAnimatedScroll() const;
361     virtual void didCompleteAnimatedScroll() const;
362     virtual void setVisibleScrollerThumbRect(const IntRect&);
363     virtual bool isOnActivePage() const;
364     virtual ScrollableArea* enclosingScrollableArea() const;
365
366 #if USE(ACCELERATED_COMPOSITING)
367     virtual GraphicsLayer* layerForHorizontalScrollbar() const;
368     virtual GraphicsLayer* layerForVerticalScrollbar() const;
369     virtual GraphicsLayer* layerForScrollCorner() const;
370 #if PLATFORM(CHROMIUM) && ENABLE(RUBBER_BANDING)
371     virtual GraphicsLayer* layerForOverhangAreas() const;
372 #endif
373 #endif
374
375     virtual void notifyPageThatContentAreaWillPaint() const;
376     virtual void disconnectFromPage() { m_page = 0; }
377
378     virtual bool scrollAnimatorEnabled() const;
379
380     void deferredRepaintTimerFired(Timer<FrameView>*);
381     void doDeferredRepaints();
382     void updateDeferredRepaintDelay();
383     double adjustedDeferredRepaintDelay() const;
384
385     bool updateWidgets();
386     void updateWidget(RenderEmbeddedObject*);
387     void scrollToAnchor();
388     void scrollPositionChanged();
389
390     bool hasCustomScrollbars() const;
391
392     virtual void updateScrollCorner();
393
394     FrameView* parentFrameView() const;
395
396     virtual AXObjectCache* axObjectCache() const;
397     void notifyWidgetsInAllFrames(WidgetNotification);
398     
399     static double sCurrentPaintTimeStamp; // used for detecting decoded resource thrash in the cache
400
401     LayoutSize m_size;
402     LayoutSize m_margins;
403     
404     typedef HashSet<RenderEmbeddedObject*> RenderEmbeddedObjectSet;
405     OwnPtr<RenderEmbeddedObjectSet> m_widgetUpdateSet;
406     RefPtr<Frame> m_frame;
407
408     bool m_doFullRepaint;
409     
410     bool m_canHaveScrollbars;
411     bool m_cannotBlitToWindow;
412     bool m_isOverlapped;
413     bool m_contentIsOpaque;
414     unsigned m_slowRepaintObjectCount;
415     unsigned m_fixedObjectCount;
416
417     int m_borderX;
418     int m_borderY;
419
420     Timer<FrameView> m_layoutTimer;
421     bool m_delayedLayout;
422     RenderObject* m_layoutRoot;
423     
424     bool m_layoutSchedulingEnabled;
425     bool m_inLayout;
426 #if ENABLE(SVG)
427     bool m_inLayoutParentView;
428 #endif
429     bool m_hasPendingPostLayoutTasks;
430     bool m_inSynchronousPostLayout;
431     int m_layoutCount;
432     unsigned m_nestedLayoutCount;
433     Timer<FrameView> m_postLayoutTasksTimer;
434     bool m_firstLayoutCallbackPending;
435
436     bool m_firstLayout;
437     bool m_isTransparent;
438     Color m_baseBackgroundColor;
439     LayoutSize m_lastLayoutSize;
440     float m_lastZoomFactor;
441
442     String m_mediaType;
443     String m_mediaTypeWhenNotPrinting;
444
445     OwnPtr<FrameActionScheduler> m_actionScheduler;
446
447     bool m_overflowStatusDirty;
448     bool m_horizontalOverflow;
449     bool m_verticalOverflow;    
450     RenderObject* m_viewportRenderer;
451
452     bool m_wasScrolledByUser;
453     bool m_inProgrammaticScroll;
454     
455     unsigned m_deferringRepaints;
456     unsigned m_repaintCount;
457     Vector<LayoutRect> m_repaintRects;
458     Timer<FrameView> m_deferredRepaintTimer;
459     double m_deferredRepaintDelay;
460     double m_lastPaintTime;
461     
462     bool m_isTrackingRepaints; // Used for testing.
463     Vector<IntRect> m_trackedRepaintRects;
464
465     bool m_shouldUpdateWhileOffscreen;
466
467     unsigned m_deferSetNeedsLayouts;
468     bool m_setNeedsLayoutWasDeferred;
469
470     RefPtr<Node> m_nodeToDraw;
471     PaintBehavior m_paintBehavior;
472     bool m_isPainting;
473
474     unsigned m_visuallyNonEmptyCharacterCount;
475     unsigned m_visuallyNonEmptyPixelCount;
476     bool m_isVisuallyNonEmpty;
477     bool m_firstVisuallyNonEmptyLayoutCallbackPending;
478
479     RefPtr<Node> m_maintainScrollPositionAnchor;
480
481     // Renderer to hold our custom scroll corner.
482     RenderScrollbarPart* m_scrollCorner;
483
484     Page* m_page;
485
486     // If true, automatically resize the frame view around its content.
487     bool m_shouldAutoSize;
488     bool m_inAutoSize;
489     // The lower bound on the size when autosizing.
490     IntSize m_minAutoSize;
491     // The upper bound on the size when autosizing.
492     IntSize m_maxAutoSize;
493
494     static double s_deferredRepaintDelay;
495     static double s_initialDeferredRepaintDelayDuringLoading;
496     static double s_maxDeferredRepaintDelayDuringLoading;
497     static double s_deferredRepaintDelayIncrementDuringLoading;
498 };
499
500 inline void FrameView::incrementVisuallyNonEmptyCharacterCount(unsigned count)
501 {
502     if (m_isVisuallyNonEmpty)
503         return;
504     m_visuallyNonEmptyCharacterCount += count;
505     // Use a threshold value to prevent very small amounts of visible content from triggering didFirstVisuallyNonEmptyLayout.
506     // The first few hundred characters rarely contain the interesting content of the page.
507     static const unsigned visualCharacterThreshold = 200;
508     if (m_visuallyNonEmptyCharacterCount > visualCharacterThreshold)
509         setIsVisuallyNonEmpty();
510 }
511
512 inline void FrameView::incrementVisuallyNonEmptyPixelCount(const IntSize& size)
513 {
514     if (m_isVisuallyNonEmpty)
515         return;
516     m_visuallyNonEmptyPixelCount += size.width() * size.height();
517     // Use a threshold value to prevent very small amounts of visible content from triggering didFirstVisuallyNonEmptyLayout
518     static const unsigned visualPixelThreshold = 32 * 32;
519     if (m_visuallyNonEmptyPixelCount > visualPixelThreshold)
520         setIsVisuallyNonEmpty();
521 }
522
523 } // namespace WebCore
524
525 #endif // FrameView_h