2009-06-29 Simon Fraser <simon.fraser@apple.com>
[WebKit-https.git] / WebCore / page / FrameView.cpp
1 /*
2  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
3  *                     1999 Lars Knoll <knoll@kde.org>
4  *                     1999 Antti Koivisto <koivisto@kde.org>
5  *                     2000 Dirk Mueller <mueller@kde.org>
6  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
7  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
8  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
9  * Copyright (C) 2009 Google Inc. All rights reserved.
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Library General Public
13  * License as published by the Free Software Foundation; either
14  * version 2 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Library General Public License for more details.
20  *
21  * You should have received a copy of the GNU Library General Public License
22  * along with this library; see the file COPYING.LIB.  If not, write to
23  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24  * Boston, MA 02110-1301, USA.
25  */
26
27 #include "config.h"
28 #include "FrameView.h"
29
30 #include "AXObjectCache.h"
31 #include "CSSStyleSelector.h"
32 #include "ChromeClient.h"
33 #include "DocLoader.h"
34 #include "EventHandler.h"
35 #include "FloatRect.h"
36 #include "FocusController.h"
37 #include "Frame.h"
38 #include "FrameLoader.h"
39 #include "FrameLoaderClient.h"
40 #include "FrameTree.h"
41 #include "GraphicsContext.h"
42 #include "HTMLDocument.h"
43 #include "HTMLFrameElement.h"
44 #include "HTMLFrameSetElement.h"
45 #include "HTMLNames.h"
46 #include "OverflowEvent.h"
47 #include "Page.h"
48 #include "RenderPart.h"
49 #include "RenderPartObject.h"
50 #include "RenderScrollbar.h"
51 #include "RenderTheme.h"
52 #include "RenderView.h"
53 #include "Settings.h"
54 #include <wtf/CurrentTime.h>
55
56 #if USE(ACCELERATED_COMPOSITING)
57 #include "RenderLayerCompositor.h"
58 #endif
59
60 namespace WebCore {
61
62 using namespace HTMLNames;
63
64 double FrameView::sCurrentPaintTimeStamp = 0.0;
65
66 #if ENABLE(REPAINT_THROTTLING)
67 // Normal delay
68 static const double deferredRepaintDelay = 0.025;
69 // Negative value would mean that first few repaints happen without a delay
70 static const double initialDeferredRepaintDelayDuringLoading = 0;
71 // The delay grows on each repaint to this maximum value
72 static const double maxDeferredRepaintDelayDuringLoading = 2.5;
73 // On each repaint the delay increses by this amount
74 static const double deferredRepaintDelayIncrementDuringLoading = 0.5;
75 #else
76 // FIXME: Repaint throttling could be good to have on all platform.
77 // The balance between CPU use and repaint frequency will need some tuning for desktop.
78 // More hooks may be needed to reset the delay on things like GIF and CSS animations.
79 static const double deferredRepaintDelay = 0;
80 static const double initialDeferredRepaintDelayDuringLoading = 0;
81 static const double maxDeferredRepaintDelayDuringLoading = 0;
82 static const double deferredRepaintDelayIncrementDuringLoading = 0;
83 #endif
84
85 // The maximum number of updateWidgets iterations that should be done before returning.
86 static const unsigned maxUpdateWidgetsIterations = 2;
87
88 struct ScheduledEvent {
89     RefPtr<Event> m_event;
90     RefPtr<Node> m_eventTarget;
91 };
92
93 FrameView::FrameView(Frame* frame)
94     : m_frame(frame)
95     , m_vmode(ScrollbarAuto)
96     , m_hmode(ScrollbarAuto)
97     , m_slowRepaintObjectCount(0)
98     , m_layoutTimer(this, &FrameView::layoutTimerFired)
99     , m_layoutRoot(0)
100     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
101     , m_needToInitScrollbars(true)
102     , m_isTransparent(false)
103     , m_baseBackgroundColor(Color::white)
104     , m_mediaType("screen")
105     , m_enqueueEvents(0)
106     , m_overflowStatusDirty(true)
107     , m_viewportRenderer(0)
108     , m_wasScrolledByUser(false)
109     , m_inProgrammaticScroll(false)
110     , m_deferredRepaintTimer(this, &FrameView::deferredRepaintTimerFired)
111     , m_shouldUpdateWhileOffscreen(true)
112     , m_deferSetNeedsLayouts(0)
113     , m_setNeedsLayoutWasDeferred(false)
114     , m_lockedToAnchor(false)
115 {
116     init();
117 }
118
119 PassRefPtr<FrameView> FrameView::create(Frame* frame)
120 {
121     RefPtr<FrameView> view = adoptRef(new FrameView(frame));
122     view->show();
123     return view.release();
124 }
125
126 PassRefPtr<FrameView> FrameView::create(Frame* frame, const IntSize& initialSize)
127 {
128     RefPtr<FrameView> view = adoptRef(new FrameView(frame));
129     view->Widget::setFrameRect(IntRect(view->pos(), initialSize));
130     view->show();
131     return view.release();
132 }
133
134 FrameView::~FrameView()
135 {
136     if (m_postLayoutTasksTimer.isActive()) {
137         m_postLayoutTasksTimer.stop();
138         m_scheduledEvents.clear();
139         m_enqueueEvents = 0;
140     }
141
142     resetScrollbars();
143     setHasHorizontalScrollbar(false); // Remove native scrollbars now before we lose the connection to the HostWindow.
144     setHasVerticalScrollbar(false);
145     
146     ASSERT(m_scheduledEvents.isEmpty());
147     ASSERT(!m_enqueueEvents);
148
149     if (m_frame) {
150         ASSERT(m_frame->view() != this || !m_frame->contentRenderer());
151         RenderPart* renderer = m_frame->ownerRenderer();
152         if (renderer && renderer->widget() == this)
153             renderer->setWidget(0);
154     }
155 }
156
157 void FrameView::reset()
158 {
159     m_useSlowRepaints = false;
160     m_isOverlapped = false;
161     m_contentIsOpaque = false;
162     m_borderX = 30;
163     m_borderY = 30;
164     m_layoutTimer.stop();
165     m_layoutRoot = 0;
166     m_delayedLayout = false;
167     m_doFullRepaint = true;
168     m_layoutSchedulingEnabled = true;
169     m_midLayout = false;
170     m_layoutCount = 0;
171     m_nestedLayoutCount = 0;
172     m_postLayoutTasksTimer.stop();
173     m_firstLayout = true;
174     m_firstLayoutCallbackPending = false;
175     m_wasScrolledByUser = false;
176     m_lastLayoutSize = IntSize();
177     m_lastZoomFactor = 1.0f;
178     m_deferringRepaints = 0;
179     m_repaintCount = 0;
180     m_repaintRects.clear();
181     m_deferredRepaintDelay = initialDeferredRepaintDelayDuringLoading;
182     m_deferredRepaintTimer.stop();
183     m_lastPaintTime = 0;
184     m_paintRestriction = PaintRestrictionNone;
185     m_isPainting = false;
186     m_isVisuallyNonEmpty = false;
187     m_firstVisuallyNonEmptyLayoutCallbackPending = true;
188     m_lockedToAnchor = false;
189 }
190
191 bool FrameView::isFrameView() const 
192
193     return true; 
194 }
195
196 void FrameView::clearFrame()
197 {
198     m_frame = 0;
199 }
200
201 void FrameView::resetScrollbars()
202 {
203     // Reset the document's scrollbars back to our defaults before we yield the floor.
204     m_firstLayout = true;
205     setScrollbarsSuppressed(true);
206     setScrollbarModes(m_hmode, m_vmode);
207     setScrollbarsSuppressed(false);
208 }
209
210 void FrameView::init()
211 {
212     reset();
213
214     m_margins = IntSize(-1, -1); // undefined
215     m_size = IntSize();
216
217     // Propagate the marginwidth/height and scrolling modes to the view.
218     Element* ownerElement = m_frame && m_frame->document() ? m_frame->document()->ownerElement() : 0;
219     if (ownerElement && (ownerElement->hasTagName(frameTag) || ownerElement->hasTagName(iframeTag))) {
220         HTMLFrameElement* frameElt = static_cast<HTMLFrameElement*>(ownerElement);
221         if (frameElt->scrollingMode() == ScrollbarAlwaysOff)
222             setCanHaveScrollbars(false);
223         int marginWidth = frameElt->getMarginWidth();
224         int marginHeight = frameElt->getMarginHeight();
225         if (marginWidth != -1)
226             setMarginWidth(marginWidth);
227         if (marginHeight != -1)
228             setMarginHeight(marginHeight);
229     }
230 }
231
232 void FrameView::detachCustomScrollbars()
233 {
234     if (!m_frame)
235         return;
236
237     Document* document = m_frame->document();
238     if (!document)
239         return;
240
241     Element* body = document->body();
242     if (!body)
243         return;
244
245     RenderBox* renderBox = body->renderBox();
246
247     Scrollbar* horizontalBar = horizontalScrollbar();
248     if (horizontalBar && horizontalBar->isCustomScrollbar() && reinterpret_cast<RenderScrollbar*>(horizontalBar)->owningRenderer() == renderBox)
249         setHasHorizontalScrollbar(false);
250
251     Scrollbar* verticalBar = verticalScrollbar();
252     if (verticalBar && verticalBar->isCustomScrollbar() && reinterpret_cast<RenderScrollbar*>(verticalBar)->owningRenderer() == renderBox)
253         setHasVerticalScrollbar(false);
254 }
255
256 void FrameView::clear()
257 {
258     setCanBlitOnScroll(true);
259     
260     reset();
261
262     if (m_frame) {
263         if (RenderPart* renderer = m_frame->ownerRenderer())
264             renderer->viewCleared();
265     }
266
267     setScrollbarsSuppressed(true);
268 }
269
270 bool FrameView::didFirstLayout() const
271 {
272     return !m_firstLayout;
273 }
274
275 void FrameView::initScrollbars()
276 {
277     if (!m_needToInitScrollbars)
278         return;
279     m_needToInitScrollbars = false;
280     updateDefaultScrollbarState();
281 }
282
283 void FrameView::updateDefaultScrollbarState()
284 {
285     m_hmode = horizontalScrollbarMode();
286     m_vmode = verticalScrollbarMode();
287     setScrollbarModes(m_hmode, m_vmode);
288 }
289
290 void FrameView::invalidateRect(const IntRect& rect)
291 {
292     if (!parent()) {
293         if (hostWindow())
294             hostWindow()->repaint(rect, true);
295         return;
296     }
297
298     if (!m_frame)
299         return;
300
301     RenderPart* renderer = m_frame->ownerRenderer();
302     if (!renderer)
303         return;
304
305     IntRect repaintRect = rect;
306     repaintRect.move(renderer->borderLeft() + renderer->paddingLeft(),
307                      renderer->borderTop() + renderer->paddingTop());
308     renderer->repaintRectangle(repaintRect);
309 }
310
311 void FrameView::setMarginWidth(int w)
312 {
313     // make it update the rendering area when set
314     m_margins.setWidth(w);
315 }
316
317 void FrameView::setMarginHeight(int h)
318 {
319     // make it update the rendering area when set
320     m_margins.setHeight(h);
321 }
322
323 void FrameView::setCanHaveScrollbars(bool canScroll)
324 {
325     ScrollView::setCanHaveScrollbars(canScroll);
326     scrollbarModes(m_hmode, m_vmode);
327 }
328
329 PassRefPtr<Scrollbar> FrameView::createScrollbar(ScrollbarOrientation orientation)
330 {
331     // FIXME: We need to update the scrollbar dynamically as documents change (or as doc elements and bodies get discovered that have custom styles).
332     Document* doc = m_frame->document();
333
334     // Try the <body> element first as a scrollbar source.
335     Element* body = doc ? doc->body() : 0;
336     if (body && body->renderer() && body->renderer()->style()->hasPseudoStyle(SCROLLBAR))
337         return RenderScrollbar::createCustomScrollbar(this, orientation, body->renderBox());
338     
339     // If the <body> didn't have a custom style, then the root element might.
340     Element* docElement = doc ? doc->documentElement() : 0;
341     if (docElement && docElement->renderer() && docElement->renderer()->style()->hasPseudoStyle(SCROLLBAR))
342         return RenderScrollbar::createCustomScrollbar(this, orientation, docElement->renderBox());
343         
344     // If we have an owning iframe/frame element, then it can set the custom scrollbar also.
345     RenderPart* frameRenderer = m_frame->ownerRenderer();
346     if (frameRenderer && frameRenderer->style()->hasPseudoStyle(SCROLLBAR))
347         return RenderScrollbar::createCustomScrollbar(this, orientation, frameRenderer);
348     
349     // Nobody set a custom style, so we just use a native scrollbar.
350     return ScrollView::createScrollbar(orientation);
351 }
352
353 void FrameView::setContentsSize(const IntSize& size)
354 {
355     m_deferSetNeedsLayouts++;
356
357     ScrollView::setContentsSize(size);
358
359     Page* page = frame() ? frame()->page() : 0;
360     if (!page)
361         return;
362
363     page->chrome()->contentsSizeChanged(frame(), size); //notify only
364     
365     m_deferSetNeedsLayouts--;
366     
367     if (!m_deferSetNeedsLayouts)
368         m_setNeedsLayoutWasDeferred = false; // FIXME: Find a way to make the deferred layout actually happen.
369 }
370
371 void FrameView::adjustViewSize()
372 {
373     ASSERT(m_frame->view() == this);
374     RenderView* root = m_frame->contentRenderer();
375     if (!root)
376         return;
377     setContentsSize(IntSize(root->overflowWidth(), root->overflowHeight()));
378 }
379
380 void FrameView::applyOverflowToViewport(RenderObject* o, ScrollbarMode& hMode, ScrollbarMode& vMode)
381 {
382     // Handle the overflow:hidden/scroll case for the body/html elements.  WinIE treats
383     // overflow:hidden and overflow:scroll on <body> as applying to the document's
384     // scrollbars.  The CSS2.1 draft states that HTML UAs should use the <html> or <body> element and XML/XHTML UAs should
385     // use the root element.
386     switch (o->style()->overflowX()) {
387         case OHIDDEN:
388             hMode = ScrollbarAlwaysOff;
389             break;
390         case OSCROLL:
391             hMode = ScrollbarAlwaysOn;
392             break;
393         case OAUTO:
394             hMode = ScrollbarAuto;
395             break;
396         default:
397             // Don't set it at all.
398             ;
399     }
400     
401      switch (o->style()->overflowY()) {
402         case OHIDDEN:
403             vMode = ScrollbarAlwaysOff;
404             break;
405         case OSCROLL:
406             vMode = ScrollbarAlwaysOn;
407             break;
408         case OAUTO:
409             vMode = ScrollbarAuto;
410             break;
411         default:
412             // Don't set it at all.
413             ;
414     }
415
416     m_viewportRenderer = o;
417 }
418
419 #if USE(ACCELERATED_COMPOSITING)
420 void FrameView::updateCompositingLayers(CompositingUpdate updateType)
421 {
422     RenderView* view = m_frame->contentRenderer();
423     if (view && view->compositor()) {
424         // This call will make sure the cached hasAcceleratedCompositing is updated from the pref
425         view->compositor()->cacheAcceleratedCompositingEnabledFlag();
426     }
427     
428     if (!view || !view->usesCompositing())
429         return;
430
431     if (updateType == ForcedCompositingUpdate)
432         view->compositor()->setCompositingLayersNeedUpdate();
433     
434     view->compositor()->updateCompositingLayers();
435 }
436
437 void FrameView::setNeedsOneShotDrawingSynchronization()
438 {
439     Page* page = frame() ? frame()->page() : 0;
440     if (page)
441         page->chrome()->client()->setNeedsOneShotDrawingSynchronization();
442 }
443 #endif // USE(ACCELERATED_COMPOSITING)
444
445 void FrameView::didMoveOnscreen()
446 {
447     RenderView* view = m_frame->contentRenderer();
448     if (view)
449         view->didMoveOnscreen();
450 }
451
452 void FrameView::willMoveOffscreen()
453 {
454     RenderView* view = m_frame->contentRenderer();
455     if (view)
456         view->willMoveOffscreen();
457 }
458
459 RenderObject* FrameView::layoutRoot(bool onlyDuringLayout) const
460 {
461     return onlyDuringLayout && layoutPending() ? 0 : m_layoutRoot;
462 }
463
464 void FrameView::layout(bool allowSubtree)
465 {
466     if (m_midLayout)
467         return;
468
469     m_layoutTimer.stop();
470     m_delayedLayout = false;
471     m_setNeedsLayoutWasDeferred = false;
472
473     // Protect the view from being deleted during layout (in recalcStyle)
474     RefPtr<FrameView> protector(this);
475
476     if (!m_frame) {
477         // FIXME: Do we need to set m_size.width here?
478         // FIXME: Should we set m_size.height here too?
479         m_size.setWidth(layoutWidth());
480         return;
481     }
482     
483     // we shouldn't enter layout() while painting
484     ASSERT(!isPainting());
485     if (isPainting())
486         return;
487
488     if (!allowSubtree && m_layoutRoot) {
489         m_layoutRoot->markContainingBlocksForLayout(false);
490         m_layoutRoot = 0;
491     }
492
493     ASSERT(m_frame->view() == this);
494     // This early return should be removed when rdar://5598072 is resolved. In the meantime, there is a
495     // gigantic CrashTracer because of this issue, and the early return will hopefully cause graceful 
496     // failure instead.  
497     if (m_frame->view() != this)
498         return;
499
500     Document* document = m_frame->document();
501
502     m_layoutSchedulingEnabled = false;
503
504     if (!m_nestedLayoutCount && m_postLayoutTasksTimer.isActive()) {
505         // This is a new top-level layout. If there are any remaining tasks from the previous
506         // layout, finish them now.
507         m_postLayoutTasksTimer.stop();
508         performPostLayoutTasks();
509     }
510
511     // Viewport-dependent media queries may cause us to need completely different style information.
512     // Check that here.
513     if (document->styleSelector()->affectedByViewportChange())
514         document->updateStyleSelector();
515
516     // Always ensure our style info is up-to-date.  This can happen in situations where
517     // the layout beats any sort of style recalc update that needs to occur.
518     if (m_frame->needsReapplyStyles())
519         m_frame->reapplyStyles();
520     else if (document->childNeedsStyleRecalc())
521         document->recalcStyle();
522     
523     bool subtree = m_layoutRoot;
524
525     // If there is only one ref to this view left, then its going to be destroyed as soon as we exit, 
526     // so there's no point to continuing to layout
527     if (protector->hasOneRef())
528         return;
529
530     RenderObject* root = subtree ? m_layoutRoot : document->renderer();
531     if (!root) {
532         // FIXME: Do we need to set m_size here?
533         m_layoutSchedulingEnabled = true;
534         return;
535     }
536
537     m_nestedLayoutCount++;
538
539     ScrollbarMode hMode = m_hmode;
540     ScrollbarMode vMode = m_vmode;
541
542     if (!subtree) {
543         RenderObject* rootRenderer = document->documentElement() ? document->documentElement()->renderer() : 0;
544         Node* body = document->body();
545         if (body && body->renderer()) {
546             if (body->hasTagName(framesetTag)) {
547                 body->renderer()->setChildNeedsLayout(true);
548                 vMode = ScrollbarAlwaysOff;
549                 hMode = ScrollbarAlwaysOff;
550             } else if (body->hasTagName(bodyTag)) {
551                 if (!m_firstLayout && m_size.height() != layoutHeight()
552                         && toRenderBox(body->renderer())->stretchesToViewHeight())
553                     body->renderer()->setChildNeedsLayout(true);
554                 // It's sufficient to just check the X overflow,
555                 // since it's illegal to have visible in only one direction.
556                 RenderObject* o = rootRenderer->style()->overflowX() == OVISIBLE && document->documentElement()->hasTagName(htmlTag) ? body->renderer() : rootRenderer;
557                 applyOverflowToViewport(o, hMode, vMode);
558             }
559         } else if (rootRenderer)
560             applyOverflowToViewport(rootRenderer, hMode, vMode);
561 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
562         if (m_firstLayout && !document->ownerElement())
563             printf("Elapsed time before first layout: %d\n", document->elapsedTime());
564 #endif
565     }
566
567     m_doFullRepaint = !subtree && (m_firstLayout || toRenderView(root)->printing());
568
569     if (!subtree) {
570         // Now set our scrollbar state for the layout.
571         ScrollbarMode currentHMode = horizontalScrollbarMode();
572         ScrollbarMode currentVMode = verticalScrollbarMode();
573
574         if (m_firstLayout || (hMode != currentHMode || vMode != currentVMode)) {
575             setScrollbarsSuppressed(true);
576             if (m_firstLayout) {
577                 m_firstLayout = false;
578                 m_firstLayoutCallbackPending = true;
579                 m_lastLayoutSize = IntSize(width(), height());
580                 m_lastZoomFactor = root->style()->zoom();
581
582                 // Set the initial vMode to AlwaysOn if we're auto.
583                 if (vMode == ScrollbarAuto)
584                     setVerticalScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear.
585                 // Set the initial hMode to AlwaysOff if we're auto.
586                 if (hMode == ScrollbarAuto)
587                     setHorizontalScrollbarMode(ScrollbarAlwaysOff); // This causes a horizontal scrollbar to disappear.
588             }
589             setScrollbarModes(hMode, vMode);
590             setScrollbarsSuppressed(false, true);
591         }
592
593         IntSize oldSize = m_size;
594
595         m_size = IntSize(layoutWidth(), layoutHeight());
596
597         if (oldSize != m_size)
598             m_doFullRepaint = true;
599     }
600
601     RenderLayer* layer = root->enclosingLayer();
602
603     pauseScheduledEvents();
604
605     if (subtree)
606         root->view()->pushLayoutState(root);
607         
608     m_midLayout = true;
609     beginDeferredRepaints();
610     root->layout();
611     endDeferredRepaints();
612     m_midLayout = false;
613
614     if (subtree)
615         root->view()->popLayoutState();
616     m_layoutRoot = 0;
617
618     m_frame->invalidateSelection();
619    
620     m_layoutSchedulingEnabled = true;
621
622     if (!subtree && !toRenderView(root)->printing())
623         adjustViewSize();
624
625     // Now update the positions of all layers.
626     beginDeferredRepaints();
627     layer->updateLayerPositions((m_doFullRepaint ? RenderLayer::DoFullRepaint : 0)
628                                 | RenderLayer::CheckForRepaint
629                                 | RenderLayer::FullUpdate);
630     endDeferredRepaints();
631
632 #if USE(ACCELERATED_COMPOSITING)
633     updateCompositingLayers();
634 #endif
635     
636     m_layoutCount++;
637
638 #if PLATFORM(MAC)
639     if (AXObjectCache::accessibilityEnabled())
640         root->document()->axObjectCache()->postNotification(root, "AXLayoutComplete", true);
641 #endif
642 #if ENABLE(DASHBOARD_SUPPORT)
643     updateDashboardRegions();
644 #endif
645
646     ASSERT(!root->needsLayout());
647
648     setCanBlitOnScroll(!useSlowRepaints());
649
650     if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
651         updateOverflowStatus(layoutWidth() < contentsWidth(),
652                              layoutHeight() < contentsHeight());
653
654     if (!m_postLayoutTasksTimer.isActive()) {
655         // Calls resumeScheduledEvents()
656         performPostLayoutTasks();
657
658         if (!m_postLayoutTasksTimer.isActive() && needsLayout()) {
659             // Post-layout widget updates or an event handler made us need layout again.
660             // Lay out again, but this time defer widget updates and event dispatch until after
661             // we return.
662             m_postLayoutTasksTimer.startOneShot(0);
663             pauseScheduledEvents();
664             layout();
665         }
666     } else {
667         resumeScheduledEvents();
668         ASSERT(m_enqueueEvents);
669     }
670
671     if (lockedToAnchor())
672         m_frame->loader()->gotoAnchor();
673
674     m_nestedLayoutCount--;
675 }
676
677 void FrameView::addWidgetToUpdate(RenderPartObject* object)
678 {
679     if (!m_widgetUpdateSet)
680         m_widgetUpdateSet.set(new HashSet<RenderPartObject*>);
681
682     m_widgetUpdateSet->add(object);
683 }
684
685 void FrameView::removeWidgetToUpdate(RenderPartObject* object)
686 {
687     if (!m_widgetUpdateSet)
688         return;
689
690     m_widgetUpdateSet->remove(object);
691 }
692
693 void FrameView::setMediaType(const String& mediaType)
694 {
695     m_mediaType = mediaType;
696 }
697
698 String FrameView::mediaType() const
699 {
700     // See if we have an override type.
701     String overrideType = m_frame->loader()->client()->overrideMediaType();
702     if (!overrideType.isNull())
703         return overrideType;
704     return m_mediaType;
705 }
706
707 bool FrameView::useSlowRepaints() const
708 {
709     return m_useSlowRepaints || m_slowRepaintObjectCount > 0 || m_isOverlapped || !m_contentIsOpaque;
710 }
711
712 void FrameView::setUseSlowRepaints()
713 {
714     m_useSlowRepaints = true;
715     setCanBlitOnScroll(false);
716 }
717
718 void FrameView::addSlowRepaintObject()
719 {
720     if (!m_slowRepaintObjectCount)
721         setCanBlitOnScroll(false);
722     m_slowRepaintObjectCount++;
723 }
724
725 void FrameView::removeSlowRepaintObject()
726 {
727     ASSERT(m_slowRepaintObjectCount > 0);
728     m_slowRepaintObjectCount--;
729     if (!m_slowRepaintObjectCount)
730         setCanBlitOnScroll(!useSlowRepaints());
731 }
732
733 void FrameView::setIsOverlapped(bool isOverlapped)
734 {
735     if (isOverlapped == m_isOverlapped)
736         return;
737
738     m_isOverlapped = isOverlapped;
739     setCanBlitOnScroll(!useSlowRepaints());
740 }
741
742 void FrameView::setContentIsOpaque(bool contentIsOpaque)
743 {
744     if (contentIsOpaque == m_contentIsOpaque)
745         return;
746
747     m_contentIsOpaque = contentIsOpaque;
748     setCanBlitOnScroll(!useSlowRepaints());
749 }
750
751 void FrameView::restoreScrollbar()
752 {
753     setScrollbarsSuppressed(false);
754 }
755
756 void FrameView::scrollRectIntoViewRecursively(const IntRect& r)
757 {
758     bool wasInProgrammaticScroll = m_inProgrammaticScroll;
759     m_inProgrammaticScroll = true;
760     setLockedToAnchor(false);
761     ScrollView::scrollRectIntoViewRecursively(r);
762     m_inProgrammaticScroll = wasInProgrammaticScroll;
763 }
764
765 void FrameView::setScrollPosition(const IntPoint& scrollPoint)
766 {
767     bool wasInProgrammaticScroll = m_inProgrammaticScroll;
768     m_inProgrammaticScroll = true;
769     setLockedToAnchor(false);
770     ScrollView::setScrollPosition(scrollPoint);
771     m_inProgrammaticScroll = wasInProgrammaticScroll;
772 }
773
774 HostWindow* FrameView::hostWindow() const
775 {
776     Page* page = frame() ? frame()->page() : 0;
777     if (!page)
778         return 0;
779     return page->chrome();
780 }
781
782 const unsigned cRepaintRectUnionThreshold = 25;
783
784 void FrameView::repaintContentRectangle(const IntRect& r, bool immediate)
785 {
786     ASSERT(!m_frame->document()->ownerElement());
787
788     double delay = adjustedDeferredRepaintDelay();
789     if ((m_deferringRepaints || m_deferredRepaintTimer.isActive() || delay) && !immediate) {
790         IntRect visibleContent = visibleContentRect();
791         visibleContent.intersect(r);
792         if (visibleContent.isEmpty())
793             return;
794         if (m_repaintCount == cRepaintRectUnionThreshold) {
795             IntRect unionedRect;
796             for (unsigned i = 0; i < cRepaintRectUnionThreshold; ++i)
797                 unionedRect.unite(m_repaintRects[i]);
798             m_repaintRects.clear();
799             m_repaintRects.append(unionedRect);
800         }
801         if (m_repaintCount < cRepaintRectUnionThreshold)
802             m_repaintRects.append(r);
803         else
804             m_repaintRects[0].unite(r);
805         m_repaintCount++;
806     
807         if (!m_deferringRepaints && !m_deferredRepaintTimer.isActive())
808              m_deferredRepaintTimer.startOneShot(delay);
809         return;
810     }
811     
812     if (!immediate && isOffscreen() && !shouldUpdateWhileOffscreen())
813         return;
814
815     ScrollView::repaintContentRectangle(r, immediate);
816 }
817
818 void FrameView::beginDeferredRepaints()
819 {
820     Page* page = m_frame->page();
821     if (page->mainFrame() != m_frame)
822         return page->mainFrame()->view()->beginDeferredRepaints();
823
824     m_deferringRepaints++;
825 }
826
827
828 void FrameView::endDeferredRepaints()
829 {
830     Page* page = m_frame->page();
831     if (page->mainFrame() != m_frame)
832         return page->mainFrame()->view()->endDeferredRepaints();
833
834     ASSERT(m_deferringRepaints > 0);
835
836     if (--m_deferringRepaints)
837         return;
838     
839     if (m_deferredRepaintTimer.isActive())
840         return;
841
842     if (double delay = adjustedDeferredRepaintDelay()) {
843         m_deferredRepaintTimer.startOneShot(delay);
844         return;
845     }
846     
847     doDeferredRepaints();
848 }
849
850 void FrameView::checkStopDelayingDeferredRepaints()
851 {
852     if (!m_deferredRepaintTimer.isActive())
853         return;
854
855     Document* document = m_frame->document();
856     if (document && (document->parsing() || document->docLoader()->requestCount()))
857         return;
858     
859     m_deferredRepaintTimer.stop();
860
861     doDeferredRepaints();
862 }
863     
864 void FrameView::doDeferredRepaints()
865 {
866     ASSERT(!m_deferringRepaints);
867     if (isOffscreen() && !shouldUpdateWhileOffscreen()) {
868         m_repaintRects.clear();
869         m_repaintCount = 0;
870         return;
871     }
872     unsigned size = m_repaintRects.size();
873     for (unsigned i = 0; i < size; i++)
874         ScrollView::repaintContentRectangle(m_repaintRects[i], false);
875     m_repaintRects.clear();
876     m_repaintCount = 0;
877     
878     updateDeferredRepaintDelay();
879 }
880
881 void FrameView::updateDeferredRepaintDelay()
882 {
883     Document* document = m_frame->document();
884     if (!document || (!document->parsing() && !document->docLoader()->requestCount())) {
885         m_deferredRepaintDelay = deferredRepaintDelay;
886         return;
887     }
888     if (m_deferredRepaintDelay < maxDeferredRepaintDelayDuringLoading) {
889         m_deferredRepaintDelay += deferredRepaintDelayIncrementDuringLoading;
890         if (m_deferredRepaintDelay > maxDeferredRepaintDelayDuringLoading)
891             m_deferredRepaintDelay = maxDeferredRepaintDelayDuringLoading;
892     }
893 }
894
895 void FrameView::resetDeferredRepaintDelay()
896 {
897     m_deferredRepaintDelay = 0;
898     if (m_deferredRepaintTimer.isActive()) {
899         m_deferredRepaintTimer.stop();
900         if (!m_deferringRepaints)
901             doDeferredRepaints();
902     }
903 }
904
905 double FrameView::adjustedDeferredRepaintDelay() const
906 {
907     if (!m_deferredRepaintDelay)
908         return 0;
909     double timeSinceLastPaint = currentTime() - m_lastPaintTime;
910     return max(0., m_deferredRepaintDelay - timeSinceLastPaint);
911 }
912     
913 void FrameView::deferredRepaintTimerFired(Timer<FrameView>*)
914 {
915     doDeferredRepaints();
916 }    
917
918 void FrameView::layoutTimerFired(Timer<FrameView>*)
919 {
920 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
921     if (!m_frame->document()->ownerElement())
922         printf("Layout timer fired at %d\n", m_frame->document()->elapsedTime());
923 #endif
924     layout();
925 }
926
927 void FrameView::scheduleRelayout()
928 {
929     ASSERT(!m_frame->document()->inPageCache());
930     ASSERT(m_frame->view() == this);
931
932     if (m_layoutRoot) {
933         m_layoutRoot->markContainingBlocksForLayout(false);
934         m_layoutRoot = 0;
935     }
936     if (!m_layoutSchedulingEnabled)
937         return;
938     if (!needsLayout())
939         return;
940     if (!m_frame->document()->shouldScheduleLayout())
941         return;
942
943     int delay = m_frame->document()->minimumLayoutDelay();
944     if (m_layoutTimer.isActive() && m_delayedLayout && !delay)
945         unscheduleRelayout();
946     if (m_layoutTimer.isActive())
947         return;
948
949     m_delayedLayout = delay != 0;
950
951 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
952     if (!m_frame->document()->ownerElement())
953         printf("Scheduling layout for %d\n", delay);
954 #endif
955
956     m_layoutTimer.startOneShot(delay * 0.001);
957 }
958
959 static bool isObjectAncestorContainerOf(RenderObject* ancestor, RenderObject* descendant)
960 {
961     for (RenderObject* r = descendant; r; r = r->container()) {
962         if (r == ancestor)
963             return true;
964     }
965     return false;
966 }
967
968 void FrameView::scheduleRelayoutOfSubtree(RenderObject* relayoutRoot)
969 {
970     ASSERT(m_frame->view() == this);
971
972     if (!m_layoutSchedulingEnabled || (m_frame->contentRenderer()
973             && m_frame->contentRenderer()->needsLayout())) {
974         if (relayoutRoot)
975             relayoutRoot->markContainingBlocksForLayout(false);
976         return;
977     }
978
979     if (layoutPending()) {
980         if (m_layoutRoot != relayoutRoot) {
981             if (isObjectAncestorContainerOf(m_layoutRoot, relayoutRoot)) {
982                 // Keep the current root
983                 relayoutRoot->markContainingBlocksForLayout(false, m_layoutRoot);
984             } else if (m_layoutRoot && isObjectAncestorContainerOf(relayoutRoot, m_layoutRoot)) {
985                 // Re-root at relayoutRoot
986                 m_layoutRoot->markContainingBlocksForLayout(false, relayoutRoot);
987                 m_layoutRoot = relayoutRoot;
988             } else {
989                 // Just do a full relayout
990                 if (m_layoutRoot)
991                     m_layoutRoot->markContainingBlocksForLayout(false);
992                 m_layoutRoot = 0;
993                 relayoutRoot->markContainingBlocksForLayout(false);
994             }
995         }
996     } else {
997         int delay = m_frame->document()->minimumLayoutDelay();
998         m_layoutRoot = relayoutRoot;
999         m_delayedLayout = delay != 0;
1000         m_layoutTimer.startOneShot(delay * 0.001);
1001     }
1002 }
1003
1004 bool FrameView::layoutPending() const
1005 {
1006     return m_layoutTimer.isActive();
1007 }
1008
1009 bool FrameView::needsLayout() const
1010 {
1011     // This can return true in cases where the document does not have a body yet.
1012     // Document::shouldScheduleLayout takes care of preventing us from scheduling
1013     // layout in that case.
1014     if (!m_frame)
1015         return false;
1016     RenderView* root = m_frame->contentRenderer();
1017     Document* document = m_frame->document();
1018     return layoutPending()
1019         || (root && root->needsLayout())
1020         || m_layoutRoot
1021         || (document && document->childNeedsStyleRecalc()) // can occur when using WebKit ObjC interface
1022         || m_frame->needsReapplyStyles()
1023         || (m_deferSetNeedsLayouts && m_setNeedsLayoutWasDeferred);
1024 }
1025
1026 void FrameView::setNeedsLayout()
1027 {
1028     if (m_deferSetNeedsLayouts) {
1029         m_setNeedsLayoutWasDeferred = true;
1030         return;
1031     }
1032     RenderView* root = m_frame->contentRenderer();
1033     if (root)
1034         root->setNeedsLayout(true);
1035 }
1036
1037 void FrameView::unscheduleRelayout()
1038 {
1039     if (!m_layoutTimer.isActive())
1040         return;
1041
1042 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1043     if (!m_frame->document()->ownerElement())
1044         printf("Layout timer unscheduled at %d\n", m_frame->document()->elapsedTime());
1045 #endif
1046     
1047     m_layoutTimer.stop();
1048     m_delayedLayout = false;
1049 }
1050
1051 bool FrameView::isTransparent() const
1052 {
1053     return m_isTransparent;
1054 }
1055
1056 void FrameView::setTransparent(bool isTransparent)
1057 {
1058     m_isTransparent = isTransparent;
1059 }
1060
1061 Color FrameView::baseBackgroundColor() const
1062 {
1063     return m_baseBackgroundColor;
1064 }
1065
1066 void FrameView::setBaseBackgroundColor(Color bc)
1067 {
1068     if (!bc.isValid())
1069         bc = Color::white;
1070     m_baseBackgroundColor = bc;
1071 }
1072
1073 void FrameView::updateBackgroundRecursively(const Color& backgroundColor, bool transparent)
1074 {
1075     for (Frame* frame = m_frame.get(); frame; frame = frame->tree()->traverseNext(m_frame.get())) {
1076         FrameView* view = frame->view();
1077         if (!view)
1078             continue;
1079
1080         view->setTransparent(transparent);
1081         view->setBaseBackgroundColor(backgroundColor);
1082     }
1083 }
1084
1085 bool FrameView::shouldUpdateWhileOffscreen() const
1086 {
1087     return m_shouldUpdateWhileOffscreen;
1088 }
1089
1090 void FrameView::setShouldUpdateWhileOffscreen(bool shouldUpdateWhileOffscreen)
1091 {
1092     m_shouldUpdateWhileOffscreen = shouldUpdateWhileOffscreen;
1093 }
1094
1095 void FrameView::scheduleEvent(PassRefPtr<Event> event, PassRefPtr<Node> eventTarget)
1096 {
1097     if (!m_enqueueEvents) {
1098         ExceptionCode ec = 0;
1099         eventTarget->dispatchEvent(event, ec);
1100         return;
1101     }
1102
1103     ScheduledEvent* scheduledEvent = new ScheduledEvent;
1104     scheduledEvent->m_event = event;
1105     scheduledEvent->m_eventTarget = eventTarget;
1106     m_scheduledEvents.append(scheduledEvent);
1107 }
1108
1109 void FrameView::pauseScheduledEvents()
1110 {
1111     ASSERT(m_scheduledEvents.isEmpty() || m_enqueueEvents);
1112     m_enqueueEvents++;
1113 }
1114
1115 void FrameView::resumeScheduledEvents()
1116 {
1117     m_enqueueEvents--;
1118     if (!m_enqueueEvents)
1119         dispatchScheduledEvents();
1120     ASSERT(m_scheduledEvents.isEmpty() || m_enqueueEvents);
1121 }
1122
1123 bool FrameView::updateWidgets()
1124 {
1125     if (m_nestedLayoutCount > 1 || !m_widgetUpdateSet || m_widgetUpdateSet->isEmpty())
1126         return true;
1127     
1128     Vector<RenderPartObject*> objectVector;
1129     copyToVector(*m_widgetUpdateSet, objectVector);
1130     size_t size = objectVector.size();
1131     for (size_t i = 0; i < size; ++i) {
1132         RenderPartObject* object = objectVector[i];
1133         object->updateWidget(false);
1134         
1135         // updateWidget() can destroy the RenderPartObject, so we need to make sure it's
1136         // alive by checking if it's still in m_widgetUpdateSet.
1137         if (m_widgetUpdateSet->contains(object)) {
1138             object->updateWidgetPosition();
1139             m_widgetUpdateSet->remove(object);
1140         }
1141     }
1142     
1143     return m_widgetUpdateSet->isEmpty();
1144 }
1145     
1146 void FrameView::performPostLayoutTasks()
1147 {
1148     if (m_firstLayoutCallbackPending) {
1149         m_firstLayoutCallbackPending = false;
1150         m_frame->loader()->didFirstLayout();
1151     }
1152
1153     if (m_isVisuallyNonEmpty && m_firstVisuallyNonEmptyLayoutCallbackPending) {
1154         m_firstVisuallyNonEmptyLayoutCallbackPending = false;
1155         m_frame->loader()->didFirstVisuallyNonEmptyLayout();
1156     }
1157
1158     RenderView* root = m_frame->contentRenderer();
1159
1160     root->updateWidgetPositions();
1161     
1162     for (unsigned i = 0; i < maxUpdateWidgetsIterations; i++) {
1163         if (updateWidgets())
1164             break;
1165     }
1166     
1167     resumeScheduledEvents();
1168
1169     if (!root->printing()) {
1170         IntSize currentSize = IntSize(width(), height());
1171         float currentZoomFactor = root->style()->zoom();
1172         bool resized = !m_firstLayout && (currentSize != m_lastLayoutSize || currentZoomFactor != m_lastZoomFactor);
1173         m_lastLayoutSize = currentSize;
1174         m_lastZoomFactor = currentZoomFactor;
1175         if (resized)
1176             m_frame->eventHandler()->sendResizeEvent();
1177     }
1178 }
1179
1180 void FrameView::postLayoutTimerFired(Timer<FrameView>*)
1181 {
1182     performPostLayoutTasks();
1183 }
1184
1185 void FrameView::updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow)
1186 {
1187     if (!m_viewportRenderer)
1188         return;
1189     
1190     if (m_overflowStatusDirty) {
1191         m_horizontalOverflow = horizontalOverflow;
1192         m_verticalOverflow = verticalOverflow;
1193         m_overflowStatusDirty = false;
1194         return;
1195     }
1196     
1197     bool horizontalOverflowChanged = (m_horizontalOverflow != horizontalOverflow);
1198     bool verticalOverflowChanged = (m_verticalOverflow != verticalOverflow);
1199     
1200     if (horizontalOverflowChanged || verticalOverflowChanged) {
1201         m_horizontalOverflow = horizontalOverflow;
1202         m_verticalOverflow = verticalOverflow;
1203         
1204         scheduleEvent(OverflowEvent::create(horizontalOverflowChanged, horizontalOverflow,
1205             verticalOverflowChanged, verticalOverflow),
1206             m_viewportRenderer->node());
1207     }
1208     
1209 }
1210
1211 void FrameView::dispatchScheduledEvents()
1212 {
1213     if (m_scheduledEvents.isEmpty())
1214         return;
1215
1216     Vector<ScheduledEvent*> scheduledEventsCopy = m_scheduledEvents;
1217     m_scheduledEvents.clear();
1218     
1219     Vector<ScheduledEvent*>::iterator end = scheduledEventsCopy.end();
1220     for (Vector<ScheduledEvent*>::iterator it = scheduledEventsCopy.begin(); it != end; ++it) {
1221         ScheduledEvent* scheduledEvent = *it;
1222         
1223         ExceptionCode ec = 0;
1224         
1225         // Only dispatch events to nodes that are in the document
1226         if (scheduledEvent->m_eventTarget->inDocument())
1227             scheduledEvent->m_eventTarget->dispatchEvent(scheduledEvent->m_event, ec);
1228         
1229         delete scheduledEvent;
1230     }
1231 }
1232
1233 IntRect FrameView::windowClipRect(bool clipToContents) const
1234 {
1235     ASSERT(m_frame->view() == this);
1236
1237     // Set our clip rect to be our contents.
1238     IntRect clipRect = contentsToWindow(visibleContentRect(!clipToContents));
1239     if (!m_frame || !m_frame->document()->ownerElement())
1240         return clipRect;
1241
1242     // Take our owner element and get the clip rect from the enclosing layer.
1243     Element* elt = m_frame->document()->ownerElement();
1244     RenderLayer* layer = elt->renderer()->enclosingLayer();
1245     // FIXME: layer should never be null, but sometimes seems to be anyway.
1246     if (!layer)
1247         return clipRect;
1248     FrameView* parentView = elt->document()->view();
1249     clipRect.intersect(parentView->windowClipRectForLayer(layer, true));
1250     return clipRect;
1251 }
1252
1253 IntRect FrameView::windowClipRectForLayer(const RenderLayer* layer, bool clipToLayerContents) const
1254 {
1255     // If we have no layer, just return our window clip rect.
1256     if (!layer)
1257         return windowClipRect();
1258
1259     // Apply the clip from the layer.
1260     IntRect clipRect;
1261     if (clipToLayerContents)
1262         clipRect = layer->childrenClipRect();
1263     else
1264         clipRect = layer->selfClipRect();
1265     clipRect = contentsToWindow(clipRect); 
1266     return intersection(clipRect, windowClipRect());
1267 }
1268
1269 bool FrameView::isActive() const
1270 {
1271     Page* page = frame()->page();
1272     return page && page->focusController()->isActive();
1273 }
1274
1275 void FrameView::valueChanged(Scrollbar* bar)
1276 {
1277     // Figure out if we really moved.
1278     IntSize offset = scrollOffset();
1279     ScrollView::valueChanged(bar);
1280     if (offset != scrollOffset())
1281         frame()->eventHandler()->sendScrollEvent();
1282 }
1283
1284 void FrameView::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
1285 {
1286     // Add in our offset within the FrameView.
1287     IntRect dirtyRect = rect;
1288     dirtyRect.move(scrollbar->x(), scrollbar->y());
1289     invalidateRect(dirtyRect);
1290 }
1291
1292 void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const
1293 {
1294     tickmarks = frame()->document()->renderedRectsForMarkers(DocumentMarker::TextMatch);
1295 }
1296
1297 IntRect FrameView::windowResizerRect() const
1298 {
1299     Page* page = frame() ? frame()->page() : 0;
1300     if (!page)
1301         return IntRect();
1302     return page->chrome()->windowResizerRect();
1303 }
1304
1305 #if ENABLE(DASHBOARD_SUPPORT)
1306 void FrameView::updateDashboardRegions()
1307 {
1308     Document* document = m_frame->document();
1309     if (!document->hasDashboardRegions())
1310         return;
1311     Vector<DashboardRegionValue> newRegions;
1312     document->renderBox()->collectDashboardRegions(newRegions);
1313     if (newRegions == document->dashboardRegions())
1314         return;
1315     document->setDashboardRegions(newRegions);
1316     Page* page = m_frame->page();
1317     if (!page)
1318         return;
1319     page->chrome()->client()->dashboardRegionsChanged();
1320 }
1321 #endif
1322
1323 void FrameView::updateControlTints()
1324 {
1325     // This is called when control tints are changed from aqua/graphite to clear and vice versa.
1326     // We do a "fake" paint, and when the theme gets a paint call, it can then do an invalidate.
1327     // This is only done if the theme supports control tinting. It's up to the theme and platform
1328     // to define when controls get the tint and to call this function when that changes.
1329     
1330     // Optimize the common case where we bring a window to the front while it's still empty.
1331     if (!m_frame || m_frame->loader()->url().isEmpty())
1332         return;
1333
1334     if (m_frame->contentRenderer() && m_frame->contentRenderer()->theme()->supportsControlTints()) {
1335         if (needsLayout())
1336             layout();
1337         PlatformGraphicsContext* const noContext = 0;
1338         GraphicsContext context(noContext);
1339         context.setUpdatingControlTints(true);
1340         if (platformWidget())
1341             paintContents(&context, visibleContentRect());
1342         else
1343             paint(&context, frameRect());
1344     }
1345 }
1346
1347 bool FrameView::wasScrolledByUser() const
1348 {
1349     return m_wasScrolledByUser;
1350 }
1351
1352 void FrameView::setWasScrolledByUser(bool wasScrolledByUser)
1353 {
1354     if (m_inProgrammaticScroll)
1355         return;
1356     setLockedToAnchor(false);
1357     m_wasScrolledByUser = wasScrolledByUser;
1358 }
1359
1360 void FrameView::paintContents(GraphicsContext* p, const IntRect& rect)
1361 {
1362     if (!frame())
1363         return;
1364     
1365     Document* document = frame()->document();
1366
1367 #ifndef NDEBUG
1368     bool fillWithRed;
1369     if (document->printing())
1370         fillWithRed = false; // Printing, don't fill with red (can't remember why).
1371     else if (document->ownerElement())
1372         fillWithRed = false; // Subframe, don't fill with red.
1373     else if (isTransparent())
1374         fillWithRed = false; // Transparent, don't fill with red.
1375     else if (m_paintRestriction == PaintRestrictionSelectionOnly || m_paintRestriction == PaintRestrictionSelectionOnlyBlackText)
1376         fillWithRed = false; // Selections are transparent, don't fill with red.
1377     else if (m_nodeToDraw)
1378         fillWithRed = false; // Element images are transparent, don't fill with red.
1379     else
1380         fillWithRed = true;
1381     
1382     if (fillWithRed)
1383         p->fillRect(rect, Color(0xFF, 0, 0));
1384 #endif
1385
1386     bool isTopLevelPainter = !sCurrentPaintTimeStamp;
1387     if (isTopLevelPainter)
1388         sCurrentPaintTimeStamp = currentTime();
1389     
1390     RenderView* contentRenderer = frame()->contentRenderer();
1391     if (!contentRenderer) {
1392         LOG_ERROR("called Frame::paint with nil renderer");
1393         return;
1394     }
1395
1396     ASSERT(!needsLayout());
1397     if (needsLayout())
1398         return;
1399
1400     ASSERT(!m_isPainting);
1401         
1402     m_isPainting = true;
1403         
1404     // m_nodeToDraw is used to draw only one element (and its descendants)
1405     RenderObject* eltRenderer = m_nodeToDraw ? m_nodeToDraw->renderer() : 0;
1406     if (m_paintRestriction == PaintRestrictionNone)
1407         document->invalidateRenderedRectsForMarkersInRect(rect);
1408     contentRenderer->layer()->paint(p, rect, m_paintRestriction, eltRenderer);
1409     
1410     m_isPainting = false;
1411     m_lastPaintTime = currentTime();
1412
1413 #if ENABLE(DASHBOARD_SUPPORT)
1414     // Regions may have changed as a result of the visibility/z-index of element changing.
1415     if (document->dashboardRegionsDirty())
1416         updateDashboardRegions();
1417 #endif
1418
1419     if (isTopLevelPainter)
1420         sCurrentPaintTimeStamp = 0;
1421 }
1422
1423 void FrameView::setPaintRestriction(PaintRestriction pr)
1424 {
1425     m_paintRestriction = pr;
1426 }
1427     
1428 bool FrameView::isPainting() const
1429 {
1430     return m_isPainting;
1431 }
1432
1433 void FrameView::setNodeToDraw(Node* node)
1434 {
1435     m_nodeToDraw = node;
1436 }
1437
1438 void FrameView::layoutIfNeededRecursive()
1439 {
1440     // We have to crawl our entire tree looking for any FrameViews that need
1441     // layout and make sure they are up to date.
1442     // Mac actually tests for intersection with the dirty region and tries not to
1443     // update layout for frames that are outside the dirty region.  Not only does this seem
1444     // pointless (since those frames will have set a zero timer to layout anyway), but
1445     // it is also incorrect, since if two frames overlap, the first could be excluded from the dirty
1446     // region but then become included later by the second frame adding rects to the dirty region
1447     // when it lays out.
1448
1449     if (needsLayout())
1450         layout();
1451
1452     const HashSet<Widget*>* viewChildren = children();
1453     HashSet<Widget*>::const_iterator end = viewChildren->end();
1454     for (HashSet<Widget*>::const_iterator current = viewChildren->begin(); current != end; ++current)
1455         if ((*current)->isFrameView())
1456             static_cast<FrameView*>(*current)->layoutIfNeededRecursive();
1457
1458     // layoutIfNeededRecursive is called when we need to make sure layout is up-to-date before
1459     // painting, so we need to flush out any deferred repaints too.
1460     if (m_deferredRepaintTimer.isActive()) {
1461         m_deferredRepaintTimer.stop();
1462         doDeferredRepaints();
1463     }
1464 }
1465
1466 void FrameView::forceLayout(bool allowSubtree)
1467 {
1468     layout(allowSubtree);
1469     // We cannot unschedule a pending relayout, since the force can be called with
1470     // a tiny rectangle from a drawRect update.  By unscheduling we in effect
1471     // "validate" and stop the necessary full repaint from occurring.  Basically any basic
1472     // append/remove DHTML is broken by this call.  For now, I have removed the optimization
1473     // until we have a better invalidation stategy. -dwh
1474     //unscheduleRelayout();
1475 }
1476
1477 void FrameView::forceLayoutWithPageWidthRange(float minPageWidth, float maxPageWidth, bool _adjustViewSize)
1478 {
1479     // Dumping externalRepresentation(m_frame->renderer()).ascii() is a good trick to see
1480     // the state of things before and after the layout
1481     RenderView *root = toRenderView(m_frame->document()->renderer());
1482     if (root) {
1483         // This magic is basically copied from khtmlview::print
1484         int pageW = (int)ceilf(minPageWidth);
1485         root->setWidth(pageW);
1486         root->setNeedsLayoutAndPrefWidthsRecalc();
1487         forceLayout();
1488
1489         // If we don't fit in the minimum page width, we'll lay out again. If we don't fit in the
1490         // maximum page width, we will lay out to the maximum page width and clip extra content.
1491         // FIXME: We are assuming a shrink-to-fit printing implementation.  A cropping
1492         // implementation should not do this!
1493         int rightmostPos = root->rightmostPosition();
1494         if (rightmostPos > minPageWidth) {
1495             pageW = std::min(rightmostPos, (int)ceilf(maxPageWidth));
1496             root->setWidth(pageW);
1497             root->setNeedsLayoutAndPrefWidthsRecalc();
1498             forceLayout();
1499         }
1500     }
1501
1502     if (_adjustViewSize)
1503         adjustViewSize();
1504 }
1505
1506 void FrameView::adjustPageHeight(float *newBottom, float oldTop, float oldBottom, float /*bottomLimit*/)
1507 {
1508     RenderView* root = m_frame->contentRenderer();
1509     if (root) {
1510         // Use a context with painting disabled.
1511         GraphicsContext context((PlatformGraphicsContext*)0);
1512         root->setTruncatedAt((int)floorf(oldBottom));
1513         IntRect dirtyRect(0, (int)floorf(oldTop), root->overflowWidth(), (int)ceilf(oldBottom - oldTop));
1514         root->layer()->paint(&context, dirtyRect);
1515         *newBottom = root->bestTruncatedAt();
1516         if (*newBottom == 0)
1517             *newBottom = oldBottom;
1518     } else
1519         *newBottom = oldBottom;
1520 }
1521
1522 } // namespace WebCore