Attachment #189582 for bug #110505

View Details Raw Unified Return to Bug 110505

| Differences between



2013-02-21  Antoine Quint  <graouts@apple.com>

        Expose a list of all reasons that qualify a RenderLayer to be compositedd
        https://bugs.webkit.org/show_bug.cgi?id=110505

        Expose the various reasons that can qualify a RenderLayer to be composited
        via a new bitmask returned by the reasonForCompositing() method on
        RenderLayerCompositor. This method already existed and was used for logging
        purposes, but the previous functionality is now accessed via the
        logReasonForCompositing() method.
        
        This will allow the the InspectorLayerTreeAgent to provide this information
        to the front-end on a per-layer basis as requested by the front-end.

        Reviewed by NOBODY (OOPS!).

        No new tests.

        * rendering/RenderLayerCompositor.cpp:
        (WebCore::RenderLayerCompositor::logLayerInfo):
        (WebCore::RenderLayerCompositor::reasonForCompositing):
        (WebCore):
        (WebCore::RenderLayerCompositor::logReasonForCompositing):
        * rendering/RenderLayerCompositor.h:
        (RenderLayerCompositor):

2013-02-18  Sheriff Bot  <webkit.review.bot@gmail.com>

        Unreviewed, rolling out r143145.




    LOG(Compositing, "%*p %dx%d %.2fKB (%s) %s\n", 12 + depth * 2, layer, backing->compositedBounds().width(), backing->compositedBounds().height(),
        backing->backingStoreMemoryEstimate() / 1024,
        logReasonForCompositing(layer), layer->name().utf8().data());
}
#endif


    return false;
}

CompositingReason RenderLayerCompositor::reasonForCompositing(const RenderLayer* layer)
const char* RenderLayerCompositor::reasonForCompositing(const RenderLayer* layer)
{
    CompositingReason reason = CompositingReasonNone;

    if (!layer || !layer->isComposited())
        return reason;

    RenderObject* renderer = layer->renderer();
    if (layer->isReflection()) {
        renderer = renderer->parent();

    }

    if (requiresCompositingForTransform(renderer))
        reason |= CompositingReason3DTransform;

    if (requiresCompositingForVideo(renderer))
        reason |= CompositingReasonVideo;

    if (requiresCompositingForCanvas(renderer))
        reason |= CompositingReasonCanvas;

    if (requiresCompositingForPlugin(renderer))
        reason |= CompositingReasonPlugin;

    if (requiresCompositingForFrame(renderer))
        reason |= CompositingReasonIFrame;
    
    if ((canRender3DTransforms() && renderer->style()->backfaceVisibility() == BackfaceVisibilityHidden))
        reason |= CompositingReasonBackfaceVisibilityHidden;

    if (clipsCompositingDescendants(layer))
        reason |= CompositingReasonClipsCompositingDescendants;

    if (requiresCompositingForAnimation(renderer))
        reason |= CompositingReasonAnimation;

    if (requiresCompositingForFilters(renderer))
        reason |= CompositingReasonFilters;

    if (requiresCompositingForPosition(renderer, layer))
        reason |= renderer->style()->position() == FixedPosition ? CompositingReasonPositionFixed : CompositingReasonPositionSticky;

    if (requiresCompositingForOverflowScrolling(layer))
        reason |= CompositingReasonOverflowScrollingTouch;

    if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForStacking)
        reason |= CompositingReasonStacking;
    else if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForOverlap)
        reason |= CompositingReasonOverlap;
    else if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForBackgroundLayer)
        reason |= CompositingReasonNegativeZIndexChildren;
    else if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForGraphicalEffect) {
        return "negative z-index children";

    if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForGraphicalEffect) {
        if (layer->transform())
            reason |= CompositingReasonTransformWithCompositedDescendants;

        if (renderer->isTransparent())
            reason |= CompositingReasonOpacityWithCompositedDescendants;

        if (renderer->hasMask())
            reason |= CompositingReasonMaskWithCompositedDescendants;

        if (renderer->hasReflection())
            reason |= CompositingReasonReflectionWithCompositedDescendants;

        if (renderer->hasFilter())
            reason |= CompositingReasonFilterWithCompositedDescendants;
            
        if (renderer->hasBlendMode())
            reason |= CompositingReasonBlendingWithCompositedDescendants;
    } else if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForPerspective)
        reason |= CompositingReasonPerspective;
    else if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForPreserve3D)
        reason |= CompositingReasonPreserve3D;

    if (inCompositingMode() && layer->isRootLayer())
        reason |= CompositingReasonRoot;

    return reason;
}

