Changeset 40544 in webkit


Ignore:
Timestamp:
Feb 3, 2009 12:43:55 PM (15 years ago)
Author:
Simon Fraser
Message:

2009-02-02 Simon Fraser <Simon Fraser>

Reviewed by Dave Hyatt

​https://bugs.webkit.org/show_bug.cgi?id=23358

Hook accelerated compositing into RenderLayer.

Location:
trunk/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r40543 r40544  
     12009-02-02  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Reviewed by Dave Hyatt
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=23358
     6
     7        Hook accelerated compositing into RenderLayer.
     8
     9        * rendering/RenderLayer.cpp:
     10        (WebCore::RenderLayer::RenderLayer):
     11        (WebCore::RenderLayer::~RenderLayer):
     12        Init and clean up backing and the hasCompositingDescendant bit.
     13       
     14        (WebCore::RenderLayer::compositor):
     15        Shortcut to get to the RenderLayerCompositor.
     16
     17        (WebCore::RenderLayer::updateLayerPositions):
     18        We need to let full repaints propagate to all compositing layers, and
     19        update the backing after layout here.
     20       
     21        (WebCore::RenderLayer::transparentAncestor):
     22        (WebCore::transparencyClipBox):
     23        (WebCore::RenderLayer::beginTransparencyLayers):
     24        Account for the fact that opacity may be rendered via the compositing
     25        layer sometimes.
     26       
     27        (WebCore::RenderLayer::addChild):
     28        (WebCore::RenderLayer::removeChild):
     29        (WebCore::RenderLayer::removeOnlyThisLayer):
     30        Tell the compositor when the RenderLayer hierarchy changes.
     31       
     32        (WebCore::RenderLayer::scrollToOffset):
     33        Update layer geometry after scrolling.
     34       
     35        (WebCore::RenderLayer::paintLayer):
     36        We short-circuit painting on composited layers, because these layers
     37        are painted on a callback from the compositing system.
     38       
     39        (WebCore::RenderLayer::hitTestLayer):
     40        Only apply transforms if we are rendering them in software.
     41       
     42        (WebCore::RenderLayer::localBoundingBox):
     43        (WebCore::RenderLayer::boundingBox):
     44        (WebCore::RenderLayer::absoluteBoundingBox):
     45        Refactor bounding box code that we can compute local, and ancestor-relative
     46        bounding box, as well as absolute.
     47       
     48        (WebCore::RenderLayer::ensureBacking):
     49        (WebCore::RenderLayer::clearBacking):
     50        RenderLayerBacking creation and destruction.
     51       
     52        (WebCore::RenderLayer::setParent):
     53        Tell the compositor when the RenderLayer hierarchy changes.
     54
     55        (WebCore::RenderLayer::dirtyZOrderLists):
     56        (WebCore::RenderLayer::dirtyStackingContextZOrderLists):
     57        (WebCore::RenderLayer::dirtyOverflowList):
     58        When the z-order and overflow lists change, we need to tell the
     59        compositor that the composited layers need to be rejiggered soon.
     60       
     61        (WebCore::RenderLayer::updateZOrderLists):
     62        Whitespace cleanup.
     63       
     64        (WebCore::RenderLayer::setBackingNeedsRepaint):
     65        (WebCore::RenderLayer::setBackingNeedsRepaintInRect):
     66        Dirty composited layer contents for painting.
     67       
     68        (WebCore::RenderLayer::styleChanged):
     69        Update the layer backing after style changes.
     70
     71        * rendering/RenderLayer.h:
     72        (WebCore::RenderLayer::isComposited):
     73        (WebCore::RenderLayer::backing):
     74        Accessors for testing and getting the backing for this RenderLayer.
     75       
     76        (WebCore::RenderLayer::paintsWithTransparency):
     77        (WebCore::RenderLayer::paintsWithTransform):
     78        Transform and opacity can be applied via the compositing layer, or rendered
     79        in software. These methods tell us if we need to account for them in the
     80        non-compositing path.
     81       
     82        (WebCore::RenderLayer::hasCompositingDescendant):
     83        (WebCore::RenderLayer::setHasCompositingDescendant):
     84        Maintain a bit to tell if this layer has composited descendants.
     85
    1862009-02-03  Simon Fraser  <simon.fraser@apple.com>
    287

  • trunk/WebCore/rendering/RenderLayer.cpp

    r40486 r40544  
    4545#include "RenderLayer.h"
    4646
     47#include "CString.h"
    4748#include "CSSPropertyNames.h"
     49#include "CSSStyleSelector.h"
    4850#include "Document.h"
    4951#include "EventHandler.h"
    … …  
    7476#include "ScrollbarTheme.h"
    7577#include "SelectionController.h"
     78#include "TransformationMatrix.h"
    7679#include "TranslateTransformOperation.h"
    7780#include <wtf/StdLibExtras.h>
     81
     82#if USE(ACCELERATED_COMPOSITING)
     83#include "RenderLayerBacking.h"
     84#include "RenderLayerCompositor.h"
     85#endif
    7886
    7987#if ENABLE(SVG)
    … …  
    157165    , m_visibleDescendantStatusDirty(false)
    158166    , m_hasVisibleDescendant(false)
     167#if USE(ACCELERATED_COMPOSITING)
     168    , m_hasCompositingDescendant(false)
     169#endif
    159170    , m_marquee(0)
    160171    , m_staticX(0)
    … …  
    164175    , m_scrollCorner(0)
    165176    , m_resizer(0)
     177#if USE(ACCELERATED_COMPOSITING)
     178    , m_backing(0)
     179#endif
    166180{
    167181    if (!renderer->firstChild() && renderer->style()) {
    … …  
    189203    delete m_marquee;
    190204
     205#if USE(ACCELERATED_COMPOSITING)
     206    clearBacking();
     207#endif
     208   
    191209    // Make sure we have no lingering clip rects.
    192210    ASSERT(!m_clipRects);
    … …  
    205223}
    206224
     225#if USE(ACCELERATED_COMPOSITING)
     226RenderLayerCompositor* RenderLayer::compositor() const
     227{
     228    return renderer()->view()->compositor();
     229}
     230#endif // USE(ACCELERATED_COMPOSITING)
     231
    207232void RenderLayer::updateLayerPositions(bool doFullRepaint, bool checkForRepaint)
    208233{
    209234    if (doFullRepaint) {
    210235        renderer()->repaint();
     236#if USE(ACCELERATED_COMPOSITING)
     237        checkForRepaint = false;
     238        // We need the full repaint to propagate to child layers if we are hardware compositing.
     239        if (!compositor()->inCompositingMode())
     240            doFullRepaint = false;
     241#else
    211242        checkForRepaint = doFullRepaint = false;
     243#endif
    212244    }
    213245   
    … …  
    260292    for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
    261293        child->updateLayerPositions(doFullRepaint, checkForRepaint);
     294
     295#if USE(ACCELERATED_COMPOSITING)
     296    if (isComposited())
     297        backing()->updateAfterLayout();
     298#endif
    262299       
    263300    // With all our children positioned, now update our marquee if we need to.
    … …  
    496533}
    497534
    498 RenderLayer*
    499 RenderLayer::transparentAncestor()
    500 {
    501     RenderLayer* curr = parent();
    502     for ( ; curr && !curr->isTransparent(); curr = curr->parent()) { }
    503     return curr;
     535RenderLayer* RenderLayer::transparentPaintingAncestor()
     536{
     537    if (isComposited())
     538        return 0;
     539
     540    for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
     541        if (curr->isComposited())
     542            return 0;
     543        if (curr->isTransparent())
     544            return curr;
     545    }
     546    return 0;
    504547}
    505548
    … …  
    510553    // would be better to respect clips.
    511554   
    512     TransformationMatrix* t = l->transform();
    513     if (t && rootLayer != l) {
     555    if (rootLayer != l && l->paintsWithTransform()) {
    514556        // The best we can do here is to use enclosed bounding boxes to establish a "fuzzy" enough clip to encompass
    515557        // the transformed layer and all of its children.
    … …  
    517559        int y = 0;
    518560        l->convertToLayerCoords(rootLayer, x, y);
     561
    519562        TransformationMatrix transform;
    520563        transform.translate(x, y);
    521         transform = *t * transform;
     564        transform = *l->transform() * transform;
    522565        transform = transform * enclosingTransform;
    523566
    … …  
    553596void RenderLayer::beginTransparencyLayers(GraphicsContext* p, const RenderLayer* rootLayer)
    554597{
    555     if (p->paintingDisabled() || (isTransparent() && m_usedTransparency))
    556         return;
    557    
    558     RenderLayer* ancestor = transparentAncestor();
     598    if (p->paintingDisabled() || (paintsWithTransparency() && m_usedTransparency))
     599        return;
     600   
     601    RenderLayer* ancestor = transparentPaintingAncestor();
    559602    if (ancestor)
    560603        ancestor->beginTransparencyLayers(p, rootLayer);
    561604   
    562     if (isTransparent()) {
     605    if (paintsWithTransparency()) {
    563606        m_usedTransparency = true;
    564607        p->save();
    … …  
    617660    if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
    618661        childVisibilityChanged(true);
     662   
     663#if USE(ACCELERATED_COMPOSITING)
     664    compositor()->layerWasAdded(this, child);
     665#endif
    619666}
    620667
    621668RenderLayer* RenderLayer::removeChild(RenderLayer* oldChild)
    622669{
     670#if USE(ACCELERATED_COMPOSITING)
     671    compositor()->layerWillBeRemoved(this, oldChild);
     672#endif
     673
    623674    // remove the child
    624675    if (oldChild->previousSibling())
    … …  
    657708        return;
    658709   
     710#if USE(ACCELERATED_COMPOSITING)
     711    compositor()->layerWillBeRemoved(m_parent, this);
     712#endif
     713
    659714    // Dirty the clip rects.
    660715    clearClipRectsIncludingDescendants();
    … …  
    834889    for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
    835890        child->updateLayerPositions(false, false);
     891
     892#if USE(ACCELERATED_COMPOSITING)
     893    if (isComposited())
     894        m_backing->updateGraphicsLayerGeometry();
     895#endif
    836896   
    837897    RenderView* view = renderer()->view();
    … …  
    16571717                        RenderObject* paintingRoot, bool appliedTransform, bool temporaryClipRects)
    16581718{
     1719#if USE(ACCELERATED_COMPOSITING)
     1720    // Composited RenderLayers are painted via the backing's paintIntoLayer().
     1721    if (isComposited() && !backing()->paintingGoesToWindow())
     1722        return;
     1723#endif
     1724
    16591725    // Avoid painting layers when stylesheets haven't loaded.  This eliminates FOUC.
    16601726    // It's ok not to draw, because later on, when all the stylesheets do load, updateStyleSelector on the Document
    … …  
    16671733        return;
    16681734
    1669     if (isTransparent())
     1735    if (paintsWithTransparency())
    16701736        haveTransparency = true;
    16711737
    16721738    // Apply a transform if we have one.  A reflection is considered to be a transform, since it is a flip and a translate.
    1673     if (m_transform && !appliedTransform) {
     1739    if (paintsWithTransform() && !appliedTransform) {
    16741740        // If the transform can't be inverted, then don't paint anything.
    16751741        if (!m_transform->isInvertible())
    … …  
    17131779        // Now do a paint with the root layer shifted to be us.
    17141780        paintLayer(this, p, transform.inverse().mapRect(paintDirtyRect), haveTransparency, paintRestriction, paintingRoot, true, temporaryClipRects);
    1715        
     1781
    17161782        p->restore();
    17171783       
    … …  
    17391805                             
    17401806    // Ensure our lists are up-to-date.
    1741     updateZOrderLists();
    1742     updateOverflowList();
     1807    updateLayerListsIfNeeded();
    17431808
    17441809    bool selectionOnly = paintRestriction == PaintRestrictionSelectionOnly || paintRestriction == PaintRestrictionSelectionOnlyBlackText;
    … …  
    18371902
    18381903    // End our transparency layer
    1839     if (isTransparent() && m_usedTransparency) {
     1904    if (haveTransparency && m_usedTransparency) {
    18401905        p->endTransparencyLayer();
    18411906        p->restore();
    … …  
    18951960{
    18961961    // Apply a transform if we have one.
    1897     if (m_transform && !appliedTransform) {
     1962    if (paintsWithTransform() && !appliedTransform) {
    18981963        // If the transform can't be inverted, then don't hit test this layer at all.
    18991964        if (!m_transform->isInvertible())
    … …  
    19311996   
    19321997    // Ensure our lists are up-to-date.
    1933     updateZOrderLists();
    1934     updateOverflowList();
     1998    updateLayerListsIfNeeded();
    19351999
    19362000    // This variable tracks which layer the mouse ends up being inside.  The minute we find an insideLayer,
    … …  
    22062270}
    22072271
    2208 IntRect RenderLayer::boundingBox(const RenderLayer* rootLayer) const
     2272IntRect RenderLayer::localBoundingBox() const
    22092273{
    22102274    // There are three special cases we need to consider.
    … …  
    22292293        for (InlineRunBox* curr = firstBox->nextLineBox(); curr; curr = curr->nextLineBox())
    22302294            left = min(left, curr->xPos());
    2231         result = IntRect(m_x + left, m_y + (top - renderer()->y()), width(), bottom - top);
     2295        result = IntRect(left, (top - renderer()->y()), width(), bottom - top);
    22322296    } else if (renderer()->isTableRow()) {
    22332297        // Our bounding box is just the union of all of our cells' border/overflow rects.
    … …  
    22412305            }
    22422306        }
    2243         result.move(m_x, m_y);
    22442307    } else {
    22452308        if (renderer()->hasMask())
    … …  
    22522315                result.unite(overflowRect);
    22532316        }
    2254 
    2255         // We have to adjust the x/y of this result so that it is in the coordinate space of the layer.
    2256         result.move(m_x, m_y);
    2257     }
    2258    
    2259     // Convert the bounding box to an absolute position.  We can do this easily by looking at the delta
    2260     // between the bounding box's xpos and our layer's xpos and then applying that to the absolute layerBounds
    2261     // passed in.
    2262     int absX = 0, absY = 0;
    2263     convertToLayerCoords(rootLayer, absX, absY);
    2264     result.move(absX - m_x, absY - m_y);
     2317    }
     2318
    22652319    RenderView* view = renderer()->view();
    22662320    ASSERT(view);
    22672321    if (view)
    2268         result.inflate(view->maximalOutlineSize());
     2322        result.inflate(view->maximalOutlineSize()); // Used to apply a fudge factor to dirty-rect checks on blocks/tables.
     2323
    22692324    return result;
     2325}
     2326
     2327IntRect RenderLayer::boundingBox(const RenderLayer* ancestorLayer) const
     2328{   
     2329    IntRect result = localBoundingBox();
     2330
     2331    int deltaX = 0, deltaY = 0;
     2332    convertToLayerCoords(ancestorLayer, deltaX, deltaY);
     2333    result.move(deltaX, deltaY);
     2334    return result;
     2335}
     2336
     2337IntRect RenderLayer::absoluteBoundingBox() const
     2338{
     2339    return boundingBox(root());
    22702340}
    22712341
    … …  
    22902360#endif   
    22912361    }
     2362}
     2363
     2364#if USE(ACCELERATED_COMPOSITING)
     2365RenderLayerBacking* RenderLayer::ensureBacking()
     2366{
     2367    m_backing.adopt(new RenderLayerBacking(this));
     2368    return m_backing.get();
     2369}
     2370
     2371void RenderLayer::clearBacking()
     2372{
     2373    m_backing.clear();
     2374}
     2375#endif
     2376
     2377void RenderLayer::setParent(RenderLayer* parent)
     2378{
     2379    if (parent == m_parent)
     2380        return;
     2381
     2382#if USE(ACCELERATED_COMPOSITING)
     2383    if (m_parent && compositor())
     2384        compositor()->layerWillBeRemoved(m_parent, this);
     2385#endif
     2386   
     2387    m_parent = parent;
     2388   
     2389#if USE(ACCELERATED_COMPOSITING)
     2390    if (m_parent)
     2391        compositor()->layerWasAdded(m_parent, this);
     2392#endif
    22922393}
    22932394
    … …  
    23872488        m_negZOrderList->clear();
    23882489    m_zOrderListsDirty = true;
     2490
     2491#if USE(ACCELERATED_COMPOSITING)
     2492    if (compositor())
     2493        compositor()->setCompositingLayersNeedUpdate();
     2494#endif
    23892495}
    23902496
    … …  
    24012507        m_overflowList->clear();
    24022508    m_overflowListDirty = true;
     2509
     2510#if USE(ACCELERATED_COMPOSITING)
     2511    if (compositor())
     2512        compositor()->setCompositingLayersNeedUpdate();
     2513#endif
    24032514}
    24042515
    … …  
    24072518    if (!isStackingContext() || !m_zOrderListsDirty)
    24082519        return;
    2409        
     2520
    24102521    for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
    24112522        if (!m_reflection || reflectionLayer() != child)
    … …  
    24152526    if (m_posZOrderList)
    24162527        std::stable_sort(m_posZOrderList->begin(), m_posZOrderList->end(), compareZIndex);
     2528
    24172529    if (m_negZOrderList)
    24182530        std::stable_sort(m_negZOrderList->begin(), m_negZOrderList->end(), compareZIndex);
    … …  
    24662578}
    24672579
     2580void RenderLayer::updateLayerListsIfNeeded()
     2581{
     2582#if USE(ACCELERATED_COMPOSITING)
     2583    if (compositor()->inCompositingMode()) {
     2584        if ((isStackingContext() && m_zOrderListsDirty) || m_overflowListDirty)
     2585            compositor()->updateCompositingLayers(this);
     2586        return;
     2587    }
     2588#endif
     2589    updateZOrderLists();
     2590    updateOverflowList();
     2591}
     2592
    24682593void RenderLayer::repaintIncludingDescendants()
    24692594{
    … …  
    24722597        curr->repaintIncludingDescendants();
    24732598}
     2599
     2600#if USE(ACCELERATED_COMPOSITING)
     2601void RenderLayer::setBackingNeedsRepaint()
     2602{
     2603    ASSERT(isComposited());
     2604    if (backing()->paintingGoesToWindow()) {
     2605        // If we're trying to repaint the placeholder document layer, propagate the
     2606        // repaint to the native view system.
     2607        RenderView* view = renderer()->view();
     2608        if (view)
     2609            view->repaintViewRectangle(absoluteBoundingBox());
     2610    } else
     2611        backing()->setContentsNeedDisplay();
     2612}
     2613
     2614void RenderLayer::setBackingNeedsRepaintInRect(const IntRect& r)
     2615{
     2616    ASSERT(isComposited());
     2617    if (backing()->paintingGoesToWindow()) {
     2618        // If we're trying to repaint the placeholder document layer, propagate the
     2619        // repaint to the native view system.
     2620        IntRect absRect(r);
     2621        int x = 0;
     2622        int y = 0;
     2623        convertToLayerCoords(root(), x, y);
     2624        absRect.move(x, y);
     2625
     2626        RenderView* view = renderer()->view();
     2627        if (view)
     2628            view->repaintViewRectangle(absRect);
     2629    } else
     2630        backing()->setContentsNeedDisplayInRect(r);
     2631}
     2632#endif
    24742633
    24752634bool RenderLayer::shouldBeOverflowOnly() const
    … …  
    24822641}
    24832642
    2484 void RenderLayer::styleChanged(RenderStyle::Diff, const RenderStyle*)
     2643void RenderLayer::styleChanged(RenderStyle::Diff diff, const RenderStyle*)
    24852644{
    24862645    bool isOverflowOnly = shouldBeOverflowOnly();
    … …  
    25202679    updateScrollCornerStyle();
    25212680    updateResizerStyle();
     2681
     2682#if USE(ACCELERATED_COMPOSITING)
     2683    updateTransform();
     2684
     2685    if (compositor()->updateLayerCompositingState(this, diff))
     2686        compositor()->setCompositingLayersNeedUpdate();
     2687#else
     2688    UNUSED_PARAM(diff);
     2689#endif
    25222690}
    25232691

  • trunk/WebCore/rendering/RenderLayer.h

    r40500 r40544  
    5252namespace WebCore {
    5353
    54 class TransformationMatrix;
    5554class CachedResource;
    5655class HitTestRequest;
    … …  
    6564class RenderView;
    6665class Scrollbar;
     66class TransformationMatrix;
     67
     68#if USE(ACCELERATED_COMPOSITING)
     69class RenderLayerBacking;
     70class RenderLayerCompositor;
     71#endif
    6772
    6873class ClipRects {
    … …  
    200205    void repaintIncludingDescendants();
    201206
     207#if USE(ACCELERATED_COMPOSITING)
     208    // Indicate that the layer contents need to be repainted. Only has an effect
     209    // if layer compositing is being used,
     210    void setBackingNeedsRepaint();
     211    void setBackingNeedsRepaintInRect(const IntRect& r); // r is in the coordinate space of the layer's render object
     212#endif
     213
    202214    void styleChanged(RenderStyle::Diff, const RenderStyle*);
    203215
    … …  
    210222
    211223    bool isTransparent() const;
    212     RenderLayer* transparentAncestor();
     224    RenderLayer* transparentPaintingAncestor();
    213225    void beginTransparencyLayers(GraphicsContext*, const RenderLayer* rootLayer);
    214226
    … …  
    288300    bool inResizeMode() const { return m_inResizeMode; }
    289301    void setInResizeMode(bool b) { m_inResizeMode = b; }
     302
     303#if USE(ACCELERATED_COMPOSITING)
     304    RenderLayerCompositor* compositor() const;
     305#endif
    290306   
    291307    void updateLayerPosition();
    … …  
    353369    bool intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect, const RenderLayer* rootLayer) const;
    354370
    355     // Returns a bounding box for this layer only.
     371    // Bounding box relative to some ancestor layer.
    356372    IntRect boundingBox(const RenderLayer* rootLayer) const;
     373    // Bounding box in the coordinates of this layer.
     374    IntRect localBoundingBox() const;
     375    // Bounding box relative to the root.
     376    IntRect absoluteBoundingBox() const;
    357377
    358378    void updateHoverActiveState(const HitTestRequest&, HitTestResult&);
    … …  
    368388
    369389    bool hasTransform() const { return renderer()->hasTransform(); }
     390    // Note that this transform has the transform-origin baked in.
    370391    TransformationMatrix* transform() const { return m_transform.get(); }
    371392
    … …  
    379400    void operator delete(void*, size_t);
    380401
     402#if USE(ACCELERATED_COMPOSITING)
     403    bool isComposited() const { return m_backing != 0; }
     404    RenderLayerBacking* backing() const { return m_backing; }
     405    RenderLayerBacking* ensureBacking();
     406    void clearBacking();
     407#else
     408    bool isComposited() const { return false; }
     409#endif
     410
     411    bool paintsWithTransparency() const
     412    {
     413        return isTransparent() && !isComposited();
     414    }
     415
     416    bool paintsWithTransform() const
     417    {
     418        return transform() && !isComposited();
     419    }
     420
    381421private:
    382422    // The normal operator new is disallowed on all render objects.
    … …  
    386426    void setNextSibling(RenderLayer* next) { m_next = next; }
    387427    void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
    388     void setParent(RenderLayer* parent) { m_parent = parent; }
     428    void setParent(RenderLayer* parent);
    389429    void setFirstChild(RenderLayer* first) { m_first = first; }
    390430    void setLastChild(RenderLayer* last) { m_last = last; }
    … …  
    392432    void collectLayers(Vector<RenderLayer*>*&, Vector<RenderLayer*>*&);
    393433
     434    void updateLayerListsIfNeeded();
     435   
    394436    void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect,
    395437                    bool haveTransparency, PaintRestriction, RenderObject* paintingRoot,
    396438                    bool appliedTransform = false, bool temporaryClipRects = false);
    397439    RenderLayer* hitTestLayer(RenderLayer* rootLayer, const HitTestRequest&, HitTestResult&, const IntRect& hitTestRect, const IntPoint& hitTestPoint, bool appliedTransform = false);
     440
    398441    void computeScrollDimensions(bool* needHBar = 0, bool* needVBar = 0);
    399442
    … …  
    425468    void updateResizerStyle();
    426469
    427 protected:   
     470#if USE(ACCELERATED_COMPOSITING)   
     471    bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
     472    void setHasCompositingDescendant(bool b)  { m_hasCompositingDescendant = b; }
     473#endif
     474
     475private:
     476    friend class RenderLayerBacking;
     477    friend class RenderLayerCompositor;
     478
     479protected:
    428480    RenderBox* m_renderer;
    429481
    … …  
    502554    bool m_hasVisibleDescendant : 1;
    503555
     556#if USE(ACCELERATED_COMPOSITING)
     557    bool m_hasCompositingDescendant : 1;
     558#endif
     559
    504560    RenderMarquee* m_marquee; // Used by layers with overflow:marquee
    505561   
    … …  
    516572    RenderScrollbarPart* m_scrollCorner;
    517573    RenderScrollbarPart* m_resizer;
     574
     575#if USE(ACCELERATED_COMPOSITING)
     576    OwnPtr<RenderLayerBacking> m_backing;
     577#endif
    518578};
    519579
Note: See TracChangeset for help on using the changeset viewer.