Attachment #189781 for bug #110505

View Details Raw Unified Return to Bug 110505

| Differences between



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

        Expose a list of all reasons that qualify a RenderLayer to be composited
        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::reasonsForCompositing):
        (WebCore):
        (WebCore::RenderLayerCompositor::logReasonsForCompositing):
        * rendering/RenderLayerCompositor.h:
        (RenderLayerCompositor):

2013-02-22  Allan Sandfeld Jensen  <allan.jensen@digia.com>

        Allow child-frame content in hit-tests.




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


    return false;
}

CompositingReasons RenderLayerCompositor::reasonsForCompositing(const RenderLayer* layer) const
const char* RenderLayerCompositor::reasonForCompositing(const RenderLayer* layer)
{
    CompositingReasons reasons = CompositingReasonNone;

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

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

    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return reasons;
}

#if !LOG_DISABLED
const char* RenderLayerCompositor::logReasonsForCompositing(const RenderLayer* layer)
{
    CompositingReasons reasons = reasonsForCompositing(layer);

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

    if (reasons & CompositingReasonVideo)
        return "video";

    if (reasons & CompositingReasonCanvas)
        return "canvas";

    if (reasons & CompositingReasonPlugin)
        return "plugin";

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

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

    if (reasons & CompositingReasonAnimation)
        return "animation";

    if (reasons & CompositingReasonFilters)
        return "filters";

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

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

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

    if (reasons & CompositingReasonStacking)
        return "stacking";

    if (reasons & CompositingReasonOverlap)
        return "overlap";

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

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

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

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

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

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

    if (reasons & CompositingReasonPerspective)
        return "perspective";

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

    if (reasons & CompositingReasonRoot)
        return "root";

    return "";



    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 CompositingReasons;

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

    void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }

    bool viewHasTransparentBackground(Color* backgroundColor = 0) const;

    CompositingReasons reasonsForCompositing(const RenderLayer*) const;
    
private:
    class OverlapMap;

#endif

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


Return to Bug 110505

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

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 CompositingReasons;
		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 setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }	266	void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }
238		267
239	bool viewHasTransparentBackground(Color* backgroundColor = 0) const;	268	bool viewHasTransparentBackground(Color* backgroundColor = 0) const;
		269
		270	CompositingReasons reasonsForCompositing(const RenderLayer*) const;
240		271
241	private:	272	private:
242	class OverlapMap;	273	class OverlapMap;
Lines 341-347 private: a/Source/WebCore/rendering/RenderLayerCompositor.h_sec3
341	#endif	372	#endif
342		373
343	#if !LOG_DISABLED	374	#if !LOG_DISABLED
344	const char* reasonForCompositing(const RenderLayer*);	375	const char* logReasonsForCompositing(const RenderLayer*);
345	void logLayerInfo(const RenderLayer*, int depth);	376	void logLayerInfo(const RenderLayer*, int depth);
346	#endif	377	#endif
347		378

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +26 lines
		1	2013-02-22 Antoine Quint <graouts@apple.com>
		2
		3	Expose a list of all reasons that qualify a RenderLayer to be composited
		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::reasonsForCompositing):
		22	(WebCore):
		23	(WebCore::RenderLayerCompositor::logReasonsForCompositing):
		24	* rendering/RenderLayerCompositor.h:
		25	(RenderLayerCompositor):
		26
1	2013-02-22 Allan Sandfeld Jensen <allan.jensen@digia.com>	27	2013-02-22 Allan Sandfeld Jensen <allan.jensen@digia.com>
2		28
3	Allow child-frame content in hit-tests.	29	Allow child-frame content in hit-tests.