#if !LOG_DISABLED
const char* RenderLayerCompositor::logReasonForCompositing(const RenderLayer* layer)
{
    CompositingReason reason = reasonForCompositing(layer);

    if (!reason)
        return "";

    if (reason & CompositingReason3DTransform)
        return "3D transform";

    if (reason & CompositingReasonVideo)
        return "video";

    if (reason & CompositingReasonCanvas)
        return "canvas";

    if (reason & CompositingReasonPlugin)
        return "plugin";

    if (reason & CompositingReasonIFrame)
        return "iframe";
    
    if (reason & CompositingReasonBackfaceVisibilityHidden)
        return "backface-visibility: hidden";

    if (reason & CompositingReasonClipsCompositingDescendants)
        return "clips compositing descendants";

    if (reason & CompositingReasonAnimation)
        return "animation";

    if (reason & CompositingReasonFilters)
        return "filters";

    if (reason & CompositingReasonPositionFixed)
        return "position: fixed";

    if (reason & CompositingReasonPositionSticky)
        return "position: sticky";

    if (reason & CompositingReasonOverflowScrollingTouch)
        return "-webkit-overflow-scrolling: touch";

    if (reason & CompositingReasonStacking)
        return "stacking";

    if (reason & CompositingReasonOverlap)
        return "overlap";

    if (reason & CompositingReasonNegativeZIndexChildren)
        return "negative z-index children";

    if (reason & CompositingReasonTransformWithCompositedDescendants)
        return "transform with composited descendants";

    if (reason & CompositingReasonOpacityWithCompositedDescendants)
        return "opacity with composited descendants";

    if (reason & CompositingReasonMaskWithCompositedDescendants)
        return "mask with composited descendants";

    if (reason & CompositingReasonReflectionWithCompositedDescendants)
        return "reflection with composited descendants";

    if (reason & CompositingReasonFilterWithCompositedDescendants)
        return "filter with composited descendants";
            
    if (reason & CompositingReasonBlendingWithCompositedDescendants)
        return "blending with composited descendants";

    if (reason & CompositingReasonPerspective)
        return "perspective";

    if (reason & CompositingReasonPreserve3D)
        return "preserve-3d";

    if (reason & CompositingReasonRoot)
        return "root";

    return "";
}
#endif




    CompositingUpdateOnCompositedScroll
};

enum {
    CompositingReasonNone                                   = 0,
    CompositingReason3DTransform                            = 1 << 0,
    CompositingReasonVideo                                  = 1 << 1,
    CompositingReasonCanvas                                 = 1 << 2,
    CompositingReasonPlugin                                 = 1 << 3,
    CompositingReasonIFrame                                 = 1 << 4,
    CompositingReasonBackfaceVisibilityHidden               = 1 << 5,
    CompositingReasonClipsCompositingDescendants            = 1 << 6,
    CompositingReasonAnimation                              = 1 << 7,
    CompositingReasonFilters                                = 1 << 8,
    CompositingReasonPositionFixed                          = 1 << 9,
    CompositingReasonPositionSticky                         = 1 << 10,
    CompositingReasonOverflowScrollingTouch                 = 1 << 11,
    CompositingReasonStacking                               = 1 << 12,
    CompositingReasonOverlap                                = 1 << 13,
    CompositingReasonNegativeZIndexChildren                 = 1 << 14,
    CompositingReasonTransformWithCompositedDescendants     = 1 << 15,
    CompositingReasonOpacityWithCompositedDescendants       = 1 << 16,
    CompositingReasonMaskWithCompositedDescendants          = 1 << 17,
    CompositingReasonReflectionWithCompositedDescendants    = 1 << 18,
    CompositingReasonFilterWithCompositedDescendants        = 1 << 19,
    CompositingReasonBlendingWithCompositedDescendants      = 1 << 20,
    CompositingReasonPerspective                            = 1 << 21,
    CompositingReasonPreserve3D                             = 1 << 22,
    CompositingReasonRoot                                   = 1 << 23
};
typedef unsigned CompositingReason;

