WebCore:
[WebKit-https.git] / WebCore / rendering / RenderView.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  */
20
21 #include "config.h"
22 #include "RenderView.h"
23
24 #include "Document.h"
25 #include "Element.h"
26 #include "FloatQuad.h"
27 #include "Frame.h"
28 #include "FrameView.h"
29 #include "GraphicsContext.h"
30 #include "HitTestResult.h"
31 #include "RenderLayer.h"
32 #include "RenderSelectionInfo.h"
33 #include "RenderWidget.h"
34 #include "TransformState.h"
35
36 #if USE(ACCELERATED_COMPOSITING)
37 #include "RenderLayerCompositor.h"
38 #endif
39
40 namespace WebCore {
41
42 RenderView::RenderView(Node* node, FrameView* view)
43     : RenderBlock(node)
44     , m_frameView(view)
45     , m_selectionStart(0)
46     , m_selectionEnd(0)
47     , m_selectionStartPos(-1)
48     , m_selectionEndPos(-1)
49     , m_printImages(true)
50     , m_maximalOutlineSize(0)
51     , m_layoutState(0)
52     , m_layoutStateDisableCount(0)
53 {
54     // Clear our anonymous bit, set because RenderObject assumes
55     // any renderer with document as the node is anonymous.
56     setIsAnonymous(false);
57
58     // init RenderObject attributes
59     setInline(false);
60     
61     m_minPrefWidth = 0;
62     m_maxPrefWidth = 0;
63
64     setPrefWidthsDirty(true, false);
65     
66     setPositioned(true); // to 0,0 :)
67
68     // Create a new root layer for our layer hierarchy.
69     m_layer = new (node->document()->renderArena()) RenderLayer(this);
70     setHasLayer(true);
71 }
72
73 RenderView::~RenderView()
74 {
75 }
76
77 void RenderView::calcHeight()
78 {
79     if (!printing() && m_frameView)
80         setHeight(viewHeight());
81 }
82
83 void RenderView::calcWidth()
84 {
85     if (!printing() && m_frameView)
86         setWidth(viewWidth());
87     m_marginLeft = 0;
88     m_marginRight = 0;
89 }
90
91 void RenderView::calcPrefWidths()
92 {
93     ASSERT(prefWidthsDirty());
94
95     RenderBlock::calcPrefWidths();
96
97     m_maxPrefWidth = m_minPrefWidth;
98 }
99
100 void RenderView::layout()
101 {
102     if (printing())
103         m_minPrefWidth = m_maxPrefWidth = width();
104
105     // Use calcWidth/Height to get the new width/height, since this will take the full page zoom factor into account.
106     bool relayoutChildren = !printing() && (!m_frameView || width() != viewWidth() || height() != viewHeight());
107     if (relayoutChildren) {
108         setChildNeedsLayout(true, false);
109         for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
110             if (child->style()->height().isPercent() || child->style()->minHeight().isPercent() || child->style()->maxHeight().isPercent())
111                 child->setChildNeedsLayout(true, false);
112         }
113     }
114
115     ASSERT(!m_layoutState);
116     LayoutState state;
117     // FIXME: May be better to push a clip and avoid issuing offscreen repaints.
118     state.m_clipped = false;
119     m_layoutState = &state;
120
121     if (needsLayout())
122         RenderBlock::layout();
123
124     m_docWidth = calcDocWidth();
125     m_docHeight = calcDocHeight();
126
127     setOverflowWidth(max(width(), m_docWidth));
128     setOverflowHeight(max(height(), m_docHeight));
129
130     ASSERT(layoutDelta() == IntSize());
131     ASSERT(m_layoutStateDisableCount == 0);
132     ASSERT(m_layoutState == &state);
133     m_layoutState = 0;
134     setNeedsLayout(false);
135 }
136
137 void RenderView::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool /*useTransforms*/, TransformState& transformState) const
138 {
139     // If a container was specified, and was not 0 or the RenderView,
140     // then we should have found it by now.
141     ASSERT_UNUSED(repaintContainer, !repaintContainer || repaintContainer == this);
142
143     if (fixed && m_frameView)
144         transformState.move(m_frameView->scrollOffset());
145 }
146
147 void RenderView::mapAbsoluteToLocalPoint(bool fixed, bool /*useTransforms*/, TransformState& transformState) const
148 {
149     if (fixed && m_frameView)
150         transformState.move(-m_frameView->scrollOffset());
151 }
152
153 void RenderView::paint(PaintInfo& paintInfo, int tx, int ty)
154 {
155     // If we ever require layout but receive a paint anyway, something has gone horribly wrong.
156     ASSERT(!needsLayout());
157
158     // Cache the print rect because the dirty rect could get changed during painting.
159     if (printing())
160         setPrintRect(paintInfo.rect);
161     else
162         setPrintRect(IntRect());
163     paintObject(paintInfo, tx, ty);
164 }
165
166 static inline bool rendererObscuresBackground(RenderObject* object)
167 {
168     return object && object->style()->visibility() == VISIBLE && object->style()->opacity() == 1 && !object->style()->hasTransform();
169 }
170     
171 void RenderView::paintBoxDecorations(PaintInfo& paintInfo, int, int)
172 {
173     // Check to see if we are enclosed by a layer that requires complex painting rules.  If so, we cannot blit
174     // when scrolling, and we need to use slow repaints.  Examples of layers that require this are transparent layers,
175     // layers with reflections, or transformed layers.
176     // FIXME: This needs to be dynamic.  We should be able to go back to blitting if we ever stop being inside
177     // a transform, transparency layer, etc.
178     Element* elt;
179     for (elt = document()->ownerElement(); view() && elt && elt->renderer(); elt = elt->document()->ownerElement()) {
180         RenderLayer* layer = elt->renderer()->enclosingLayer();
181         if (layer->requiresSlowRepaints()) {
182             frameView()->setUseSlowRepaints();
183             break;
184         }
185     }
186
187     // If painting will entirely fill the view, no need to fill the background.
188     if (elt || rendererObscuresBackground(firstChild()) || !view())
189         return;
190
191     // This code typically only executes if the root element's visibility has been set to hidden,
192     // or there is a transform on the <html>.
193     // Only fill with the base background color (typically white) if we're the root document, 
194     // since iframes/frames with no background in the child document should show the parent's background.
195     if (view()->isTransparent()) // FIXME: This needs to be dynamic.  We should be able to go back to blitting if we ever stop being transparent.
196         frameView()->setUseSlowRepaints(); // The parent must show behind the child.
197     else {
198         Color baseColor = frameView()->baseBackgroundColor();
199         if (baseColor.alpha() > 0) {
200             paintInfo.context->save();
201             paintInfo.context->setCompositeOperation(CompositeCopy);
202             paintInfo.context->fillRect(paintInfo.rect, baseColor);
203             paintInfo.context->restore();
204         } else
205             paintInfo.context->clearRect(paintInfo.rect);
206     }
207 }
208
209 bool RenderView::shouldRepaint(const IntRect& r) const
210 {
211     if (printing() || r.width() == 0 || r.height() == 0)
212         return false;
213
214     if (!m_frameView)
215         return false;
216     
217     return true;
218 }
219
220 void RenderView::repaintViewRectangle(const IntRect& ur, bool immediate)
221 {
222     if (!shouldRepaint(ur))
223         return;
224
225     // We always just invalidate the root view, since we could be an iframe that is clipped out
226     // or even invisible.
227     Element* elt = document()->ownerElement();
228     if (!elt)
229         m_frameView->repaintContentRectangle(ur, immediate);
230     else if (RenderBox* obj = elt->renderBox()) {
231         IntRect vr = viewRect();
232         IntRect r = intersection(ur, vr);
233         
234         // Subtract out the contentsX and contentsY offsets to get our coords within the viewing
235         // rectangle.
236         r.move(-vr.x(), -vr.y());
237         
238         // FIXME: Hardcoded offsets here are not good.
239         r.move(obj->borderLeft() + obj->paddingLeft(),
240                obj->borderTop() + obj->paddingTop());
241         obj->repaintRectangle(r, immediate);
242     }
243 }
244
245 void RenderView::repaintRectangleInViewAndCompositedLayers(const IntRect& ur, bool immediate)
246 {
247     if (!shouldRepaint(ur))
248         return;
249
250     repaintViewRectangle(ur, immediate);
251     
252 #if USE(ACCELERATED_COMPOSITING)
253     // If we're a frame, repaintViewRectangle will have repainted via a RenderObject in the
254     // parent document.
255     if (document()->ownerElement())
256         return;
257
258     if (compositor()->inCompositingMode())
259         compositor()->repaintCompositedLayersAbsoluteRect(ur);
260 #endif
261 }
262
263 void RenderView::computeRectForRepaint(RenderBoxModelObject* repaintContainer, IntRect& rect, bool fixed)
264 {
265     // If a container was specified, and was not 0 or the RenderView,
266     // then we should have found it by now.
267     ASSERT_UNUSED(repaintContainer, !repaintContainer || repaintContainer == this);
268
269     if (printing())
270         return;
271
272     if (fixed && m_frameView)
273         rect.move(m_frameView->scrollX(), m_frameView->scrollY());
274         
275     // Apply our transform if we have one (because of full page zooming).
276     if (m_layer && m_layer->transform())
277         rect = m_layer->transform()->mapRect(rect);
278 }
279
280 void RenderView::absoluteRects(Vector<IntRect>& rects, int tx, int ty, bool)
281 {
282     rects.append(IntRect(tx, ty, m_layer->width(), m_layer->height()));
283 }
284
285 void RenderView::absoluteQuads(Vector<FloatQuad>& quads, bool)
286 {
287     quads.append(FloatRect(0, 0, m_layer->width(), m_layer->height()));
288 }
289
290 static RenderObject* rendererAfterPosition(RenderObject* object, unsigned offset)
291 {
292     if (!object)
293         return 0;
294
295     RenderObject* child = object->childAt(offset);
296     return child ? child : object->nextInPreOrderAfterChildren();
297 }
298
299 IntRect RenderView::selectionBounds(bool clipToVisibleContent) const
300 {
301     document()->updateRendering();
302
303     typedef HashMap<RenderObject*, RenderSelectionInfo*> SelectionMap;
304     SelectionMap selectedObjects;
305
306     RenderObject* os = m_selectionStart;
307     RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
308     while (os && os != stop) {
309         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
310             // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
311             selectedObjects.set(os, new RenderSelectionInfo(os, clipToVisibleContent));
312             RenderBlock* cb = os->containingBlock();
313             while (cb && !cb->isRenderView()) {
314                 RenderSelectionInfo* blockInfo = selectedObjects.get(cb);
315                 if (blockInfo)
316                     break;
317                 selectedObjects.set(cb, new RenderSelectionInfo(cb, clipToVisibleContent));
318                 cb = cb->containingBlock();
319             }
320         }
321
322         os = os->nextInPreOrder();
323     }
324
325     // Now create a single bounding box rect that encloses the whole selection.
326     IntRect selRect;
327     SelectionMap::iterator end = selectedObjects.end();
328     for (SelectionMap::iterator i = selectedObjects.begin(); i != end; ++i) {
329         RenderSelectionInfo* info = i->second;
330         selRect.unite(info->rect());
331         delete info;
332     }
333     return selRect;
334 }
335
336 #if USE(ACCELERATED_COMPOSITING)
337 // Compositing layer dimensions take outline size into account, so we have to recompute layer
338 // bounds when it changes.
339 // FIXME: This is ugly; it would be nice to have a better way to do this.
340 void RenderView::setMaximalOutlineSize(int o)
341 {
342     if (o != m_maximalOutlineSize) {
343         m_maximalOutlineSize = o;
344
345         if (m_frameView)
346             m_frameView->updateCompositingLayers(FrameView::ForcedCompositingUpdate);
347     }
348 }
349 #endif
350
351 void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* end, int endPos)
352 {
353     // Make sure both our start and end objects are defined.
354     // Check www.msnbc.com and try clicking around to find the case where this happened.
355     if ((start && !end) || (end && !start))
356         return;
357
358     // Just return if the selection hasn't changed.
359     if (m_selectionStart == start && m_selectionStartPos == startPos &&
360         m_selectionEnd == end && m_selectionEndPos == endPos)
361         return;
362
363     // Record the old selected objects.  These will be used later
364     // when we compare against the new selected objects.
365     int oldStartPos = m_selectionStartPos;
366     int oldEndPos = m_selectionEndPos;
367
368     // Objects each have a single selection rect to examine.
369     typedef HashMap<RenderObject*, RenderSelectionInfo*> SelectedObjectMap;
370     SelectedObjectMap oldSelectedObjects;
371     SelectedObjectMap newSelectedObjects;
372
373     // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
374     // In order to get the repaint rect right, we have to examine left, middle, and right rects individually, since otherwise
375     // the union of those rects might remain the same even when changes have occurred.
376     typedef HashMap<RenderBlock*, RenderBlockSelectionInfo*> SelectedBlockMap;
377     SelectedBlockMap oldSelectedBlocks;
378     SelectedBlockMap newSelectedBlocks;
379
380     RenderObject* os = m_selectionStart;
381     RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
382     while (os && os != stop) {
383         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
384             // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
385             oldSelectedObjects.set(os, new RenderSelectionInfo(os, true));
386             RenderBlock* cb = os->containingBlock();
387             while (cb && !cb->isRenderView()) {
388                 RenderBlockSelectionInfo* blockInfo = oldSelectedBlocks.get(cb);
389                 if (blockInfo)
390                     break;
391                 oldSelectedBlocks.set(cb, new RenderBlockSelectionInfo(cb));
392                 cb = cb->containingBlock();
393             }
394         }
395
396         os = os->nextInPreOrder();
397     }
398
399     // Now clear the selection.
400     SelectedObjectMap::iterator oldObjectsEnd = oldSelectedObjects.end();
401     for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i)
402         i->first->setSelectionState(SelectionNone);
403
404     // set selection start and end
405     m_selectionStart = start;
406     m_selectionStartPos = startPos;
407     m_selectionEnd = end;
408     m_selectionEndPos = endPos;
409
410     // Update the selection status of all objects between m_selectionStart and m_selectionEnd
411     if (start && start == end)
412         start->setSelectionState(SelectionBoth);
413     else {
414         if (start)
415             start->setSelectionState(SelectionStart);
416         if (end)
417             end->setSelectionState(SelectionEnd);
418     }
419
420     RenderObject* o = start;
421     stop = rendererAfterPosition(end, endPos);
422
423     while (o && o != stop) {
424         if (o != start && o != end && o->canBeSelectionLeaf())
425             o->setSelectionState(SelectionInside);
426         o = o->nextInPreOrder();
427     }
428
429     // Now that the selection state has been updated for the new objects, walk them again and
430     // put them in the new objects list.
431     o = start;
432     while (o && o != stop) {
433         if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
434             newSelectedObjects.set(o, new RenderSelectionInfo(o, true));
435             RenderBlock* cb = o->containingBlock();
436             while (cb && !cb->isRenderView()) {
437                 RenderBlockSelectionInfo* blockInfo = newSelectedBlocks.get(cb);
438                 if (blockInfo)
439                     break;
440                 newSelectedBlocks.set(cb, new RenderBlockSelectionInfo(cb));
441                 cb = cb->containingBlock();
442             }
443         }
444
445         o = o->nextInPreOrder();
446     }
447
448     if (!m_frameView) {
449         // We built the maps, but we aren't going to use them.
450         // We need to delete the values, otherwise they'll all leak!
451         deleteAllValues(oldSelectedObjects);
452         deleteAllValues(newSelectedObjects);
453         deleteAllValues(oldSelectedBlocks);
454         deleteAllValues(newSelectedBlocks);
455         return;
456     }
457
458     // Have any of the old selected objects changed compared to the new selection?
459     for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i) {
460         RenderObject* obj = i->first;
461         RenderSelectionInfo* newInfo = newSelectedObjects.get(obj);
462         RenderSelectionInfo* oldInfo = i->second;
463         if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||
464             (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
465             (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
466             oldInfo->repaint();
467             if (newInfo) {
468                 newInfo->repaint();
469                 newSelectedObjects.remove(obj);
470                 delete newInfo;
471             }
472         }
473         delete oldInfo;
474     }
475
476     // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
477     SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
478     for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i) {
479         RenderSelectionInfo* newInfo = i->second;
480         newInfo->repaint();
481         delete newInfo;
482     }
483
484     // Have any of the old blocks changed?
485     SelectedBlockMap::iterator oldBlocksEnd = oldSelectedBlocks.end();
486     for (SelectedBlockMap::iterator i = oldSelectedBlocks.begin(); i != oldBlocksEnd; ++i) {
487         RenderBlock* block = i->first;
488         RenderBlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
489         RenderBlockSelectionInfo* oldInfo = i->second;
490         if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {
491             oldInfo->repaint();
492             if (newInfo) {
493                 newInfo->repaint();
494                 newSelectedBlocks.remove(block);
495                 delete newInfo;
496             }
497         }
498         delete oldInfo;
499     }
500
501     // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
502     SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
503     for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i) {
504         RenderBlockSelectionInfo* newInfo = i->second;
505         newInfo->repaint();
506         delete newInfo;
507     }
508 }
509
510 void RenderView::clearSelection()
511 {
512     setSelection(0, -1, 0, -1);
513 }
514
515 void RenderView::selectionStartEnd(int& startPos, int& endPos) const
516 {
517     startPos = m_selectionStartPos;
518     endPos = m_selectionEndPos;
519 }
520
521 bool RenderView::printing() const
522 {
523     return document()->printing();
524 }
525
526 void RenderView::updateWidgetPositions()
527 {
528     RenderWidgetSet::iterator end = m_widgets.end();
529     for (RenderWidgetSet::iterator it = m_widgets.begin(); it != end; ++it)
530         (*it)->updateWidgetPosition();
531 }
532
533 void RenderView::addWidget(RenderWidget* o)
534 {
535     m_widgets.add(o);
536 }
537
538 void RenderView::removeWidget(RenderWidget* o)
539 {
540     m_widgets.remove(o);
541 }
542
543 IntRect RenderView::viewRect() const
544 {
545     if (printing())
546         return IntRect(0, 0, width(), height());
547     if (m_frameView)
548         return m_frameView->visibleContentRect();
549     return IntRect();
550 }
551
552 int RenderView::calcDocHeight() const
553 {
554     // Exclude our own height, since it always matches the viewport height.  We want to know the height
555     // of the document if it is potentially smaller than the viewport (this value will be used when trying
556     // to figure out if scrollbars are needed).
557     int h = max(0, lowestPosition(true, false));
558
559     // FIXME: This doesn't do any margin collapsing.
560     // Instead of this dh computation we should keep the result
561     // when we call RenderBlock::layout.
562     int dh = 0;
563     for (RenderBox* c = firstChildBox(); c; c = c->nextSiblingBox())
564         dh += c->height() + c->marginTop() + c->marginBottom();
565
566     if (dh > h)
567         h = dh;
568
569     return h;
570 }
571
572 int RenderView::calcDocWidth() const
573 {
574     // Exclude our own width, since it always matches the viewport width.  We want to know the width
575     // of the document if it is potentially smaller than the viewport (this value will be used when trying
576     // to figure out if scrollbars are needed).
577     int w = max(0, rightmostPosition(true, false));
578
579     for (RenderBox* c = firstChildBox(); c; c = c->nextSiblingBox()) {
580         int dw = c->width() + c->marginLeft() + c->marginRight();
581         if (dw > w)
582             w = dw;
583     }
584
585     return w;
586 }
587
588 int RenderView::viewHeight() const
589 {
590     int height = 0;
591     if (!printing() && m_frameView) {
592         height = m_frameView->layoutHeight();
593         height = m_frameView->useFixedLayout() ? ceilf(style()->effectiveZoom() * float(height)) : height;
594     }
595     return height;
596 }
597
598 int RenderView::viewWidth() const
599 {
600     int width = 0;
601     if (!printing() && m_frameView) {
602         width = m_frameView->layoutWidth();
603         width = m_frameView->useFixedLayout() ? ceilf(style()->effectiveZoom() * float(width)) : width;
604     }
605     return width;
606 }
607
608 float RenderView::zoomFactor() const
609 {
610     if (m_frameView->frame() && m_frameView->frame()->shouldApplyPageZoom())
611         return m_frameView->frame()->zoomFactor();
612
613     return 1.0f;
614 }
615
616 // The idea here is to take into account what object is moving the pagination point, and
617 // thus choose the best place to chop it.
618 void RenderView::setBestTruncatedAt(int y, RenderBoxModelObject* forRenderer, bool forcedBreak)
619 {
620     // Nobody else can set a page break once we have a forced break.
621     if (m_forcedPageBreak)
622         return;
623
624     // Forced breaks always win over unforced breaks.
625     if (forcedBreak) {
626         m_forcedPageBreak = true;
627         m_bestTruncatedAt = y;
628         return;
629     }
630
631     // Prefer the widest object that tries to move the pagination point
632     IntRect boundingBox = forRenderer->borderBoundingBox();
633     if (boundingBox.width() > m_truncatorWidth) {
634         m_truncatorWidth = boundingBox.width();
635         m_bestTruncatedAt = y;
636     }
637 }
638
639 void RenderView::pushLayoutState(RenderObject* root)
640 {
641     ASSERT(!doingFullRepaint());
642     ASSERT(m_layoutStateDisableCount == 0);
643     ASSERT(m_layoutState == 0);
644
645     m_layoutState = new (renderArena()) LayoutState(root);
646 }
647
648 void RenderView::updateHitTestResult(HitTestResult& result, const IntPoint& point)
649 {
650     if (result.innerNode())
651         return;
652
653     Node* node = document()->documentElement();
654     if (node) {
655         result.setInnerNode(node);
656         if (!result.innerNonSharedNode())
657             result.setInnerNonSharedNode(node);
658         result.setLocalPoint(point);
659     }
660 }
661
662 #if USE(ACCELERATED_COMPOSITING)
663 bool RenderView::usesCompositing() const
664 {
665     return m_compositor && m_compositor->inCompositingMode();
666 }
667
668 RenderLayerCompositor* RenderView::compositor()
669 {
670     if (!m_compositor)
671         m_compositor.set(new RenderLayerCompositor(this));
672
673     return m_compositor.get();
674 }
675 #endif
676
677 void RenderView::didMoveOnscreen()
678 {
679 #if USE(ACCELERATED_COMPOSITING)
680     if (m_compositor)
681         m_compositor->didMoveOnscreen();
682 #endif
683 }
684
685 void RenderView::willMoveOffscreen()
686 {
687 #if USE(ACCELERATED_COMPOSITING)
688     if (m_compositor)
689         m_compositor->willMoveOffscreen();
690 #endif
691 }
692
693 } // namespace WebCore