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.
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.
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.
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.
28 #include "FrameView.h"
30 #include "AXObjectCache.h"
31 #include "CSSStyleSelector.h"
33 #include "ChromeClient.h"
34 #include "DocLoader.h"
35 #include "EventHandler.h"
36 #include "FloatRect.h"
37 #include "FocusController.h"
39 #include "FrameLoader.h"
40 #include "FrameLoaderClient.h"
41 #include "FrameTree.h"
42 #include "GraphicsContext.h"
43 #include "HTMLDocument.h"
44 #include "HTMLFrameElement.h"
45 #include "HTMLFrameSetElement.h"
46 #include "HTMLNames.h"
47 #include "InspectorTimelineAgent.h"
48 #include "OverflowEvent.h"
49 #include "RenderEmbeddedObject.h"
50 #include "RenderLayer.h"
51 #include "RenderPart.h"
52 #include "RenderScrollbar.h"
53 #include "RenderScrollbarPart.h"
54 #include "RenderTheme.h"
55 #include "RenderView.h"
57 #include "TextResourceDecoder.h"
58 #include <wtf/CurrentTime.h>
60 #ifdef ANDROID_INSTRUMENT
61 #include "FrameTree.h"
62 #include "TimeCounter.h"
65 #if USE(ACCELERATED_COMPOSITING)
66 #include "RenderLayerCompositor.h"
70 #include "SVGDocument.h"
71 #include "SVGLocatable.h"
73 #include "SVGPreserveAspectRatio.h"
74 #include "SVGSVGElement.h"
75 #include "SVGViewElement.h"
76 #include "SVGViewSpec.h"
79 #if ENABLE(TILED_BACKING_STORE)
80 #include "TiledBackingStore.h"
84 #include "WebCoreFrameBridge.h"
89 using namespace HTMLNames;
91 double FrameView::sCurrentPaintTimeStamp = 0.0;
93 // REPAINT_THROTTLING now chooses default values for throttling parameters.
94 // Should be removed when applications start using runtime configuration.
95 #if ENABLE(REPAINT_THROTTLING)
97 double FrameView::s_deferredRepaintDelay = 0.025;
98 // Negative value would mean that first few repaints happen without a delay
99 double FrameView::s_initialDeferredRepaintDelayDuringLoading = 0;
100 // The delay grows on each repaint to this maximum value
101 double FrameView::s_maxDeferredRepaintDelayDuringLoading = 2.5;
102 // On each repaint the delay increses by this amount
103 double FrameView::s_deferredRepaintDelayIncrementDuringLoading = 0.5;
105 // FIXME: Repaint throttling could be good to have on all platform.
106 // The balance between CPU use and repaint frequency will need some tuning for desktop.
107 // More hooks may be needed to reset the delay on things like GIF and CSS animations.
108 double FrameView::s_deferredRepaintDelay = 0;
109 double FrameView::s_initialDeferredRepaintDelayDuringLoading = 0;
110 double FrameView::s_maxDeferredRepaintDelayDuringLoading = 0;
111 double FrameView::s_deferredRepaintDelayIncrementDuringLoading = 0;
114 // The maximum number of updateWidgets iterations that should be done before returning.
115 static const unsigned maxUpdateWidgetsIterations = 2;
117 struct ScheduledEvent : Noncopyable {
118 RefPtr<Event> m_event;
119 RefPtr<Node> m_eventTarget;
122 static inline float parentZoomFactor(Frame* frame)
124 Frame* parent = frame->tree()->parent();
127 FrameView* parentView = parent->view();
130 return parentView->zoomFactor();
133 FrameView::FrameView(Frame* frame)
135 , m_canHaveScrollbars(true)
136 , m_slowRepaintObjectCount(0)
137 , m_fixedObjectCount(0)
138 , m_layoutTimer(this, &FrameView::layoutTimerFired)
140 , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
141 , m_isTransparent(false)
142 , m_baseBackgroundColor(Color::white)
143 , m_mediaType("screen")
145 , m_overflowStatusDirty(true)
146 , m_viewportRenderer(0)
147 , m_wasScrolledByUser(false)
148 , m_inProgrammaticScroll(false)
149 , m_deferredRepaintTimer(this, &FrameView::deferredRepaintTimerFired)
150 , m_shouldUpdateWhileOffscreen(true)
151 , m_deferSetNeedsLayouts(0)
152 , m_setNeedsLayoutWasDeferred(false)
154 , m_zoomFactor(parentZoomFactor(frame))
159 PassRefPtr<FrameView> FrameView::create(Frame* frame)
161 RefPtr<FrameView> view = adoptRef(new FrameView(frame));
163 return view.release();
166 PassRefPtr<FrameView> FrameView::create(Frame* frame, const IntSize& initialSize)
168 RefPtr<FrameView> view = adoptRef(new FrameView(frame));
169 view->Widget::setFrameRect(IntRect(view->pos(), initialSize));
171 return view.release();
174 FrameView::~FrameView()
176 if (m_postLayoutTasksTimer.isActive()) {
177 m_postLayoutTasksTimer.stop();
178 m_scheduledEvents.clear();
184 // Custom scrollbars should already be destroyed at this point
185 ASSERT(!horizontalScrollbar() || !horizontalScrollbar()->isCustomScrollbar());
186 ASSERT(!verticalScrollbar() || !verticalScrollbar()->isCustomScrollbar());
188 setHasHorizontalScrollbar(false); // Remove native scrollbars now before we lose the connection to the HostWindow.
189 setHasVerticalScrollbar(false);
191 ASSERT(!m_scrollCorner);
192 ASSERT(m_scheduledEvents.isEmpty());
193 ASSERT(!m_enqueueEvents);
196 ASSERT(m_frame->view() != this || !m_frame->contentRenderer());
197 RenderPart* renderer = m_frame->ownerRenderer();
198 if (renderer && renderer->widget() == this)
199 renderer->setWidget(0);
203 void FrameView::reset()
205 m_useSlowRepaints = false;
206 m_isOverlapped = false;
207 m_contentIsOpaque = false;
210 m_layoutTimer.stop();
212 m_delayedLayout = false;
213 m_doFullRepaint = true;
214 m_layoutSchedulingEnabled = true;
217 m_nestedLayoutCount = 0;
218 m_postLayoutTasksTimer.stop();
219 m_firstLayout = true;
220 m_firstLayoutCallbackPending = false;
221 m_wasScrolledByUser = false;
222 m_lastLayoutSize = IntSize();
223 m_lastZoomFactor = 1.0f;
225 m_deferringRepaints = 0;
227 m_repaintRects.clear();
228 m_deferredRepaintDelay = s_initialDeferredRepaintDelayDuringLoading;
229 m_deferredRepaintTimer.stop();
231 m_paintBehavior = PaintBehaviorNormal;
232 m_isPainting = false;
233 m_isVisuallyNonEmpty = false;
234 m_firstVisuallyNonEmptyLayoutCallbackPending = true;
235 m_maintainScrollPositionAnchor = 0;
238 bool FrameView::isFrameView() const
243 void FrameView::clearFrame()
248 void FrameView::resetScrollbars()
250 // Reset the document's scrollbars back to our defaults before we yield the floor.
251 m_firstLayout = true;
252 setScrollbarsSuppressed(true);
253 if (m_canHaveScrollbars)
254 setScrollbarModes(ScrollbarAuto, ScrollbarAuto);
256 setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);
257 setScrollbarsSuppressed(false);
260 void FrameView::init()
264 m_margins = IntSize(-1, -1); // undefined
267 // Propagate the marginwidth/height and scrolling modes to the view.
268 Element* ownerElement = m_frame && m_frame->document() ? m_frame->document()->ownerElement() : 0;
269 if (ownerElement && (ownerElement->hasTagName(frameTag) || ownerElement->hasTagName(iframeTag))) {
270 HTMLFrameElement* frameElt = static_cast<HTMLFrameElement*>(ownerElement);
271 if (frameElt->scrollingMode() == ScrollbarAlwaysOff)
272 setCanHaveScrollbars(false);
273 int marginWidth = frameElt->getMarginWidth();
274 int marginHeight = frameElt->getMarginHeight();
275 if (marginWidth != -1)
276 setMarginWidth(marginWidth);
277 if (marginHeight != -1)
278 setMarginHeight(marginHeight);
282 void FrameView::detachCustomScrollbars()
287 Scrollbar* horizontalBar = horizontalScrollbar();
288 if (horizontalBar && horizontalBar->isCustomScrollbar())
289 setHasHorizontalScrollbar(false);
291 Scrollbar* verticalBar = verticalScrollbar();
292 if (verticalBar && verticalBar->isCustomScrollbar())
293 setHasVerticalScrollbar(false);
295 if (m_scrollCorner) {
296 m_scrollCorner->destroy();
301 void FrameView::clear()
303 setCanBlitOnScroll(true);
308 if (RenderPart* renderer = m_frame->ownerRenderer())
309 renderer->viewCleared();
312 setScrollbarsSuppressed(true);
315 bool FrameView::didFirstLayout() const
317 return !m_firstLayout;
320 void FrameView::invalidateRect(const IntRect& rect)
324 hostWindow()->invalidateContentsAndWindow(rect, false /*immediate*/);
331 RenderPart* renderer = m_frame->ownerRenderer();
335 IntRect repaintRect = rect;
336 repaintRect.move(renderer->borderLeft() + renderer->paddingLeft(),
337 renderer->borderTop() + renderer->paddingTop());
338 renderer->repaintRectangle(repaintRect);
341 void FrameView::setFrameRect(const IntRect& newRect)
343 IntRect oldRect = frameRect();
344 if (newRect == oldRect)
347 ScrollView::setFrameRect(newRect);
349 #if USE(ACCELERATED_COMPOSITING)
350 if (RenderView* root = m_frame->contentRenderer()) {
351 if (root->usesCompositing())
352 root->compositor()->frameViewDidChangeSize();
357 void FrameView::setMarginWidth(int w)
359 // make it update the rendering area when set
360 m_margins.setWidth(w);
363 void FrameView::setMarginHeight(int h)
365 // make it update the rendering area when set
366 m_margins.setHeight(h);
369 bool FrameView::avoidScrollbarCreation()
373 // with frame flattening no subframe can have scrollbars
374 // but we also cannot turn scrollbars of as we determine
375 // our flattening policy using that.
377 if (!m_frame->ownerElement())
380 if (!m_frame->settings() || m_frame->settings()->frameFlatteningEnabled())
386 void FrameView::setCanHaveScrollbars(bool canHaveScrollbars)
388 m_canHaveScrollbars = canHaveScrollbars;
389 ScrollView::setCanHaveScrollbars(canHaveScrollbars);
392 void FrameView::updateCanHaveScrollbars()
396 scrollbarModes(hMode, vMode);
397 if (hMode == ScrollbarAlwaysOff && vMode == ScrollbarAlwaysOff)
398 m_canHaveScrollbars = false;
400 m_canHaveScrollbars = true;
403 PassRefPtr<Scrollbar> FrameView::createScrollbar(ScrollbarOrientation orientation)
405 // FIXME: We need to update the scrollbar dynamically as documents change (or as doc elements and bodies get discovered that have custom styles).
406 Document* doc = m_frame->document();
408 // Try the <body> element first as a scrollbar source.
409 Element* body = doc ? doc->body() : 0;
410 if (body && body->renderer() && body->renderer()->style()->hasPseudoStyle(SCROLLBAR))
411 return RenderScrollbar::createCustomScrollbar(this, orientation, body->renderer()->enclosingBox());
413 // If the <body> didn't have a custom style, then the root element might.
414 Element* docElement = doc ? doc->documentElement() : 0;
415 if (docElement && docElement->renderer() && docElement->renderer()->style()->hasPseudoStyle(SCROLLBAR))
416 return RenderScrollbar::createCustomScrollbar(this, orientation, docElement->renderBox());
418 // If we have an owning iframe/frame element, then it can set the custom scrollbar also.
419 RenderPart* frameRenderer = m_frame->ownerRenderer();
420 if (frameRenderer && frameRenderer->style()->hasPseudoStyle(SCROLLBAR))
421 return RenderScrollbar::createCustomScrollbar(this, orientation, 0, m_frame.get());
423 // Nobody set a custom style, so we just use a native scrollbar.
424 return ScrollView::createScrollbar(orientation);
427 void FrameView::setContentsSize(const IntSize& size)
429 if (size == contentsSize())
432 m_deferSetNeedsLayouts++;
434 ScrollView::setContentsSize(size);
436 Page* page = frame() ? frame()->page() : 0;
440 page->chrome()->contentsSizeChanged(frame(), size); //notify only
442 m_deferSetNeedsLayouts--;
444 if (!m_deferSetNeedsLayouts)
445 m_setNeedsLayoutWasDeferred = false; // FIXME: Find a way to make the deferred layout actually happen.
448 void FrameView::adjustViewSize()
450 ASSERT(m_frame->view() == this);
451 RenderView* root = m_frame->contentRenderer();
455 setContentsSize(IntSize(root->rightLayoutOverflow(), root->bottomLayoutOverflow()));
458 void FrameView::applyOverflowToViewport(RenderObject* o, ScrollbarMode& hMode, ScrollbarMode& vMode)
460 // Handle the overflow:hidden/scroll case for the body/html elements. WinIE treats
461 // overflow:hidden and overflow:scroll on <body> as applying to the document's
462 // scrollbars. The CSS2.1 draft states that HTML UAs should use the <html> or <body> element and XML/XHTML UAs should
463 // use the root element.
464 switch (o->style()->overflowX()) {
466 hMode = ScrollbarAlwaysOff;
469 hMode = ScrollbarAlwaysOn;
472 hMode = ScrollbarAuto;
475 // Don't set it at all.
479 switch (o->style()->overflowY()) {
481 vMode = ScrollbarAlwaysOff;
484 vMode = ScrollbarAlwaysOn;
487 vMode = ScrollbarAuto;
490 // Don't set it at all.
494 m_viewportRenderer = o;
497 #if USE(ACCELERATED_COMPOSITING)
498 void FrameView::updateCompositingLayers()
500 RenderView* view = m_frame->contentRenderer();
504 // This call will make sure the cached hasAcceleratedCompositing is updated from the pref
505 view->compositor()->cacheAcceleratedCompositingFlags();
506 view->compositor()->updateCompositingLayers(CompositingUpdateAfterLayoutOrStyleChange);
509 void FrameView::setNeedsOneShotDrawingSynchronization()
511 Page* page = frame() ? frame()->page() : 0;
513 page->chrome()->client()->setNeedsOneShotDrawingSynchronization();
516 #endif // USE(ACCELERATED_COMPOSITING)
518 bool FrameView::hasCompositedContent() const
520 #if USE(ACCELERATED_COMPOSITING)
521 if (RenderView* view = m_frame->contentRenderer())
522 return view->compositor()->inCompositingMode();
527 // Sometimes (for plug-ins) we need to eagerly go into compositing mode.
528 void FrameView::enterCompositingMode()
530 #if USE(ACCELERATED_COMPOSITING)
531 if (RenderView* view = m_frame->contentRenderer())
532 view->compositor()->enableCompositingMode();
536 bool FrameView::isEnclosedInCompositingLayer() const
538 #if USE(ACCELERATED_COMPOSITING)
539 RenderObject* frameOwnerRenderer = m_frame->ownerRenderer();
540 return frameOwnerRenderer && frameOwnerRenderer->containerForRepaint();
546 bool FrameView::syncCompositingStateRecursive()
548 #if USE(ACCELERATED_COMPOSITING)
549 ASSERT(m_frame->view() == this);
550 RenderView* contentRenderer = m_frame->contentRenderer();
551 if (!contentRenderer)
552 return true; // We don't want to keep trying to update layers if we have no renderer.
554 // If we sync compositing layers when a layout is pending, we may cause painting of compositing
555 // layer content to occur before layout has happened, which will cause paintContents() to bail.
559 if (GraphicsLayer* rootLayer = contentRenderer->compositor()->rootPlatformLayer())
560 rootLayer->syncCompositingState();
562 bool allSubframesSynced = true;
563 const HashSet<RefPtr<Widget> >* viewChildren = children();
564 HashSet<RefPtr<Widget> >::const_iterator end = viewChildren->end();
565 for (HashSet<RefPtr<Widget> >::const_iterator current = viewChildren->begin(); current != end; ++current) {
566 Widget* widget = (*current).get();
567 if (widget->isFrameView()) {
568 bool synced = static_cast<FrameView*>(widget)->syncCompositingStateRecursive();
569 allSubframesSynced &= synced;
572 return allSubframesSynced;
573 #else // USE(ACCELERATED_COMPOSITING)
578 bool FrameView::isSoftwareRenderable() const
580 #if USE(ACCELERATED_COMPOSITING)
581 RenderView* view = m_frame->contentRenderer();
585 return !view->compositor()->has3DContent();
591 void FrameView::didMoveOnscreen()
593 RenderView* view = m_frame->contentRenderer();
595 view->didMoveOnscreen();
598 void FrameView::willMoveOffscreen()
600 RenderView* view = m_frame->contentRenderer();
602 view->willMoveOffscreen();
605 RenderObject* FrameView::layoutRoot(bool onlyDuringLayout) const
607 return onlyDuringLayout && layoutPending() ? 0 : m_layoutRoot;
610 void FrameView::layout(bool allowSubtree)
615 m_layoutTimer.stop();
616 m_delayedLayout = false;
617 m_setNeedsLayoutWasDeferred = false;
619 // Protect the view from being deleted during layout (in recalcStyle)
620 RefPtr<FrameView> protector(this);
623 // FIXME: Do we need to set m_size.width here?
624 // FIXME: Should we set m_size.height here too?
625 m_size.setWidth(layoutWidth());
629 // we shouldn't enter layout() while painting
630 ASSERT(!isPainting());
634 #if ENABLE(INSPECTOR)
635 if (InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent())
636 timelineAgent->willLayout();
639 if (!allowSubtree && m_layoutRoot) {
640 m_layoutRoot->markContainingBlocksForLayout(false);
644 ASSERT(m_frame->view() == this);
646 Document* document = m_frame->document();
648 m_layoutSchedulingEnabled = false;
650 if (!m_nestedLayoutCount && m_postLayoutTasksTimer.isActive()) {
651 // This is a new top-level layout. If there are any remaining tasks from the previous
652 // layout, finish them now.
653 m_postLayoutTasksTimer.stop();
654 performPostLayoutTasks();
657 // Viewport-dependent media queries may cause us to need completely different style information.
659 if (document->styleSelector()->affectedByViewportChange())
660 document->updateStyleSelector();
662 // Always ensure our style info is up-to-date. This can happen in situations where
663 // the layout beats any sort of style recalc update that needs to occur.
664 if (m_frame->needsReapplyStyles())
665 m_frame->reapplyStyles();
666 else if (document->childNeedsStyleRecalc())
667 document->recalcStyle();
669 bool subtree = m_layoutRoot;
671 // If there is only one ref to this view left, then its going to be destroyed as soon as we exit,
672 // so there's no point to continuing to layout
673 if (protector->hasOneRef())
676 RenderObject* root = subtree ? m_layoutRoot : document->renderer();
678 // FIXME: Do we need to set m_size here?
679 m_layoutSchedulingEnabled = true;
683 #ifdef ANDROID_INSTRUMENT
684 if (!m_frame->tree() || !m_frame->tree()->parent())
685 android::TimeCounter::start(android::TimeCounter::LayoutTimeCounter);
688 m_nestedLayoutCount++;
692 if (m_canHaveScrollbars) {
693 hMode = ScrollbarAuto;
694 vMode = ScrollbarAuto;
696 hMode = ScrollbarAlwaysOff;
697 vMode = ScrollbarAlwaysOff;
701 Node* documentElement = document->documentElement();
702 RenderObject* rootRenderer = documentElement ? documentElement->renderer() : 0;
703 Node* body = document->body();
704 if (body && body->renderer()) {
705 if (body->hasTagName(framesetTag) && m_frame->settings() && !m_frame->settings()->frameFlatteningEnabled()) {
706 #if !defined(ANDROID_FLATTEN_IFRAME) && !defined(ANDROID_FLATTEN_FRAMESET)
707 body->renderer()->setChildNeedsLayout(true);
708 vMode = ScrollbarAlwaysOff;
709 hMode = ScrollbarAlwaysOff;
711 } else if (body->hasTagName(bodyTag)) {
712 if (!m_firstLayout && m_size.height() != layoutHeight() && body->renderer()->enclosingBox()->stretchesToViewHeight())
713 body->renderer()->setChildNeedsLayout(true);
714 // It's sufficient to just check the X overflow,
715 // since it's illegal to have visible in only one direction.
716 RenderObject* o = rootRenderer->style()->overflowX() == OVISIBLE && document->documentElement()->hasTagName(htmlTag) ? body->renderer() : rootRenderer;
717 applyOverflowToViewport(o, hMode, vMode);
719 } else if (rootRenderer) {
721 if (documentElement->isSVGElement()) {
722 if (!m_firstLayout && (m_size.width() != layoutWidth() || m_size.height() != layoutHeight()))
723 rootRenderer->setChildNeedsLayout(true);
725 applyOverflowToViewport(rootRenderer, hMode, vMode);
727 applyOverflowToViewport(rootRenderer, hMode, vMode);
730 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
731 if (m_firstLayout && !document->ownerElement())
732 printf("Elapsed time before first layout: %d\n", document->elapsedTime());
736 m_doFullRepaint = !subtree && (m_firstLayout || toRenderView(root)->printing());
739 // Now set our scrollbar state for the layout.
740 ScrollbarMode currentHMode = horizontalScrollbarMode();
741 ScrollbarMode currentVMode = verticalScrollbarMode();
743 if (m_firstLayout || (hMode != currentHMode || vMode != currentVMode)) {
745 setScrollbarsSuppressed(true);
747 m_firstLayout = false;
748 m_firstLayoutCallbackPending = true;
749 m_lastLayoutSize = IntSize(width(), height());
750 m_lastZoomFactor = root->style()->zoom();
752 // Set the initial vMode to AlwaysOn if we're auto.
753 if (vMode == ScrollbarAuto)
754 setVerticalScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear.
755 // Set the initial hMode to AlwaysOff if we're auto.
756 if (hMode == ScrollbarAuto)
757 setHorizontalScrollbarMode(ScrollbarAlwaysOff); // This causes a horizontal scrollbar to disappear.
759 setScrollbarModes(hMode, vMode);
760 setScrollbarsSuppressed(false, true);
762 setScrollbarModes(hMode, vMode);
765 IntSize oldSize = m_size;
767 m_size = IntSize(layoutWidth(), layoutHeight());
769 if (oldSize != m_size)
770 m_doFullRepaint = true;
773 RenderLayer* layer = root->enclosingLayer();
775 pauseScheduledEvents();
777 bool disableLayoutState = false;
779 RenderView* view = root->view();
780 disableLayoutState = view->shouldDisableLayoutStateForSubtree(root);
781 view->pushLayoutState(root);
782 if (disableLayoutState)
783 view->disableLayoutState();
787 beginDeferredRepaints();
789 endDeferredRepaints();
793 RenderView* view = root->view();
794 view->popLayoutState();
795 if (disableLayoutState)
796 view->enableLayoutState();
800 m_frame->selection()->setCaretRectNeedsUpdate();
801 m_frame->selection()->updateAppearance();
803 m_layoutSchedulingEnabled = true;
805 if (!subtree && !toRenderView(root)->printing())
808 // Now update the positions of all layers.
809 beginDeferredRepaints();
810 IntPoint cachedOffset;
811 layer->updateLayerPositions((m_doFullRepaint ? RenderLayer::DoFullRepaint : 0)
812 | RenderLayer::CheckForRepaint
813 | RenderLayer::IsCompositingUpdateRoot
814 | RenderLayer::UpdateCompositingLayers,
815 subtree ? 0 : &cachedOffset);
816 endDeferredRepaints();
818 #if USE(ACCELERATED_COMPOSITING)
819 updateCompositingLayers();
825 if (AXObjectCache::accessibilityEnabled())
826 root->document()->axObjectCache()->postNotification(root, AXObjectCache::AXLayoutComplete, true);
828 #if ENABLE(DASHBOARD_SUPPORT)
829 updateDashboardRegions();
832 #ifdef ANDROID_INSTRUMENT
833 if (!m_frame->tree()->parent())
834 android::TimeCounter::record(android::TimeCounter::LayoutTimeCounter, __FUNCTION__);
836 ASSERT(!root->needsLayout());
838 setCanBlitOnScroll(!useSlowRepaints());
840 if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
841 updateOverflowStatus(layoutWidth() < contentsWidth(),
842 layoutHeight() < contentsHeight());
844 if (!m_postLayoutTasksTimer.isActive()) {
845 // Calls resumeScheduledEvents()
846 performPostLayoutTasks();
848 if (!m_postLayoutTasksTimer.isActive() && needsLayout()) {
849 // Post-layout widget updates or an event handler made us need layout again.
850 // Lay out again, but this time defer widget updates and event dispatch until after
852 m_postLayoutTasksTimer.startOneShot(0);
853 pauseScheduledEvents();
857 resumeScheduledEvents();
858 ASSERT(m_enqueueEvents);
861 #if ENABLE(INSPECTOR)
862 if (InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent())
863 timelineAgent->didLayout();
866 m_nestedLayoutCount--;
869 void FrameView::addWidgetToUpdate(RenderEmbeddedObject* object)
871 if (!m_widgetUpdateSet)
872 m_widgetUpdateSet.set(new RenderEmbeddedObjectSet);
874 m_widgetUpdateSet->add(object);
877 void FrameView::removeWidgetToUpdate(RenderEmbeddedObject* object)
879 if (!m_widgetUpdateSet)
882 m_widgetUpdateSet->remove(object);
885 void FrameView::setMediaType(const String& mediaType)
887 m_mediaType = mediaType;
890 String FrameView::mediaType() const
892 // See if we have an override type.
893 String overrideType = m_frame->loader()->client()->overrideMediaType();
894 if (!overrideType.isNull())
899 void FrameView::adjustMediaTypeForPrinting(bool printing)
902 if (m_mediaTypeWhenNotPrinting.isNull())
903 m_mediaTypeWhenNotPrinting = mediaType();
904 setMediaType("print");
906 if (!m_mediaTypeWhenNotPrinting.isNull())
907 setMediaType(m_mediaTypeWhenNotPrinting);
908 m_mediaTypeWhenNotPrinting = String();
912 bool FrameView::useSlowRepaints() const
914 return m_useSlowRepaints || m_slowRepaintObjectCount > 0 || (platformWidget() && m_fixedObjectCount > 0) || m_isOverlapped || !m_contentIsOpaque;
917 bool FrameView::useSlowRepaintsIfNotOverlapped() const
919 return m_useSlowRepaints || m_slowRepaintObjectCount > 0 || (platformWidget() && m_fixedObjectCount > 0) || !m_contentIsOpaque;
922 void FrameView::setUseSlowRepaints()
924 m_useSlowRepaints = true;
925 setCanBlitOnScroll(false);
928 void FrameView::addSlowRepaintObject()
930 if (!m_slowRepaintObjectCount)
931 setCanBlitOnScroll(false);
932 m_slowRepaintObjectCount++;
935 void FrameView::removeSlowRepaintObject()
937 ASSERT(m_slowRepaintObjectCount > 0);
938 m_slowRepaintObjectCount--;
939 if (!m_slowRepaintObjectCount)
940 setCanBlitOnScroll(!useSlowRepaints());
943 void FrameView::addFixedObject()
945 if (!m_fixedObjectCount && platformWidget())
946 setCanBlitOnScroll(false);
947 ++m_fixedObjectCount;
950 void FrameView::removeFixedObject()
952 ASSERT(m_fixedObjectCount > 0);
953 --m_fixedObjectCount;
954 if (!m_fixedObjectCount)
955 setCanBlitOnScroll(!useSlowRepaints());
958 bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect)
960 const size_t fixedObjectThreshold = 5;
962 RenderBlock::PositionedObjectsListHashSet* positionedObjects = 0;
963 if (RenderView* root = m_frame->contentRenderer())
964 positionedObjects = root->positionedObjects();
966 if (!positionedObjects || positionedObjects->isEmpty()) {
967 hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);
971 // Get the rects of the fixed objects visible in the rectToScroll
972 Vector<IntRect, fixedObjectThreshold> subRectToUpdate;
973 bool updateInvalidatedSubRect = true;
974 RenderBlock::PositionedObjectsListHashSet::const_iterator end = positionedObjects->end();
975 for (RenderBlock::PositionedObjectsListHashSet::const_iterator it = positionedObjects->begin(); it != end; ++it) {
976 RenderBox* renderBox = *it;
977 if (renderBox->style()->position() != FixedPosition)
979 IntRect updateRect = renderBox->layer()->repaintRectIncludingDescendants();
980 updateRect = contentsToWindow(updateRect);
982 updateRect.intersect(rectToScroll);
983 if (!updateRect.isEmpty()) {
984 if (subRectToUpdate.size() >= fixedObjectThreshold) {
985 updateInvalidatedSubRect = false;
988 subRectToUpdate.append(updateRect);
993 if (updateInvalidatedSubRect) {
995 hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);
997 // 2) update the area of fixed objects that has been invalidated
998 size_t fixObjectsCount = subRectToUpdate.size();
999 for (size_t i = 0; i < fixObjectsCount; ++i) {
1000 IntRect updateRect = subRectToUpdate[i];
1001 IntRect scrolledRect = updateRect;
1002 scrolledRect.move(scrollDelta);
1003 updateRect.unite(scrolledRect);
1004 updateRect.intersect(rectToScroll);
1005 hostWindow()->invalidateContentsAndWindow(updateRect, false);
1010 // the number of fixed objects exceed the threshold, we cannot use the fast path
1014 // Note that this gets called at painting time.
1015 void FrameView::setIsOverlapped(bool isOverlapped)
1017 if (isOverlapped == m_isOverlapped)
1020 m_isOverlapped = isOverlapped;
1021 setCanBlitOnScroll(!useSlowRepaints());
1023 #if USE(ACCELERATED_COMPOSITING)
1024 // Overlap can affect compositing tests, so if it changes, we need to trigger
1025 // a layer update in the parent document.
1026 if (hasCompositedContent()) {
1027 if (Frame* parentFrame = m_frame->tree()->parent()) {
1028 if (RenderView* parentView = parentFrame->contentRenderer()) {
1029 RenderLayerCompositor* compositor = parentView->compositor();
1030 compositor->setCompositingLayersNeedRebuild();
1031 compositor->scheduleCompositingLayerUpdate();
1038 void FrameView::setContentIsOpaque(bool contentIsOpaque)
1040 if (contentIsOpaque == m_contentIsOpaque)
1043 m_contentIsOpaque = contentIsOpaque;
1044 setCanBlitOnScroll(!useSlowRepaints());
1047 void FrameView::restoreScrollbar()
1049 setScrollbarsSuppressed(false);
1052 bool FrameView::scrollToFragment(const KURL& url)
1054 // If our URL has no ref, then we have no place we need to jump to.
1055 // OTOH If CSS target was set previously, we want to set it to 0, recalc
1056 // and possibly repaint because :target pseudo class may have been
1057 // set (see bug 11321).
1058 if (!url.hasFragmentIdentifier() && !m_frame->document()->cssTarget())
1061 String fragmentIdentifier = url.fragmentIdentifier();
1062 if (scrollToAnchor(fragmentIdentifier))
1065 // Try again after decoding the ref, based on the document's encoding.
1066 if (TextResourceDecoder* decoder = m_frame->document()->decoder())
1067 return scrollToAnchor(decodeURLEscapeSequences(fragmentIdentifier, decoder->encoding()));
1072 bool FrameView::scrollToAnchor(const String& name)
1074 ASSERT(m_frame->document());
1076 if (!m_frame->document()->haveStylesheetsLoaded()) {
1077 m_frame->document()->setGotoAnchorNeededAfterStylesheetsLoad(true);
1081 m_frame->document()->setGotoAnchorNeededAfterStylesheetsLoad(false);
1083 Element* anchorNode = m_frame->document()->findAnchor(name);
1086 if (m_frame->document()->isSVGDocument()) {
1087 if (name.startsWith("xpointer(")) {
1088 // We need to parse the xpointer reference here
1089 } else if (name.startsWith("svgView(")) {
1090 RefPtr<SVGSVGElement> svg = static_cast<SVGDocument*>(m_frame->document())->rootElement();
1091 if (!svg->currentView()->parseViewSpec(name))
1093 svg->setUseCurrentView(true);
1095 if (anchorNode && anchorNode->hasTagName(SVGNames::viewTag)) {
1096 RefPtr<SVGViewElement> viewElement = anchorNode->hasTagName(SVGNames::viewTag) ? static_cast<SVGViewElement*>(anchorNode) : 0;
1097 if (viewElement.get()) {
1098 RefPtr<SVGSVGElement> svg = static_cast<SVGSVGElement*>(SVGLocatable::nearestViewportElement(viewElement.get()));
1099 svg->inheritViewAttributes(viewElement.get());
1103 // FIXME: need to decide which <svg> to focus on, and zoom to that one
1104 // FIXME: need to actually "highlight" the viewTarget(s)
1108 m_frame->document()->setCSSTarget(anchorNode); // Setting to null will clear the current target.
1110 // Implement the rule that "" and "top" both mean top of page as in other browsers.
1111 if (!anchorNode && !(name.isEmpty() || equalIgnoringCase(name, "top")))
1114 #ifdef ANDROID_SCROLL_ON_GOTO_ANCHOR
1115 // TODO(andreip): check with Grace if this is correct.
1116 android::WebFrame::getWebFrame(m_frame.get())->setUserInitiatedClick(true);
1118 maintainScrollPositionAtAnchor(anchorNode ? static_cast<Node*>(anchorNode) : m_frame->document());
1119 #ifdef ANDROID_SCROLL_ON_GOTO_ANCHOR
1120 android::WebFrame::getWebFrame(m_frame.get())->setUserInitiatedClick(false);
1125 void FrameView::maintainScrollPositionAtAnchor(Node* anchorNode)
1127 m_maintainScrollPositionAnchor = anchorNode;
1128 if (!m_maintainScrollPositionAnchor)
1131 // We need to update the layout before scrolling, otherwise we could
1132 // really mess things up if an anchor scroll comes at a bad moment.
1133 m_frame->document()->updateStyleIfNeeded();
1134 // Only do a layout if changes have occurred that make it necessary.
1135 if (m_frame->contentRenderer() && m_frame->contentRenderer()->needsLayout())
1141 void FrameView::setScrollPosition(const IntPoint& scrollPoint)
1143 bool wasInProgrammaticScroll = m_inProgrammaticScroll;
1144 m_inProgrammaticScroll = true;
1145 m_maintainScrollPositionAnchor = 0;
1146 ScrollView::setScrollPosition(scrollPoint);
1147 m_inProgrammaticScroll = wasInProgrammaticScroll;
1150 void FrameView::scrollPositionChangedViaPlatformWidget()
1152 repaintFixedElementsAfterScrolling();
1153 scrollPositionChanged();
1156 void FrameView::scrollPositionChanged()
1158 frame()->eventHandler()->sendScrollEvent();
1160 #if USE(ACCELERATED_COMPOSITING)
1161 if (RenderView* root = m_frame->contentRenderer()) {
1162 if (root->usesCompositing())
1163 root->compositor()->frameViewDidScroll(scrollPosition());
1168 void FrameView::repaintFixedElementsAfterScrolling()
1170 // For fixed position elements, update widget positions and compositing layers after scrolling,
1171 // but only if we're not inside of layout.
1172 if (!m_nestedLayoutCount && hasFixedObjects()) {
1173 if (RenderView* root = m_frame->contentRenderer()) {
1174 root->updateWidgetPositions();
1175 root->layer()->updateRepaintRectsAfterScroll();
1176 #if USE(ACCELERATED_COMPOSITING)
1177 root->compositor()->updateCompositingLayers(CompositingUpdateOnScroll);
1183 HostWindow* FrameView::hostWindow() const
1185 Page* page = frame() ? frame()->page() : 0;
1188 return page->chrome();
1191 const unsigned cRepaintRectUnionThreshold = 25;
1193 void FrameView::repaintContentRectangle(const IntRect& r, bool immediate)
1195 ASSERT(!m_frame->document()->ownerElement());
1197 double delay = adjustedDeferredRepaintDelay();
1198 if ((m_deferringRepaints || m_deferredRepaintTimer.isActive() || delay) && !immediate) {
1199 IntRect paintRect = r;
1200 if (!paintsEntireContents())
1201 paintRect.intersect(visibleContentRect());
1202 #ifdef ANDROID_CAPTURE_OFFSCREEN_PAINTS
1204 ScrollView::platformOffscreenContentRectangle(visibleContentRect(), r);
1206 if (paintRect.isEmpty())
1208 if (m_repaintCount == cRepaintRectUnionThreshold) {
1209 IntRect unionedRect;
1210 for (unsigned i = 0; i < cRepaintRectUnionThreshold; ++i)
1211 unionedRect.unite(m_repaintRects[i]);
1212 m_repaintRects.clear();
1213 m_repaintRects.append(unionedRect);
1215 if (m_repaintCount < cRepaintRectUnionThreshold)
1216 m_repaintRects.append(paintRect);
1218 m_repaintRects[0].unite(paintRect);
1221 if (!m_deferringRepaints && !m_deferredRepaintTimer.isActive())
1222 m_deferredRepaintTimer.startOneShot(delay);
1226 if (!immediate && isOffscreen() && !shouldUpdateWhileOffscreen())
1229 #if ENABLE(TILED_BACKING_STORE)
1230 if (frame()->tiledBackingStore()) {
1231 frame()->tiledBackingStore()->invalidate(r);
1235 ScrollView::repaintContentRectangle(r, immediate);
1238 void FrameView::visibleContentsResized()
1240 // We check to make sure the view is attached to a frame() as this method can
1241 // be triggered before the view is attached by Frame::createView(...) setting
1242 // various values such as setScrollBarModes(...) for example. An ASSERT is
1243 // triggered when a view is layout before being attached to a frame().
1244 if (!frame()->view())
1251 void FrameView::beginDeferredRepaints()
1253 Page* page = m_frame->page();
1254 if (page->mainFrame() != m_frame)
1255 return page->mainFrame()->view()->beginDeferredRepaints();
1257 m_deferringRepaints++;
1261 void FrameView::endDeferredRepaints()
1263 Page* page = m_frame->page();
1264 if (page->mainFrame() != m_frame)
1265 return page->mainFrame()->view()->endDeferredRepaints();
1267 ASSERT(m_deferringRepaints > 0);
1269 if (--m_deferringRepaints)
1272 if (m_deferredRepaintTimer.isActive())
1275 if (double delay = adjustedDeferredRepaintDelay()) {
1276 m_deferredRepaintTimer.startOneShot(delay);
1280 doDeferredRepaints();
1283 void FrameView::checkStopDelayingDeferredRepaints()
1285 if (!m_deferredRepaintTimer.isActive())
1288 Document* document = m_frame->document();
1289 if (document && (document->parsing() || document->docLoader()->requestCount()))
1292 m_deferredRepaintTimer.stop();
1294 doDeferredRepaints();
1297 void FrameView::doDeferredRepaints()
1299 ASSERT(!m_deferringRepaints);
1300 if (isOffscreen() && !shouldUpdateWhileOffscreen()) {
1301 m_repaintRects.clear();
1305 unsigned size = m_repaintRects.size();
1306 for (unsigned i = 0; i < size; i++) {
1307 #if ENABLE(TILED_BACKING_STORE)
1308 if (frame()->tiledBackingStore()) {
1309 frame()->tiledBackingStore()->invalidate(m_repaintRects[i]);
1313 ScrollView::repaintContentRectangle(m_repaintRects[i], false);
1315 m_repaintRects.clear();
1318 updateDeferredRepaintDelay();
1321 void FrameView::updateDeferredRepaintDelay()
1323 Document* document = m_frame->document();
1324 if (!document || (!document->parsing() && !document->docLoader()->requestCount())) {
1325 m_deferredRepaintDelay = s_deferredRepaintDelay;
1328 if (m_deferredRepaintDelay < s_maxDeferredRepaintDelayDuringLoading) {
1329 m_deferredRepaintDelay += s_deferredRepaintDelayIncrementDuringLoading;
1330 if (m_deferredRepaintDelay > s_maxDeferredRepaintDelayDuringLoading)
1331 m_deferredRepaintDelay = s_maxDeferredRepaintDelayDuringLoading;
1335 void FrameView::resetDeferredRepaintDelay()
1337 m_deferredRepaintDelay = 0;
1338 if (m_deferredRepaintTimer.isActive()) {
1339 m_deferredRepaintTimer.stop();
1340 if (!m_deferringRepaints)
1341 doDeferredRepaints();
1345 double FrameView::adjustedDeferredRepaintDelay() const
1347 if (!m_deferredRepaintDelay)
1349 double timeSinceLastPaint = currentTime() - m_lastPaintTime;
1350 return max(0., m_deferredRepaintDelay - timeSinceLastPaint);
1353 void FrameView::deferredRepaintTimerFired(Timer<FrameView>*)
1355 doDeferredRepaints();
1358 void FrameView::layoutTimerFired(Timer<FrameView>*)
1360 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1361 if (!m_frame->document()->ownerElement())
1362 printf("Layout timer fired at %d\n", m_frame->document()->elapsedTime());
1367 void FrameView::scheduleRelayout()
1369 // FIXME: We should assert the page is not in the page cache, but that is causing
1370 // too many false assertions. See <rdar://problem/7218118>.
1371 ASSERT(m_frame->view() == this);
1374 m_layoutRoot->markContainingBlocksForLayout(false);
1377 if (!m_layoutSchedulingEnabled)
1381 if (!m_frame->document()->shouldScheduleLayout())
1384 #if defined(ANDROID_FLATTEN_IFRAME) || defined(ANDROID_FLATTEN_FRAMESET)
1385 // This is the Android frame flattening code. The common code below is not
1386 // used as frameSetFlatteningEnabled() is false on Android.
1387 if (m_frame->ownerRenderer())
1388 m_frame->ownerRenderer()->setNeedsLayoutAndPrefWidthsRecalc();
1391 // When frame flattening is enabled, the contents of the frame affects layout of the parent frames.
1392 // Also invalidate parent frame starting from the owner element of this frame.
1393 if (m_frame->settings() && m_frame->settings()->frameFlatteningEnabled() && m_frame->ownerRenderer()) {
1394 if (m_frame->ownerElement()->hasTagName(iframeTag) || m_frame->ownerElement()->hasTagName(frameTag))
1395 m_frame->ownerRenderer()->setNeedsLayout(true, true);
1398 int delay = m_frame->document()->minimumLayoutDelay();
1399 if (m_layoutTimer.isActive() && m_delayedLayout && !delay)
1400 unscheduleRelayout();
1401 if (m_layoutTimer.isActive())
1404 m_delayedLayout = delay != 0;
1406 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1407 if (!m_frame->document()->ownerElement())
1408 printf("Scheduling layout for %d\n", delay);
1411 m_layoutTimer.startOneShot(delay * 0.001);
1414 static bool isObjectAncestorContainerOf(RenderObject* ancestor, RenderObject* descendant)
1416 for (RenderObject* r = descendant; r; r = r->container()) {
1423 void FrameView::scheduleRelayoutOfSubtree(RenderObject* relayoutRoot)
1425 ASSERT(m_frame->view() == this);
1427 if (m_frame->contentRenderer() && m_frame->contentRenderer()->needsLayout()) {
1429 relayoutRoot->markContainingBlocksForLayout(false);
1433 if (layoutPending() || !m_layoutSchedulingEnabled) {
1434 if (m_layoutRoot != relayoutRoot) {
1435 if (isObjectAncestorContainerOf(m_layoutRoot, relayoutRoot)) {
1436 // Keep the current root
1437 relayoutRoot->markContainingBlocksForLayout(false, m_layoutRoot);
1438 } else if (m_layoutRoot && isObjectAncestorContainerOf(relayoutRoot, m_layoutRoot)) {
1439 // Re-root at relayoutRoot
1440 m_layoutRoot->markContainingBlocksForLayout(false, relayoutRoot);
1441 m_layoutRoot = relayoutRoot;
1443 // Just do a full relayout
1445 m_layoutRoot->markContainingBlocksForLayout(false);
1447 relayoutRoot->markContainingBlocksForLayout(false);
1450 } else if (m_layoutSchedulingEnabled) {
1451 int delay = m_frame->document()->minimumLayoutDelay();
1452 m_layoutRoot = relayoutRoot;
1453 m_delayedLayout = delay != 0;
1454 m_layoutTimer.startOneShot(delay * 0.001);
1458 bool FrameView::layoutPending() const
1460 return m_layoutTimer.isActive();
1463 bool FrameView::needsLayout() const
1465 // This can return true in cases where the document does not have a body yet.
1466 // Document::shouldScheduleLayout takes care of preventing us from scheduling
1467 // layout in that case.
1470 RenderView* root = m_frame->contentRenderer();
1471 Document* document = m_frame->document();
1472 return layoutPending()
1473 || (root && root->needsLayout())
1475 || (document && document->childNeedsStyleRecalc()) // can occur when using WebKit ObjC interface
1476 || m_frame->needsReapplyStyles()
1477 || (m_deferSetNeedsLayouts && m_setNeedsLayoutWasDeferred);
1480 void FrameView::setNeedsLayout()
1482 if (m_deferSetNeedsLayouts) {
1483 m_setNeedsLayoutWasDeferred = true;
1486 RenderView* root = m_frame->contentRenderer();
1488 root->setNeedsLayout(true);
1491 void FrameView::unscheduleRelayout()
1493 if (!m_layoutTimer.isActive())
1496 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1497 if (!m_frame->document()->ownerElement())
1498 printf("Layout timer unscheduled at %d\n", m_frame->document()->elapsedTime());
1501 m_layoutTimer.stop();
1502 m_delayedLayout = false;
1505 bool FrameView::isTransparent() const
1507 return m_isTransparent;
1510 void FrameView::setTransparent(bool isTransparent)
1512 m_isTransparent = isTransparent;
1515 Color FrameView::baseBackgroundColor() const
1517 return m_baseBackgroundColor;
1520 void FrameView::setBaseBackgroundColor(Color bc)
1524 m_baseBackgroundColor = bc;
1527 void FrameView::updateBackgroundRecursively(const Color& backgroundColor, bool transparent)
1529 for (Frame* frame = m_frame.get(); frame; frame = frame->tree()->traverseNext(m_frame.get())) {
1530 FrameView* view = frame->view();
1534 view->setTransparent(transparent);
1535 view->setBaseBackgroundColor(backgroundColor);
1539 bool FrameView::shouldUpdateWhileOffscreen() const
1541 return m_shouldUpdateWhileOffscreen;
1544 void FrameView::setShouldUpdateWhileOffscreen(bool shouldUpdateWhileOffscreen)
1546 m_shouldUpdateWhileOffscreen = shouldUpdateWhileOffscreen;
1549 void FrameView::scheduleEvent(PassRefPtr<Event> event, PassRefPtr<Node> eventTarget)
1551 if (!m_enqueueEvents) {
1552 ExceptionCode ec = 0;
1553 eventTarget->dispatchEvent(event, ec);
1557 ScheduledEvent* scheduledEvent = new ScheduledEvent;
1558 scheduledEvent->m_event = event;
1559 scheduledEvent->m_eventTarget = eventTarget;
1560 m_scheduledEvents.append(scheduledEvent);
1563 void FrameView::pauseScheduledEvents()
1565 ASSERT(m_scheduledEvents.isEmpty() || m_enqueueEvents);
1569 void FrameView::resumeScheduledEvents()
1572 if (!m_enqueueEvents)
1573 dispatchScheduledEvents();
1574 ASSERT(m_scheduledEvents.isEmpty() || m_enqueueEvents);
1577 void FrameView::scrollToAnchor()
1579 RefPtr<Node> anchorNode = m_maintainScrollPositionAnchor;
1583 if (!anchorNode->renderer())
1587 if (anchorNode != m_frame->document())
1588 rect = anchorNode->getRect();
1590 // Scroll nested layers and frames to reveal the anchor.
1591 // Align to the top and to the closest side (this matches other browsers).
1592 anchorNode->renderer()->enclosingLayer()->scrollRectToVisible(rect, true, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways);
1594 if (AXObjectCache::accessibilityEnabled())
1595 m_frame->document()->axObjectCache()->handleScrolledToAnchor(anchorNode.get());
1597 // scrollRectToVisible can call into setScrollPosition(), which resets m_maintainScrollPositionAnchor.
1598 m_maintainScrollPositionAnchor = anchorNode;
1601 bool FrameView::updateWidgets()
1603 if (m_nestedLayoutCount > 1 || !m_widgetUpdateSet || m_widgetUpdateSet->isEmpty())
1606 size_t size = m_widgetUpdateSet->size();
1608 Vector<RenderEmbeddedObject*> objects;
1609 objects.reserveCapacity(size);
1611 RenderEmbeddedObjectSet::const_iterator end = m_widgetUpdateSet->end();
1612 for (RenderEmbeddedObjectSet::const_iterator it = m_widgetUpdateSet->begin(); it != end; ++it) {
1613 objects.uncheckedAppend(*it);
1617 for (size_t i = 0; i < size; ++i) {
1618 RenderEmbeddedObject* object = objects[i];
1620 // The object may have been destroyed, but our manual ref() keeps the object from being deleted.
1621 object->updateWidget(false);
1622 object->updateWidgetPosition();
1624 m_widgetUpdateSet->remove(object);
1627 RenderArena* arena = m_frame->document()->renderArena();
1628 for (size_t i = 0; i < size; ++i)
1629 objects[i]->deref(arena);
1631 return m_widgetUpdateSet->isEmpty();
1634 void FrameView::performPostLayoutTasks()
1636 if (m_firstLayoutCallbackPending) {
1637 m_firstLayoutCallbackPending = false;
1638 m_frame->loader()->didFirstLayout();
1641 if (m_isVisuallyNonEmpty && m_firstVisuallyNonEmptyLayoutCallbackPending) {
1642 m_firstVisuallyNonEmptyLayoutCallbackPending = false;
1643 m_frame->loader()->didFirstVisuallyNonEmptyLayout();
1646 RenderView* root = m_frame->contentRenderer();
1648 root->updateWidgetPositions();
1650 for (unsigned i = 0; i < maxUpdateWidgetsIterations; i++) {
1651 if (updateWidgets())
1657 resumeScheduledEvents();
1659 if (!root->printing()) {
1660 IntSize currentSize = IntSize(width(), height());
1661 float currentZoomFactor = root->style()->zoom();
1662 bool resized = !m_firstLayout && (currentSize != m_lastLayoutSize || currentZoomFactor != m_lastZoomFactor);
1663 m_lastLayoutSize = currentSize;
1664 m_lastZoomFactor = currentZoomFactor;
1666 m_frame->eventHandler()->sendResizeEvent();
1670 void FrameView::postLayoutTimerFired(Timer<FrameView>*)
1672 performPostLayoutTasks();
1675 void FrameView::updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow)
1677 if (!m_viewportRenderer)
1680 if (m_overflowStatusDirty) {
1681 m_horizontalOverflow = horizontalOverflow;
1682 m_verticalOverflow = verticalOverflow;
1683 m_overflowStatusDirty = false;
1687 bool horizontalOverflowChanged = (m_horizontalOverflow != horizontalOverflow);
1688 bool verticalOverflowChanged = (m_verticalOverflow != verticalOverflow);
1690 if (horizontalOverflowChanged || verticalOverflowChanged) {
1691 m_horizontalOverflow = horizontalOverflow;
1692 m_verticalOverflow = verticalOverflow;
1694 scheduleEvent(OverflowEvent::create(horizontalOverflowChanged, horizontalOverflow,
1695 verticalOverflowChanged, verticalOverflow),
1696 m_viewportRenderer->node());
1701 void FrameView::dispatchScheduledEvents()
1703 if (m_scheduledEvents.isEmpty())
1706 Vector<ScheduledEvent*> scheduledEventsCopy = m_scheduledEvents;
1707 m_scheduledEvents.clear();
1709 Vector<ScheduledEvent*>::iterator end = scheduledEventsCopy.end();
1710 for (Vector<ScheduledEvent*>::iterator it = scheduledEventsCopy.begin(); it != end; ++it) {
1711 ScheduledEvent* scheduledEvent = *it;
1713 ExceptionCode ec = 0;
1715 // Only dispatch events to nodes that are in the document
1716 if (scheduledEvent->m_eventTarget->inDocument())
1717 scheduledEvent->m_eventTarget->dispatchEvent(scheduledEvent->m_event, ec);
1719 delete scheduledEvent;
1723 IntRect FrameView::windowClipRect(bool clipToContents) const
1725 ASSERT(m_frame->view() == this);
1727 // Set our clip rect to be our contents.
1728 IntRect clipRect = contentsToWindow(visibleContentRect(!clipToContents));
1729 if (!m_frame || !m_frame->document() || !m_frame->document()->ownerElement())
1732 // Take our owner element and get the clip rect from the enclosing layer.
1733 Element* elt = m_frame->document()->ownerElement();
1734 RenderLayer* layer = elt->renderer()->enclosingLayer();
1735 // FIXME: layer should never be null, but sometimes seems to be anyway.
1738 FrameView* parentView = elt->document()->view();
1739 clipRect.intersect(parentView->windowClipRectForLayer(layer, true));
1743 IntRect FrameView::windowClipRectForLayer(const RenderLayer* layer, bool clipToLayerContents) const
1745 // If we have no layer, just return our window clip rect.
1747 return windowClipRect();
1749 // Apply the clip from the layer.
1751 if (clipToLayerContents)
1752 clipRect = layer->childrenClipRect();
1754 clipRect = layer->selfClipRect();
1755 clipRect = contentsToWindow(clipRect);
1756 return intersection(clipRect, windowClipRect());
1759 bool FrameView::isActive() const
1761 Page* page = frame()->page();
1762 return page && page->focusController()->isActive();
1765 void FrameView::valueChanged(Scrollbar* bar)
1767 // Figure out if we really moved.
1768 IntSize offset = scrollOffset();
1769 ScrollView::valueChanged(bar);
1770 if (offset != scrollOffset())
1771 scrollPositionChanged();
1772 frame()->loader()->client()->didChangeScrollOffset();
1775 void FrameView::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
1777 // Add in our offset within the FrameView.
1778 IntRect dirtyRect = rect;
1779 dirtyRect.move(scrollbar->x(), scrollbar->y());
1780 invalidateRect(dirtyRect);
1783 void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const
1785 tickmarks = frame()->document()->markers()->renderedRectsForMarkers(DocumentMarker::TextMatch);
1788 IntRect FrameView::windowResizerRect() const
1790 Page* page = frame() ? frame()->page() : 0;
1793 return page->chrome()->windowResizerRect();
1796 #if ENABLE(DASHBOARD_SUPPORT)
1797 void FrameView::updateDashboardRegions()
1799 Document* document = m_frame->document();
1800 if (!document->hasDashboardRegions())
1802 Vector<DashboardRegionValue> newRegions;
1803 document->renderBox()->collectDashboardRegions(newRegions);
1804 if (newRegions == document->dashboardRegions())
1806 document->setDashboardRegions(newRegions);
1807 Page* page = m_frame->page();
1810 page->chrome()->client()->dashboardRegionsChanged();
1814 void FrameView::invalidateScrollCorner()
1816 invalidateRect(scrollCornerRect());
1819 void FrameView::updateScrollCorner()
1821 RenderObject* renderer = 0;
1822 RefPtr<RenderStyle> cornerStyle;
1824 if (!scrollCornerRect().isEmpty()) {
1825 // Try the <body> element first as a scroll corner source.
1826 Document* doc = m_frame->document();
1827 Element* body = doc ? doc->body() : 0;
1828 if (body && body->renderer()) {
1829 renderer = body->renderer();
1830 cornerStyle = renderer->getUncachedPseudoStyle(SCROLLBAR_CORNER, renderer->style());
1834 // If the <body> didn't have a custom style, then the root element might.
1835 Element* docElement = doc ? doc->documentElement() : 0;
1836 if (docElement && docElement->renderer()) {
1837 renderer = docElement->renderer();
1838 cornerStyle = renderer->getUncachedPseudoStyle(SCROLLBAR_CORNER, renderer->style());
1843 // If we have an owning iframe/frame element, then it can set the custom scrollbar also.
1844 if (RenderPart* renderer = m_frame->ownerRenderer())
1845 cornerStyle = renderer->getUncachedPseudoStyle(SCROLLBAR_CORNER, renderer->style());
1850 if (!m_scrollCorner)
1851 m_scrollCorner = new (renderer->renderArena()) RenderScrollbarPart(renderer->document());
1852 m_scrollCorner->setStyle(cornerStyle.release());
1853 invalidateRect(scrollCornerRect());
1854 } else if (m_scrollCorner) {
1855 m_scrollCorner->destroy();
1860 void FrameView::paintScrollCorner(GraphicsContext* context, const IntRect& cornerRect)
1862 if (context->updatingControlTints()) {
1863 updateScrollCorner();
1867 if (m_scrollCorner) {
1868 m_scrollCorner->paintIntoRect(context, cornerRect.x(), cornerRect.y(), cornerRect);
1872 ScrollView::paintScrollCorner(context, cornerRect);
1875 bool FrameView::hasCustomScrollbars() const
1877 const HashSet<RefPtr<Widget> >* viewChildren = children();
1878 HashSet<RefPtr<Widget> >::const_iterator end = viewChildren->end();
1879 for (HashSet<RefPtr<Widget> >::const_iterator current = viewChildren->begin(); current != end; ++current) {
1880 Widget* widget = current->get();
1881 if (widget->isFrameView()) {
1882 if (static_cast<FrameView*>(widget)->hasCustomScrollbars())
1884 } else if (widget->isScrollbar()) {
1885 Scrollbar* scrollbar = static_cast<Scrollbar*>(widget);
1886 if (scrollbar->isCustomScrollbar())
1894 void FrameView::updateControlTints()
1896 // This is called when control tints are changed from aqua/graphite to clear and vice versa.
1897 // We do a "fake" paint, and when the theme gets a paint call, it can then do an invalidate.
1898 // This is only done if the theme supports control tinting. It's up to the theme and platform
1899 // to define when controls get the tint and to call this function when that changes.
1901 // Optimize the common case where we bring a window to the front while it's still empty.
1902 if (!m_frame || m_frame->loader()->url().isEmpty())
1905 if ((m_frame->contentRenderer() && m_frame->contentRenderer()->theme()->supportsControlTints()) || hasCustomScrollbars()) {
1908 PlatformGraphicsContext* const noContext = 0;
1909 GraphicsContext context(noContext);
1910 context.setUpdatingControlTints(true);
1911 if (platformWidget())
1912 paintContents(&context, visibleContentRect());
1914 paint(&context, frameRect());
1918 bool FrameView::wasScrolledByUser() const
1920 return m_wasScrolledByUser;
1923 void FrameView::setWasScrolledByUser(bool wasScrolledByUser)
1925 if (m_inProgrammaticScroll)
1927 m_maintainScrollPositionAnchor = 0;
1928 m_wasScrolledByUser = wasScrolledByUser;
1931 void FrameView::paintContents(GraphicsContext* p, const IntRect& rect)
1936 #if ENABLE(INSPECTOR)
1937 if (InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent())
1938 timelineAgent->willPaint(rect);
1941 Document* document = frame()->document();
1945 if (document->printing())
1946 fillWithRed = false; // Printing, don't fill with red (can't remember why).
1947 else if (document->ownerElement())
1948 fillWithRed = false; // Subframe, don't fill with red.
1949 else if (isTransparent())
1950 fillWithRed = false; // Transparent, don't fill with red.
1951 else if (m_paintBehavior & PaintBehaviorSelectionOnly)
1952 fillWithRed = false; // Selections are transparent, don't fill with red.
1953 else if (m_nodeToDraw)
1954 fillWithRed = false; // Element images are transparent, don't fill with red.
1959 p->fillRect(rect, Color(0xFF, 0, 0), DeviceColorSpace);
1962 bool isTopLevelPainter = !sCurrentPaintTimeStamp;
1963 if (isTopLevelPainter)
1964 sCurrentPaintTimeStamp = currentTime();
1966 RenderView* contentRenderer = frame()->contentRenderer();
1967 if (!contentRenderer) {
1968 LOG_ERROR("called Frame::paint with nil renderer");
1972 ASSERT(!needsLayout());
1976 #if USE(ACCELERATED_COMPOSITING)
1977 if (!p->paintingDisabled()) {
1978 if (GraphicsLayer* rootLayer = contentRenderer->compositor()->rootPlatformLayer())
1979 rootLayer->syncCompositingState();
1983 ASSERT(!m_isPainting);
1985 m_isPainting = true;
1987 // m_nodeToDraw is used to draw only one element (and its descendants)
1988 RenderObject* eltRenderer = m_nodeToDraw ? m_nodeToDraw->renderer() : 0;
1990 PaintBehavior oldPaintBehavior = m_paintBehavior;
1991 if (m_paintBehavior == PaintBehaviorNormal)
1992 document->markers()->invalidateRenderedRectsForMarkersInRect(rect);
1994 if (document->printing())
1995 m_paintBehavior |= PaintBehaviorFlattenCompositingLayers;
1997 contentRenderer->layer()->paint(p, rect, m_paintBehavior, eltRenderer);
1999 m_paintBehavior = oldPaintBehavior;
2001 m_isPainting = false;
2002 m_lastPaintTime = currentTime();
2004 #if ENABLE(DASHBOARD_SUPPORT)
2005 // Regions may have changed as a result of the visibility/z-index of element changing.
2006 if (document->dashboardRegionsDirty())
2007 updateDashboardRegions();
2010 if (isTopLevelPainter)
2011 sCurrentPaintTimeStamp = 0;
2013 #if ENABLE(INSPECTOR)
2014 if (InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent())
2015 timelineAgent->didPaint();
2019 void FrameView::setPaintBehavior(PaintBehavior behavior)
2021 m_paintBehavior = behavior;
2024 PaintBehavior FrameView::paintBehavior() const
2026 return m_paintBehavior;
2029 bool FrameView::isPainting() const
2031 return m_isPainting;
2034 void FrameView::setNodeToDraw(Node* node)
2036 m_nodeToDraw = node;
2039 void FrameView::layoutIfNeededRecursive()
2041 // We have to crawl our entire tree looking for any FrameViews that need
2042 // layout and make sure they are up to date.
2043 // Mac actually tests for intersection with the dirty region and tries not to
2044 // update layout for frames that are outside the dirty region. Not only does this seem
2045 // pointless (since those frames will have set a zero timer to layout anyway), but
2046 // it is also incorrect, since if two frames overlap, the first could be excluded from the dirty
2047 // region but then become included later by the second frame adding rects to the dirty region
2048 // when it lays out.
2053 const HashSet<RefPtr<Widget> >* viewChildren = children();
2054 HashSet<RefPtr<Widget> >::const_iterator end = viewChildren->end();
2055 for (HashSet<RefPtr<Widget> >::const_iterator current = viewChildren->begin(); current != end; ++current) {
2056 Widget* widget = (*current).get();
2057 if (widget->isFrameView())
2058 static_cast<FrameView*>(widget)->layoutIfNeededRecursive();
2061 // layoutIfNeededRecursive is called when we need to make sure layout is up-to-date before
2062 // painting, so we need to flush out any deferred repaints too.
2063 flushDeferredRepaints();
2066 void FrameView::flushDeferredRepaints()
2068 if (!m_deferredRepaintTimer.isActive())
2070 m_deferredRepaintTimer.stop();
2071 doDeferredRepaints();
2074 void FrameView::forceLayout(bool allowSubtree)
2076 layout(allowSubtree);
2077 // We cannot unschedule a pending relayout, since the force can be called with
2078 // a tiny rectangle from a drawRect update. By unscheduling we in effect
2079 // "validate" and stop the necessary full repaint from occurring. Basically any basic
2080 // append/remove DHTML is broken by this call. For now, I have removed the optimization
2081 // until we have a better invalidation stategy. -dwh
2082 //unscheduleRelayout();
2085 void FrameView::forceLayoutForPagination(const FloatSize& pageSize, float maximumShrinkFactor, Frame::AdjustViewSizeOrNot shouldAdjustViewSize)
2087 // Dumping externalRepresentation(m_frame->renderer()).ascii() is a good trick to see
2088 // the state of things before and after the layout
2089 RenderView *root = toRenderView(m_frame->document()->renderer());
2091 int pageW = ceilf(pageSize.width());
2092 m_pageHeight = pageSize.height() ? pageSize.height() : visibleHeight();
2093 root->setWidth(pageW);
2094 root->setNeedsLayoutAndPrefWidthsRecalc();
2097 // If we don't fit in the given page width, we'll lay out again. If we don't fit in the
2098 // page width when shrunk, we will lay out at maximum shrink and clip extra content.
2099 // FIXME: We are assuming a shrink-to-fit printing implementation. A cropping
2100 // implementation should not do this!
2101 int rightmostPos = root->rightmostPosition();
2102 if (rightmostPos > pageSize.width()) {
2103 pageW = std::min<int>(rightmostPos, ceilf(pageSize.width() * maximumShrinkFactor));
2104 if (pageSize.height())
2105 m_pageHeight = pageW / pageSize.width() * pageSize.height();
2106 root->setWidth(pageW);
2107 root->setNeedsLayoutAndPrefWidthsRecalc();
2112 if (shouldAdjustViewSize)
2117 void FrameView::adjustPageHeight(float *newBottom, float oldTop, float oldBottom, float /*bottomLimit*/)
2119 RenderView* root = m_frame->contentRenderer();
2121 // Use a context with painting disabled.
2122 GraphicsContext context((PlatformGraphicsContext*)0);
2123 root->setTruncatedAt((int)floorf(oldBottom));
2124 IntRect dirtyRect(0, (int)floorf(oldTop), root->rightLayoutOverflow(), (int)ceilf(oldBottom - oldTop));
2125 root->layer()->paint(&context, dirtyRect);
2126 *newBottom = root->bestTruncatedAt();
2127 if (*newBottom == 0)
2128 *newBottom = oldBottom;
2130 *newBottom = oldBottom;
2133 IntRect FrameView::convertFromRenderer(const RenderObject* renderer, const IntRect& rendererRect) const
2135 IntRect rect = renderer->localToAbsoluteQuad(FloatRect(rendererRect)).enclosingBoundingBox();
2137 // Convert from page ("absolute") to FrameView coordinates.
2138 rect.move(-scrollX(), -scrollY());
2143 IntRect FrameView::convertToRenderer(const RenderObject* renderer, const IntRect& viewRect) const
2145 IntRect rect = viewRect;
2147 // Convert from FrameView coords into page ("absolute") coordinates.
2148 rect.move(scrollX(), scrollY());
2150 // FIXME: we don't have a way to map an absolute rect down to a local quad, so just
2151 // move the rect for now.
2152 rect.setLocation(roundedIntPoint(renderer->absoluteToLocal(rect.location(), false, true /* use transforms */)));
2156 IntPoint FrameView::convertFromRenderer(const RenderObject* renderer, const IntPoint& rendererPoint) const
2158 IntPoint point = roundedIntPoint(renderer->localToAbsolute(rendererPoint, false, true /* use transforms */));
2160 // Convert from page ("absolute") to FrameView coordinates.
2161 point.move(-scrollX(), -scrollY());
2165 IntPoint FrameView::convertToRenderer(const RenderObject* renderer, const IntPoint& viewPoint) const
2167 IntPoint point = viewPoint;
2169 // Convert from FrameView coords into page ("absolute") coordinates.
2170 point += IntSize(scrollX(), scrollY());
2172 return roundedIntPoint(renderer->absoluteToLocal(point, false, true /* use transforms */));
2175 IntRect FrameView::convertToContainingView(const IntRect& localRect) const
2177 if (const ScrollView* parentScrollView = parent()) {
2178 if (parentScrollView->isFrameView()) {
2179 const FrameView* parentView = static_cast<const FrameView*>(parentScrollView);
2180 // Get our renderer in the parent view
2181 RenderPart* renderer = m_frame->ownerRenderer();
2185 IntRect rect(localRect);
2186 // Add borders and padding??
2187 rect.move(renderer->borderLeft() + renderer->paddingLeft(),
2188 renderer->borderTop() + renderer->paddingTop());
2189 return parentView->convertFromRenderer(renderer, rect);
2192 return Widget::convertToContainingView(localRect);
2198 IntRect FrameView::convertFromContainingView(const IntRect& parentRect) const
2200 if (const ScrollView* parentScrollView = parent()) {
2201 if (parentScrollView->isFrameView()) {
2202 const FrameView* parentView = static_cast<const FrameView*>(parentScrollView);
2204 // Get our renderer in the parent view
2205 RenderPart* renderer = m_frame->ownerRenderer();
2209 IntRect rect = parentView->convertToRenderer(renderer, parentRect);
2210 // Subtract borders and padding
2211 rect.move(-renderer->borderLeft() - renderer->paddingLeft(),
2212 -renderer->borderTop() - renderer->paddingTop());
2216 return Widget::convertFromContainingView(parentRect);
2222 IntPoint FrameView::convertToContainingView(const IntPoint& localPoint) const
2224 if (const ScrollView* parentScrollView = parent()) {
2225 if (parentScrollView->isFrameView()) {
2226 const FrameView* parentView = static_cast<const FrameView*>(parentScrollView);
2228 // Get our renderer in the parent view
2229 RenderPart* renderer = m_frame->ownerRenderer();
2233 IntPoint point(localPoint);
2235 // Add borders and padding
2236 point.move(renderer->borderLeft() + renderer->paddingLeft(),
2237 renderer->borderTop() + renderer->paddingTop());
2238 return parentView->convertFromRenderer(renderer, point);
2241 return Widget::convertToContainingView(localPoint);
2247 IntPoint FrameView::convertFromContainingView(const IntPoint& parentPoint) const
2249 if (const ScrollView* parentScrollView = parent()) {
2250 if (parentScrollView->isFrameView()) {
2251 const FrameView* parentView = static_cast<const FrameView*>(parentScrollView);
2253 // Get our renderer in the parent view
2254 RenderPart* renderer = m_frame->ownerRenderer();
2258 IntPoint point = parentView->convertToRenderer(renderer, parentPoint);
2259 // Subtract borders and padding
2260 point.move(-renderer->borderLeft() - renderer->paddingLeft(),
2261 -renderer->borderTop() - renderer->paddingTop());
2265 return Widget::convertFromContainingView(parentPoint);
2271 bool FrameView::shouldApplyTextZoom() const
2273 if (m_zoomFactor == 1)
2277 Page* page = m_frame->page();
2278 return page && page->settings()->zoomMode() == ZoomTextOnly;
2281 bool FrameView::shouldApplyPageZoom() const
2283 if (m_zoomFactor == 1)
2287 Page* page = m_frame->page();
2288 return page && page->settings()->zoomMode() == ZoomPage;
2291 void FrameView::setZoomFactor(float percent, ZoomMode mode)
2296 Page* page = m_frame->page();
2300 if (m_zoomFactor == percent && page->settings()->zoomMode() == mode)
2303 Document* document = m_frame->document();
2308 // Respect SVGs zoomAndPan="disabled" property in standalone SVG documents.
2309 // FIXME: How to handle compound documents + zoomAndPan="disabled"? Needs SVG WG clarification.
2310 if (document->isSVGDocument()) {
2311 if (!static_cast<SVGDocument*>(document)->zoomAndPanEnabled())
2313 if (document->renderer())
2314 document->renderer()->setNeedsLayout(true);
2318 if (mode == ZoomPage) {
2319 // Update the scroll position when doing a full page zoom, so the content stays in relatively the same position.
2320 IntPoint scrollPosition = this->scrollPosition();
2321 float percentDifference = (percent / m_zoomFactor);
2322 setScrollPosition(IntPoint(scrollPosition.x() * percentDifference, scrollPosition.y() * percentDifference));
2325 m_zoomFactor = percent;
2326 page->settings()->setZoomMode(mode);
2328 document->recalcStyle(Node::Force);
2330 for (Frame* child = m_frame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
2331 if (FrameView* childView = child->view())
2332 childView->setZoomFactor(m_zoomFactor, mode);
2335 if (document->renderer() && document->renderer()->needsLayout() && didFirstLayout())
2341 void FrameView::setRepaintThrottlingDeferredRepaintDelay(double p)
2343 s_deferredRepaintDelay = p;
2346 // Negative value would mean that first few repaints happen without a delay
2347 void FrameView::setRepaintThrottlingnInitialDeferredRepaintDelayDuringLoading(double p)
2349 s_initialDeferredRepaintDelayDuringLoading = p;
2352 // The delay grows on each repaint to this maximum value
2353 void FrameView::setRepaintThrottlingMaxDeferredRepaintDelayDuringLoading(double p)
2355 s_maxDeferredRepaintDelayDuringLoading = p;
2358 // On each repaint the delay increases by this amount
2359 void FrameView::setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double p)
2361 s_deferredRepaintDelayIncrementDuringLoading = p;
2364 } // namespace WebCore