// RenderLayerCompositor manages the hierarchy of
// composited RenderLayers. It determines which RenderLayers
// become compositing, and creates and maintains a hierarchy of

    void reportMemoryUsage(MemoryObjectInfo*) const;
    void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }

    CompositingReason reasonForCompositing(const RenderLayer*);

private:
    class OverlapMap;


#endif

#if !LOG_DISABLED
    const char* logReasonForCompositing(const RenderLayer*);
    void logLayerInfo(const RenderLayer*, int depth);
#endif


Return to Bug 110505

Lines 564-570 void RenderLayerCompositor::logLayerInfo(const RenderLayer* layer, int depth) a/Source/WebCore/rendering/RenderLayerCompositor.cpp_sec1
- a/Source/WebCore/rendering/RenderLayerCompositor.cpp -35 / +114 lines
564		564
565	LOG(Compositing, "%p %dx%d %.2fKB (%s) %s\n", 12 + depth 2, layer, backing->compositedBounds().width(), backing->compositedBounds().height(),	565	LOG(Compositing, "%p %dx%d %.2fKB (%s) %s\n", 12 + depth 2, layer, backing->compositedBounds().width(), backing->compositedBounds().height(),
566	backing->backingStoreMemoryEstimate() / 1024,	566	backing->backingStoreMemoryEstimate() / 1024,
567	reasonForCompositing(layer), layer->name().utf8().data());	567	logReasonForCompositing(layer), layer->name().utf8().data());
568	}	568	}
569	#endif	569	#endif
570		570
Lines 1700-1708 bool RenderLayerCompositor::requiresOwnBackingStore(const RenderLayer* layer, co a/Source/WebCore/rendering/RenderLayerCompositor.cpp_sec2
1700	return false;	1700	return false;
1701	}	1701	}
1702		1702
1703	#if !LOG_DISABLED	1703	CompositingReason RenderLayerCompositor::reasonForCompositing(const RenderLayer* layer)
1704	const char* RenderLayerCompositor::reasonForCompositing(const RenderLayer* layer)
1705	{	1704	{
		1705	CompositingReason reason = CompositingReasonNone;
		1706
		1707	if (!layer \|\| !layer->isComposited())
		1708	return reason;
		1709
1706	RenderObject* renderer = layer->renderer();	1710	RenderObject* renderer = layer->renderer();
1707	if (layer->isReflection()) {	1711	if (layer->isReflection()) {
1708	renderer = renderer->parent();	1712	renderer = renderer->parent();
Lines 1710-1786 const char* RenderLayerCompositor::reasonForCompositing(const RenderLayer* layer a/Source/WebCore/rendering/RenderLayerCompositor.cpp_sec3
1710	}	1714	}
1711		1715
1712	if (requiresCompositingForTransform(renderer))	1716	if (requiresCompositingForTransform(renderer))
1713	return "3D transform";	1717	reason \|= CompositingReason3DTransform;
1714		1718
1715	if (requiresCompositingForVideo(renderer))	1719	if (requiresCompositingForVideo(renderer))
1716	return "video";	1720	reason \|= CompositingReasonVideo;
1717		1721
1718	if (requiresCompositingForCanvas(renderer))	1722	if (requiresCompositingForCanvas(renderer))
1719	return "canvas";	1723	reason \|= CompositingReasonCanvas;
1720		1724
1721	if (requiresCompositingForPlugin(renderer))	1725	if (requiresCompositingForPlugin(renderer))
1722	return "plugin";	1726	reason \|= CompositingReasonPlugin;
1723		1727
1724	if (requiresCompositingForFrame(renderer))	1728	if (requiresCompositingForFrame(renderer))
1725	return "iframe";	1729	reason \|= CompositingReasonIFrame;
1726		1730
1727	if ((canRender3DTransforms() && renderer->style()->backfaceVisibility() == BackfaceVisibilityHidden))	1731	if ((canRender3DTransforms() && renderer->style()->backfaceVisibility() == BackfaceVisibilityHidden))
1728	return "backface-visibility: hidden";	1732	reason \|= CompositingReasonBackfaceVisibilityHidden;
1729		1733
1730	if (clipsCompositingDescendants(layer))	1734	if (clipsCompositingDescendants(layer))
1731	return "clips compositing descendants";	1735	reason \|= CompositingReasonClipsCompositingDescendants;
1732		1736
1733	if (requiresCompositingForAnimation(renderer))	1737	if (requiresCompositingForAnimation(renderer))
1734	return "animation";	1738	reason \|= CompositingReasonAnimation;
1735		1739
1736	if (requiresCompositingForFilters(renderer))	1740	if (requiresCompositingForFilters(renderer))
1737	return "filters";	1741	reason \|= CompositingReasonFilters;
1738		1742
1739	if (requiresCompositingForPosition(renderer, layer))	1743	if (requiresCompositingForPosition(renderer, layer))
1740	return renderer->style()->position() == FixedPosition ? "position: fixed" : "position: sticky";	1744	reason \|= renderer->style()->position() == FixedPosition ? CompositingReasonPositionFixed : CompositingReasonPositionSticky;
1741		1745
1742	if (requiresCompositingForOverflowScrolling(layer))	1746	if (requiresCompositingForOverflowScrolling(layer))
1743	return "-webkit-overflow-scrolling: touch";	1747	reason \|= CompositingReasonOverflowScrollingTouch;
1744		1748
1745	if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForStacking)	1749	if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForStacking)
1746	return "stacking";	1750	reason \|= CompositingReasonStacking;
1747		1751	else if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForOverlap)
1748	if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForOverlap)	1752	reason \|= CompositingReasonOverlap;
1749	return "overlap";	1753	else if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForBackgroundLayer)
1750		1754	reason \|= CompositingReasonNegativeZIndexChildren;
1751	if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForBackgroundLayer)	1755	else if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForGraphicalEffect) {
1752	return "negative z-index children";
1753
1754	if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForGraphicalEffect) {
1755	if (layer->transform())	1756	if (layer->transform())
1756	return "transform with composited descendants";	1757	reason \|= CompositingReasonTransformWithCompositedDescendants;
1757		1758
1758	if (renderer->isTransparent())	1759	if (renderer->isTransparent())
1759	return "opacity with composited descendants";	1760	reason \|= CompositingReasonOpacityWithCompositedDescendants;
1760		1761
1761	if (renderer->hasMask())	1762	if (renderer->hasMask())
1762	return "mask with composited descendants";	1763	reason \|= CompositingReasonMaskWithCompositedDescendants;
1763		1764
1764	if (renderer->hasReflection())	1765	if (renderer->hasReflection())
1765	return "reflection with composited descendants";	1766	reason \|= CompositingReasonReflectionWithCompositedDescendants;
1766		1767
1767	if (renderer->hasFilter())	1768	if (renderer->hasFilter())
1768	return "filter with composited descendants";	1769	reason \|= CompositingReasonFilterWithCompositedDescendants;
1769		1770
1770	if (renderer->hasBlendMode())	1771	if (renderer->hasBlendMode())
1771	return "blending with composited descendants";	1772	reason \|= CompositingReasonBlendingWithCompositedDescendants;
1772	}	1773	} else if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForPerspective)
		1774	reason \|= CompositingReasonPerspective;
		1775	else if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForPreserve3D)
		1776	reason \|= CompositingReasonPreserve3D;
		1777
		1778	if (inCompositingMode() && layer->isRootLayer())
		1779	reason \|= CompositingReasonRoot;
		1780
		1781	return reason;
		1782	}
		1783
		1784	#if !LOG_DISABLED
		1785	const char* RenderLayerCompositor::logReasonForCompositing(const RenderLayer* layer)
		1786	{
		1787	CompositingReason reason = reasonForCompositing(layer);
		1788
		1789	if (!reason)
		1790	return "";
		1791
		1792	if (reason & CompositingReason3DTransform)
		1793	return "3D transform";
		1794
		1795	if (reason & CompositingReasonVideo)
		1796	return "video";
1773		1797
1774	if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForPerspective)	1798	if (reason & CompositingReasonCanvas)
		1799	return "canvas";
		1800
		1801	if (reason & CompositingReasonPlugin)
		1802	return "plugin";
		1803
		1804	if (reason & CompositingReasonIFrame)
		1805	return "iframe";
		1806
		1807	if (reason & CompositingReasonBackfaceVisibilityHidden)
		1808	return "backface-visibility: hidden";
		1809
		1810	if (reason & CompositingReasonClipsCompositingDescendants)
		1811	return "clips compositing descendants";
		1812
		1813	if (reason & CompositingReasonAnimation)
		1814	return "animation";
		1815
		1816	if (reason & CompositingReasonFilters)
		1817	return "filters";
		1818
		1819	if (reason & CompositingReasonPositionFixed)
		1820	return "position: fixed";
		1821
		1822	if (reason & CompositingReasonPositionSticky)
		1823	return "position: sticky";
		1824
		1825	if (reason & CompositingReasonOverflowScrollingTouch)
		1826	return "-webkit-overflow-scrolling: touch";
		1827
		1828	if (reason & CompositingReasonStacking)
		1829	return "stacking";
		1830
		1831	if (reason & CompositingReasonOverlap)
		1832	return "overlap";
		1833
		1834	if (reason & CompositingReasonNegativeZIndexChildren)
		1835	return "negative z-index children";
		1836
		1837	if (reason & CompositingReasonTransformWithCompositedDescendants)
		1838	return "transform with composited descendants";
		1839
		1840	if (reason & CompositingReasonOpacityWithCompositedDescendants)
		1841	return "opacity with composited descendants";
		1842
		1843	if (reason & CompositingReasonMaskWithCompositedDescendants)
		1844	return "mask with composited descendants";
		1845
		1846	if (reason & CompositingReasonReflectionWithCompositedDescendants)
		1847	return "reflection with composited descendants";
		1848
		1849	if (reason & CompositingReasonFilterWithCompositedDescendants)
		1850	return "filter with composited descendants";
		1851
		1852	if (reason & CompositingReasonBlendingWithCompositedDescendants)
		1853	return "blending with composited descendants";
		1854
		1855	if (reason & CompositingReasonPerspective)
