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