1775	return "perspective";	1856	return "perspective";
1776		1857
1777	if (layer->indirectCompositingReason() == RenderLayer::IndirectCompositingForPreserve3D)	1858	if (reason & CompositingReasonPreserve3D)
1778	return "preserve-3d";	1859	return "preserve-3d";
1779		1860
1780	if (inCompositingMode() && layer->isRootLayer())	1861	if (reason & CompositingReasonRoot)
1781	return "root";	1862	return "root";
1782
1783	return "";
1784	}	1863	}
1785	#endif	1864	#endif
1786		1865

Lines 55-60 enum CompositingUpdateType { a/Source/WebCore/rendering/RenderLayerCompositor.h_sec1
- a/Source/WebCore/rendering/RenderLayerCompositor.h -1 / +32 lines
55	CompositingUpdateOnCompositedScroll	55	CompositingUpdateOnCompositedScroll
56	};	56	};
57		57
		58	enum {
		59	CompositingReasonNone = 0,
		60	CompositingReason3DTransform = 1 << 0,
		61	CompositingReasonVideo = 1 << 1,
		62	CompositingReasonCanvas = 1 << 2,
		63	CompositingReasonPlugin = 1 << 3,
		64	CompositingReasonIFrame = 1 << 4,
		65	CompositingReasonBackfaceVisibilityHidden = 1 << 5,
		66	CompositingReasonClipsCompositingDescendants = 1 << 6,
		67	CompositingReasonAnimation = 1 << 7,
		68	CompositingReasonFilters = 1 << 8,
		69	CompositingReasonPositionFixed = 1 << 9,
		70	CompositingReasonPositionSticky = 1 << 10,
		71	CompositingReasonOverflowScrollingTouch = 1 << 11,
		72	CompositingReasonStacking = 1 << 12,
		73	CompositingReasonOverlap = 1 << 13,
		74	CompositingReasonNegativeZIndexChildren = 1 << 14,
		75	CompositingReasonTransformWithCompositedDescendants = 1 << 15,
		76	CompositingReasonOpacityWithCompositedDescendants = 1 << 16,
		77	CompositingReasonMaskWithCompositedDescendants = 1 << 17,
		78	CompositingReasonReflectionWithCompositedDescendants = 1 << 18,
		79	CompositingReasonFilterWithCompositedDescendants = 1 << 19,
		80	CompositingReasonBlendingWithCompositedDescendants = 1 << 20,
		81	CompositingReasonPerspective = 1 << 21,
		82	CompositingReasonPreserve3D = 1 << 22,
		83	CompositingReasonRoot = 1 << 23
		84	};
		85	typedef unsigned CompositingReason;
		86
58	// RenderLayerCompositor manages the hierarchy of	87	// RenderLayerCompositor manages the hierarchy of
59	// composited RenderLayers. It determines which RenderLayers	88	// composited RenderLayers. It determines which RenderLayers
60	// become compositing, and creates and maintains a hierarchy of	89	// become compositing, and creates and maintains a hierarchy of
Lines 237-242 public: a/Source/WebCore/rendering/RenderLayerCompositor.h_sec2
237	void reportMemoryUsage(MemoryObjectInfo*) const;	266	void reportMemoryUsage(MemoryObjectInfo*) const;
238	void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }	267	void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }
239		268
		269	CompositingReason reasonForCompositing(const RenderLayer*);
		270
240	private:	271	private:
241	class OverlapMap;	272	class OverlapMap;
242		273
Lines 339-345 private: a/Source/WebCore/rendering/RenderLayerCompositor.h_sec3
339	#endif	370	#endif
340		371
341	#if !LOG_DISABLED	372	#if !LOG_DISABLED
342	const char* reasonForCompositing(const RenderLayer*);	373	const char* logReasonForCompositing(const RenderLayer*);
343	void logLayerInfo(const RenderLayer*, int depth);	374	void logLayerInfo(const RenderLayer*, int depth);
344	#endif	375	#endif
345		376

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +26 lines
		1	2013-02-21 Antoine Quint <graouts@apple.com>
		2
		3	Expose a list of all reasons that qualify a RenderLayer to be compositedd
		4	https://bugs.webkit.org/show_bug.cgi?id=110505
		5
		6	Expose the various reasons that can qualify a RenderLayer to be composited
		7	via a new bitmask returned by the reasonForCompositing() method on
		8	RenderLayerCompositor. This method already existed and was used for logging
		9	purposes, but the previous functionality is now accessed via the
		10	logReasonForCompositing() method.
		11
		12	This will allow the the InspectorLayerTreeAgent to provide this information
		13	to the front-end on a per-layer basis as requested by the front-end.
		14
		15	Reviewed by NOBODY (OOPS!).
		16
		17	No new tests.
		18
		19	* rendering/RenderLayerCompositor.cpp:
		20	(WebCore::RenderLayerCompositor::logLayerInfo):
		21	(WebCore::RenderLayerCompositor::reasonForCompositing):
		22	(WebCore):
		23	(WebCore::RenderLayerCompositor::logReasonForCompositing):
		24	* rendering/RenderLayerCompositor.h:
		25	(RenderLayerCompositor):
		26
1	2013-02-18 Sheriff Bot <webkit.review.bot@gmail.com>	27	2013-02-18 Sheriff Bot <webkit.review.bot@gmail.com>
2		28
3	Unreviewed, rolling out r143145.	29	Unreviewed, rolling out r143145.