This source file includes following definitions.
- repaintRectMap
- create
- m_3dRenderingContext
- setParent
- hasAncestor
- setChildren
- addChildInternal
- addChild
- addChildAtIndex
- addChildBelow
- addChildAbove
- replaceChild
- removeAllChildren
- removeFromParent
- setReplicatedByLayer
- setOffsetFromRenderer
- paintGraphicsLayerContents
- setZPosition
- updateChildList
- updateLayerIsDrawable
- updateContentsRect
- registerContentsLayer
- unregisterContentsLayer
- setContentsTo
- setupContentsLayer
- clearContentsLayerIfUnregistered
- debugInfo
- takeDebugInfoFor
- contentsLayerIfRegistered
- resetTrackedRepaints
- addRepaintRect
- collectTrackedRepaintRects
- dumpLayer
- dumpProperties
- layerTreeAsText
- debugName
- setCompositingReasons
- setPosition
- setAnchorPoint
- setSize
- setTransform
- setShouldFlattenTransform
- setRenderingContext
- setMasksToBounds
- setDrawsContent
- setContentsVisible
- setClipParent
- setScrollParent
- setBackgroundColor
- setContentsOpaque
- setMaskLayer
- setContentsClippingMaskLayer
- setBackfaceVisibility
- setOpacity
- setBlendMode
- setIsRootForIsolatedGroup
- setHasGpuRasterizationHint
- setContentsNeedsDisplay
- setNeedsDisplay
- setNeedsDisplayInRect
- setContentsRect
- setContentsToImage
- setContentsToNinePatch
- addAnimation
- pauseAnimation
- removeAnimation
- platformLayer
- copyWebCoreFilterOperationsToWebFilterOperations
- setFilters
- setBackgroundFilters
- addLinkHighlight
- removeLinkHighlight
- setScrollableArea
- paint
- notifyAnimationStarted
- notifyAnimationFinished
- didScroll
- showGraphicsLayerTree
#include "config.h"
#include "platform/graphics/GraphicsLayer.h"
#include "SkImageFilter.h"
#include "SkMatrix44.h"
#include "platform/geometry/FloatRect.h"
#include "platform/geometry/LayoutRect.h"
#include "platform/graphics/GraphicsLayerFactory.h"
#include "platform/graphics/filters/SkiaImageFilterBuilder.h"
#include "platform/graphics/skia/NativeImageSkia.h"
#include "platform/scroll/ScrollableArea.h"
#include "platform/text/TextStream.h"
#include "public/platform/Platform.h"
#include "public/platform/WebAnimation.h"
#include "public/platform/WebCompositorSupport.h"
#include "public/platform/WebFilterOperations.h"
#include "public/platform/WebFloatPoint.h"
#include "public/platform/WebFloatRect.h"
#include "public/platform/WebGraphicsLayerDebugInfo.h"
#include "public/platform/WebLayer.h"
#include "public/platform/WebPoint.h"
#include "public/platform/WebSize.h"
#include "wtf/CurrentTime.h"
#include "wtf/HashMap.h"
#include "wtf/HashSet.h"
#include "wtf/text/WTFString.h"
#ifndef NDEBUG
#include <stdio.h>
#endif
using blink::Platform;
using blink::WebAnimation;
using blink::WebFilterOperations;
using blink::WebLayer;
using blink::WebPoint;
namespace WebCore {
typedef HashMap<const GraphicsLayer*, Vector<FloatRect> > RepaintMap;
static RepaintMap& repaintRectMap()
{
DEFINE_STATIC_LOCAL(RepaintMap, map, ());
return map;
}
PassOwnPtr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient* client)
{
return factory->createGraphicsLayer(client);
}
GraphicsLayer::GraphicsLayer(GraphicsLayerClient* client)
: m_client(client)
, m_anchorPoint(0.5f, 0.5f, 0)
, m_backgroundColor(Color::transparent)
, m_opacity(1)
, m_zPosition(0)
, m_blendMode(blink::WebBlendModeNormal)
, m_contentsOpaque(false)
, m_shouldFlattenTransform(true)
, m_backfaceVisibility(true)
, m_masksToBounds(false)
, m_drawsContent(false)
, m_contentsVisible(true)
, m_isRootForIsolatedGroup(false)
, m_hasGpuRasterizationHint(false)
, m_hasScrollParent(false)
, m_hasClipParent(false)
, m_paintingPhase(GraphicsLayerPaintAllWithOverflowClip)
, m_contentsOrientation(CompositingCoordinatesTopDown)
, m_parent(0)
, m_maskLayer(0)
, m_contentsClippingMaskLayer(0)
, m_replicaLayer(0)
, m_replicatedLayer(0)
, m_paintCount(0)
, m_contentsLayer(0)
, m_contentsLayerId(0)
, m_scrollableArea(0)
, m_3dRenderingContext(0)
{
#ifndef NDEBUG
if (m_client)
m_client->verifyNotPainting();
#endif
m_opaqueRectTrackingContentLayerDelegate = adoptPtr(new OpaqueRectTrackingContentLayerDelegate(this));
m_layer = adoptPtr(Platform::current()->compositorSupport()->createContentLayer(m_opaqueRectTrackingContentLayerDelegate.get()));
m_layer->layer()->setDrawsContent(m_drawsContent && m_contentsVisible);
m_layer->layer()->setWebLayerClient(this);
m_layer->setAutomaticallyComputeRasterScale(true);
}
GraphicsLayer::~GraphicsLayer()
{
for (size_t i = 0; i < m_linkHighlights.size(); ++i)
m_linkHighlights[i]->clearCurrentGraphicsLayer();
m_linkHighlights.clear();
#ifndef NDEBUG
if (m_client)
m_client->verifyNotPainting();
#endif
if (m_replicaLayer)
m_replicaLayer->setReplicatedLayer(0);
if (m_replicatedLayer)
m_replicatedLayer->setReplicatedByLayer(0);
removeAllChildren();
removeFromParent();
resetTrackedRepaints();
ASSERT(!m_parent);
}
void GraphicsLayer::setParent(GraphicsLayer* layer)
{
ASSERT(!layer || !layer->hasAncestor(this));
m_parent = layer;
}
bool GraphicsLayer::hasAncestor(GraphicsLayer* ancestor) const
{
for (GraphicsLayer* curr = parent(); curr; curr = curr->parent()) {
if (curr == ancestor)
return true;
}
return false;
}
bool GraphicsLayer::setChildren(const GraphicsLayerVector& newChildren)
{
if (newChildren == m_children)
return false;
removeAllChildren();
size_t listSize = newChildren.size();
for (size_t i = 0; i < listSize; ++i)
addChildInternal(newChildren[i]);
updateChildList();
return true;
}
void GraphicsLayer::addChildInternal(GraphicsLayer* childLayer)
{
ASSERT(childLayer != this);
if (childLayer->parent())
childLayer->removeFromParent();
childLayer->setParent(this);
m_children.append(childLayer);
}
void GraphicsLayer::addChild(GraphicsLayer* childLayer)
{
addChildInternal(childLayer);
updateChildList();
}
void GraphicsLayer::addChildAtIndex(GraphicsLayer* childLayer, int index)
{
ASSERT(childLayer != this);
if (childLayer->parent())
childLayer->removeFromParent();
childLayer->setParent(this);
m_children.insert(index, childLayer);
updateChildList();
}
void GraphicsLayer::addChildBelow(GraphicsLayer* childLayer, GraphicsLayer* sibling)
{
ASSERT(childLayer != this);
childLayer->removeFromParent();
bool found = false;
for (unsigned i = 0; i < m_children.size(); i++) {
if (sibling == m_children[i]) {
m_children.insert(i, childLayer);
found = true;
break;
}
}
childLayer->setParent(this);
if (!found)
m_children.append(childLayer);
updateChildList();
}
void GraphicsLayer::addChildAbove(GraphicsLayer* childLayer, GraphicsLayer* sibling)
{
childLayer->removeFromParent();
ASSERT(childLayer != this);
bool found = false;
for (unsigned i = 0; i < m_children.size(); i++) {
if (sibling == m_children[i]) {
m_children.insert(i+1, childLayer);
found = true;
break;
}
}
childLayer->setParent(this);
if (!found)
m_children.append(childLayer);
updateChildList();
}
bool GraphicsLayer::replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild)
{
ASSERT(!newChild->parent());
bool found = false;
for (unsigned i = 0; i < m_children.size(); i++) {
if (oldChild == m_children[i]) {
m_children[i] = newChild;
found = true;
break;
}
}
if (found) {
oldChild->setParent(0);
newChild->removeFromParent();
newChild->setParent(this);
updateChildList();
return true;
}
return false;
}
void GraphicsLayer::removeAllChildren()
{
while (!m_children.isEmpty()) {
GraphicsLayer* curLayer = m_children.last();
ASSERT(curLayer->parent());
curLayer->removeFromParent();
}
}
void GraphicsLayer::removeFromParent()
{
if (m_parent) {
m_parent->m_children.remove(m_parent->m_children.reverseFind(this));
setParent(0);
}
platformLayer()->removeFromParent();
}
void GraphicsLayer::setReplicatedByLayer(GraphicsLayer* layer)
{
if (m_replicaLayer != layer) {
if (m_replicaLayer)
m_replicaLayer->setReplicatedLayer(0);
if (layer)
layer->setReplicatedLayer(this);
m_replicaLayer = layer;
}
WebLayer* webReplicaLayer = layer ? layer->platformLayer() : 0;
platformLayer()->setReplicaLayer(webReplicaLayer);
}
void GraphicsLayer::setOffsetFromRenderer(const IntSize& offset, ShouldSetNeedsDisplay shouldSetNeedsDisplay)
{
if (offset == m_offsetFromRenderer)
return;
m_offsetFromRenderer = offset;
if (shouldSetNeedsDisplay == SetNeedsDisplay)
setNeedsDisplay();
}
void GraphicsLayer::paintGraphicsLayerContents(GraphicsContext& context, const IntRect& clip)
{
if (!m_client)
return;
incrementPaintCount();
m_client->paintContents(this, context, m_paintingPhase, clip);
}
void GraphicsLayer::setZPosition(float position)
{
m_zPosition = position;
}
void GraphicsLayer::updateChildList()
{
WebLayer* childHost = m_layer->layer();
childHost->removeAllChildren();
clearContentsLayerIfUnregistered();
if (m_contentsLayer) {
childHost->addChild(m_contentsLayer);
}
for (size_t i = 0; i < m_children.size(); ++i)
childHost->addChild(m_children[i]->platformLayer());
for (size_t i = 0; i < m_linkHighlights.size(); ++i)
childHost->addChild(m_linkHighlights[i]->layer());
}
void GraphicsLayer::updateLayerIsDrawable()
{
m_layer->layer()->setDrawsContent(m_drawsContent && m_contentsVisible);
if (WebLayer* contentsLayer = contentsLayerIfRegistered())
contentsLayer->setDrawsContent(m_contentsVisible);
if (m_drawsContent) {
m_layer->layer()->invalidate();
for (size_t i = 0; i < m_linkHighlights.size(); ++i)
m_linkHighlights[i]->invalidate();
}
}
void GraphicsLayer::updateContentsRect()
{
WebLayer* contentsLayer = contentsLayerIfRegistered();
if (!contentsLayer)
return;
contentsLayer->setPosition(FloatPoint(m_contentsRect.x(), m_contentsRect.y()));
contentsLayer->setBounds(IntSize(m_contentsRect.width(), m_contentsRect.height()));
if (m_contentsClippingMaskLayer) {
if (m_contentsClippingMaskLayer->size() != m_contentsRect.size()) {
m_contentsClippingMaskLayer->setSize(m_contentsRect.size());
m_contentsClippingMaskLayer->setNeedsDisplay();
}
m_contentsClippingMaskLayer->setPosition(FloatPoint());
m_contentsClippingMaskLayer->setOffsetFromRenderer(offsetFromRenderer() + IntSize(m_contentsRect.location().x(), m_contentsRect.location().y()));
}
}
static HashSet<int>* s_registeredLayerSet;
void GraphicsLayer::registerContentsLayer(WebLayer* layer)
{
if (!s_registeredLayerSet)
s_registeredLayerSet = new HashSet<int>;
if (s_registeredLayerSet->contains(layer->id()))
CRASH();
s_registeredLayerSet->add(layer->id());
}
void GraphicsLayer::unregisterContentsLayer(WebLayer* layer)
{
ASSERT(s_registeredLayerSet);
if (!s_registeredLayerSet->contains(layer->id()))
CRASH();
s_registeredLayerSet->remove(layer->id());
}
void GraphicsLayer::setContentsTo(WebLayer* layer)
{
bool childrenChanged = false;
if (layer) {
ASSERT(s_registeredLayerSet);
if (!s_registeredLayerSet->contains(layer->id()))
CRASH();
if (m_contentsLayerId != layer->id()) {
setupContentsLayer(layer);
childrenChanged = true;
}
updateContentsRect();
} else {
if (m_contentsLayer) {
childrenChanged = true;
m_contentsLayer = 0;
m_contentsLayerId = 0;
}
}
if (childrenChanged)
updateChildList();
}
void GraphicsLayer::setupContentsLayer(WebLayer* contentsLayer)
{
ASSERT(contentsLayer);
m_contentsLayer = contentsLayer;
m_contentsLayerId = m_contentsLayer->id();
m_contentsLayer->setWebLayerClient(this);
m_contentsLayer->setAnchorPoint(FloatPoint(0, 0));
m_contentsLayer->setUseParentBackfaceVisibility(true);
m_contentsLayer->setDrawsContent(m_contentsVisible);
m_layer->layer()->insertChild(m_contentsLayer, 0);
WebLayer* borderWebLayer = m_contentsClippingMaskLayer ? m_contentsClippingMaskLayer->platformLayer() : 0;
m_contentsLayer->setMaskLayer(borderWebLayer);
m_contentsLayer->setRenderingContext(m_3dRenderingContext);
}
void GraphicsLayer::clearContentsLayerIfUnregistered()
{
if (!m_contentsLayerId || s_registeredLayerSet->contains(m_contentsLayerId))
return;
m_contentsLayer = 0;
m_contentsLayerId = 0;
}
GraphicsLayerDebugInfo& GraphicsLayer::debugInfo()
{
return m_debugInfo;
}
blink::WebGraphicsLayerDebugInfo* GraphicsLayer::takeDebugInfoFor(WebLayer* layer)
{
GraphicsLayerDebugInfo* clone = m_debugInfo.clone();
clone->setDebugName(debugName(layer));
return clone;
}
WebLayer* GraphicsLayer::contentsLayerIfRegistered()
{
clearContentsLayerIfUnregistered();
return m_contentsLayer;
}
void GraphicsLayer::resetTrackedRepaints()
{
repaintRectMap().remove(this);
}
void GraphicsLayer::addRepaintRect(const FloatRect& repaintRect)
{
if (m_client->isTrackingRepaints()) {
FloatRect largestRepaintRect(FloatPoint(), m_size);
largestRepaintRect.intersect(repaintRect);
RepaintMap::iterator repaintIt = repaintRectMap().find(this);
if (repaintIt == repaintRectMap().end()) {
Vector<FloatRect> repaintRects;
repaintRects.append(largestRepaintRect);
repaintRectMap().set(this, repaintRects);
} else {
Vector<FloatRect>& repaintRects = repaintIt->value;
repaintRects.append(largestRepaintRect);
}
}
}
void GraphicsLayer::collectTrackedRepaintRects(Vector<FloatRect>& rects) const
{
if (!m_client->isTrackingRepaints())
return;
RepaintMap::iterator repaintIt = repaintRectMap().find(this);
if (repaintIt != repaintRectMap().end())
rects.appendVector(repaintIt->value);
}
void GraphicsLayer::dumpLayer(TextStream& ts, int indent, LayerTreeFlags flags, RenderingContextMap& renderingContextMap) const
{
writeIndent(ts, indent);
ts << "(" << "GraphicsLayer";
if (flags & LayerTreeIncludesDebugInfo) {
ts << " " << static_cast<void*>(const_cast<GraphicsLayer*>(this));
ts << " \"" << m_client->debugName(this) << "\"";
}
ts << "\n";
dumpProperties(ts, indent, flags, renderingContextMap);
writeIndent(ts, indent);
ts << ")\n";
}
void GraphicsLayer::dumpProperties(TextStream& ts, int indent, LayerTreeFlags flags, RenderingContextMap& renderingContextMap) const
{
if (m_position != FloatPoint()) {
writeIndent(ts, indent + 1);
ts << "(position " << m_position.x() << " " << m_position.y() << ")\n";
}
if (m_boundsOrigin != FloatPoint()) {
writeIndent(ts, indent + 1);
ts << "(bounds origin " << m_boundsOrigin.x() << " " << m_boundsOrigin.y() << ")\n";
}
if (m_anchorPoint != FloatPoint3D(0.5f, 0.5f, 0)) {
writeIndent(ts, indent + 1);
ts << "(anchor " << m_anchorPoint.x() << " " << m_anchorPoint.y() << ")\n";
}
if (m_size != IntSize()) {
writeIndent(ts, indent + 1);
ts << "(bounds " << m_size.width() << " " << m_size.height() << ")\n";
}
if (m_opacity != 1) {
writeIndent(ts, indent + 1);
ts << "(opacity " << m_opacity << ")\n";
}
if (m_blendMode != blink::WebBlendModeNormal) {
writeIndent(ts, indent + 1);
ts << "(blendMode " << compositeOperatorName(CompositeSourceOver, m_blendMode) << ")\n";
}
if (m_isRootForIsolatedGroup) {
writeIndent(ts, indent + 1);
ts << "(isolate " << m_isRootForIsolatedGroup << ")\n";
}
if (m_contentsOpaque) {
writeIndent(ts, indent + 1);
ts << "(contentsOpaque " << m_contentsOpaque << ")\n";
}
if (!m_shouldFlattenTransform) {
writeIndent(ts, indent + 1);
ts << "(shouldFlattenTransform " << m_shouldFlattenTransform << ")\n";
}
if (m_3dRenderingContext) {
RenderingContextMap::const_iterator it = renderingContextMap.find(m_3dRenderingContext);
int contextId = renderingContextMap.size() + 1;
if (it == renderingContextMap.end())
renderingContextMap.set(m_3dRenderingContext, contextId);
else
contextId = it->value;
writeIndent(ts, indent + 1);
ts << "(3dRenderingContext " << contextId << ")\n";
}
if (m_drawsContent) {
writeIndent(ts, indent + 1);
ts << "(drawsContent " << m_drawsContent << ")\n";
}
if (!m_contentsVisible) {
writeIndent(ts, indent + 1);
ts << "(contentsVisible " << m_contentsVisible << ")\n";
}
if (m_hasGpuRasterizationHint) {
writeIndent(ts, indent + 1);
ts << "(hasGpuRasterizationHint " << m_hasGpuRasterizationHint << ")\n";
}
if (!m_backfaceVisibility) {
writeIndent(ts, indent + 1);
ts << "(backfaceVisibility " << (m_backfaceVisibility ? "visible" : "hidden") << ")\n";
}
if (flags & LayerTreeIncludesDebugInfo) {
writeIndent(ts, indent + 1);
ts << "(";
if (m_client)
ts << "client " << static_cast<void*>(m_client);
else
ts << "no client";
ts << ")\n";
}
if (m_backgroundColor.alpha()) {
writeIndent(ts, indent + 1);
ts << "(backgroundColor " << m_backgroundColor.nameForRenderTreeAsText() << ")\n";
}
if (!m_transform.isIdentity()) {
writeIndent(ts, indent + 1);
ts << "(transform ";
ts << "[" << m_transform.m11() << " " << m_transform.m12() << " " << m_transform.m13() << " " << m_transform.m14() << "] ";
ts << "[" << m_transform.m21() << " " << m_transform.m22() << " " << m_transform.m23() << " " << m_transform.m24() << "] ";
ts << "[" << m_transform.m31() << " " << m_transform.m32() << " " << m_transform.m33() << " " << m_transform.m34() << "] ";
ts << "[" << m_transform.m41() << " " << m_transform.m42() << " " << m_transform.m43() << " " << m_transform.m44() << "])\n";
}
if (m_replicaLayer) {
writeIndent(ts, indent + 1);
ts << "(replica layer";
if (flags & LayerTreeIncludesDebugInfo)
ts << " " << m_replicaLayer;
ts << ")\n";
m_replicaLayer->dumpLayer(ts, indent + 2, flags, renderingContextMap);
}
if (m_replicatedLayer) {
writeIndent(ts, indent + 1);
ts << "(replicated layer";
if (flags & LayerTreeIncludesDebugInfo)
ts << " " << m_replicatedLayer;
ts << ")\n";
}
if ((flags & LayerTreeIncludesRepaintRects) && repaintRectMap().contains(this) && !repaintRectMap().get(this).isEmpty()) {
writeIndent(ts, indent + 1);
ts << "(repaint rects\n";
for (size_t i = 0; i < repaintRectMap().get(this).size(); ++i) {
if (repaintRectMap().get(this)[i].isEmpty())
continue;
writeIndent(ts, indent + 2);
ts << "(rect ";
ts << repaintRectMap().get(this)[i].x() << " ";
ts << repaintRectMap().get(this)[i].y() << " ";
ts << repaintRectMap().get(this)[i].width() << " ";
ts << repaintRectMap().get(this)[i].height();
ts << ")\n";
}
writeIndent(ts, indent + 1);
ts << ")\n";
}
if ((flags & LayerTreeIncludesPaintingPhases) && paintingPhase()) {
writeIndent(ts, indent + 1);
ts << "(paintingPhases\n";
if (paintingPhase() & GraphicsLayerPaintBackground) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintBackground\n";
}
if (paintingPhase() & GraphicsLayerPaintForeground) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintForeground\n";
}
if (paintingPhase() & GraphicsLayerPaintMask) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintMask\n";
}
if (paintingPhase() & GraphicsLayerPaintChildClippingMask) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintChildClippingMask\n";
}
if (paintingPhase() & GraphicsLayerPaintOverflowContents) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintOverflowContents\n";
}
if (paintingPhase() & GraphicsLayerPaintCompositedScroll) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintCompositedScroll\n";
}
writeIndent(ts, indent + 1);
ts << ")\n";
}
if (flags & LayerTreeIncludesClipAndScrollParents) {
if (m_hasScrollParent) {
writeIndent(ts, indent + 1);
ts << "(hasScrollParent 1)\n";
}
if (m_hasClipParent) {
writeIndent(ts, indent + 1);
ts << "(hasClipParent 1)\n";
}
}
if (flags & LayerTreeIncludesDebugInfo) {
writeIndent(ts, indent + 1);
ts << "(compositingReasons\n";
for (size_t i = 0; i < WTF_ARRAY_LENGTH(compositingReasonStringMap); ++i) {
if (m_debugInfo.compositingReasons() & compositingReasonStringMap[i].reason) {
writeIndent(ts, indent + 2);
ts << compositingReasonStringMap[i].description << "\n";
}
}
writeIndent(ts, indent + 1);
ts << ")\n";
}
if (m_children.size()) {
writeIndent(ts, indent + 1);
ts << "(children " << m_children.size() << "\n";
unsigned i;
for (i = 0; i < m_children.size(); i++)
m_children[i]->dumpLayer(ts, indent + 2, flags, renderingContextMap);
writeIndent(ts, indent + 1);
ts << ")\n";
}
}
String GraphicsLayer::layerTreeAsText(LayerTreeFlags flags) const
{
TextStream ts;
RenderingContextMap renderingContextMap;
dumpLayer(ts, 0, flags, renderingContextMap);
return ts.release();
}
String GraphicsLayer::debugName(blink::WebLayer* webLayer) const
{
String name;
if (!m_client)
return name;
String highlightDebugName;
for (size_t i = 0; i < m_linkHighlights.size(); ++i) {
if (webLayer == m_linkHighlights[i]->layer()) {
highlightDebugName = "LinkHighlight[" + String::number(i) + "] for " + m_client->debugName(this);
break;
}
}
if (webLayer == m_contentsLayer) {
name = "ContentsLayer for " + m_client->debugName(this);
} else if (!highlightDebugName.isEmpty()) {
name = highlightDebugName;
} else if (webLayer == m_layer->layer()) {
name = m_client->debugName(this);
} else {
ASSERT_NOT_REACHED();
}
return name;
}
void GraphicsLayer::setCompositingReasons(CompositingReasons reasons)
{
m_debugInfo.setCompositingReasons(reasons);
}
void GraphicsLayer::setPosition(const FloatPoint& point)
{
m_position = point;
platformLayer()->setPosition(m_position);
}
void GraphicsLayer::setAnchorPoint(const FloatPoint3D& point)
{
m_anchorPoint = point;
platformLayer()->setAnchorPoint(FloatPoint(m_anchorPoint.x(), m_anchorPoint.y()));
platformLayer()->setAnchorPointZ(m_anchorPoint.z());
}
void GraphicsLayer::setSize(const FloatSize& size)
{
FloatSize clampedSize = size;
if (clampedSize.width() < 0 || clampedSize.height() < 0)
clampedSize = FloatSize();
if (clampedSize == m_size)
return;
m_size = clampedSize;
m_layer->layer()->setBounds(flooredIntSize(m_size));
}
void GraphicsLayer::setTransform(const TransformationMatrix& transform)
{
m_transform = transform;
platformLayer()->setTransform(TransformationMatrix::toSkMatrix44(m_transform));
}
void GraphicsLayer::setShouldFlattenTransform(bool shouldFlatten)
{
if (shouldFlatten == m_shouldFlattenTransform)
return;
m_shouldFlattenTransform = shouldFlatten;
m_layer->layer()->setShouldFlattenTransform(shouldFlatten);
}
void GraphicsLayer::setRenderingContext(int context)
{
if (m_3dRenderingContext == context)
return;
m_3dRenderingContext = context;
m_layer->layer()->setRenderingContext(context);
if (m_contentsLayer)
m_contentsLayer->setRenderingContext(m_3dRenderingContext);
}
void GraphicsLayer::setMasksToBounds(bool masksToBounds)
{
m_masksToBounds = masksToBounds;
m_layer->layer()->setMasksToBounds(m_masksToBounds);
}
void GraphicsLayer::setDrawsContent(bool drawsContent)
{
if (drawsContent == m_drawsContent)
return;
m_drawsContent = drawsContent;
updateLayerIsDrawable();
}
void GraphicsLayer::setContentsVisible(bool contentsVisible)
{
if (contentsVisible == m_contentsVisible)
return;
m_contentsVisible = contentsVisible;
updateLayerIsDrawable();
}
void GraphicsLayer::setClipParent(blink::WebLayer* parent)
{
m_hasClipParent = !!parent;
m_layer->layer()->setClipParent(parent);
}
void GraphicsLayer::setScrollParent(blink::WebLayer* parent)
{
m_hasScrollParent = !!parent;
m_layer->layer()->setScrollParent(parent);
}
void GraphicsLayer::setBackgroundColor(const Color& color)
{
if (color == m_backgroundColor)
return;
m_backgroundColor = color;
m_layer->layer()->setBackgroundColor(m_backgroundColor.rgb());
}
void GraphicsLayer::setContentsOpaque(bool opaque)
{
m_contentsOpaque = opaque;
m_layer->layer()->setOpaque(m_contentsOpaque);
m_opaqueRectTrackingContentLayerDelegate->setOpaque(m_contentsOpaque);
}
void GraphicsLayer::setMaskLayer(GraphicsLayer* maskLayer)
{
if (maskLayer == m_maskLayer)
return;
m_maskLayer = maskLayer;
WebLayer* maskWebLayer = m_maskLayer ? m_maskLayer->platformLayer() : 0;
m_layer->layer()->setMaskLayer(maskWebLayer);
}
void GraphicsLayer::setContentsClippingMaskLayer(GraphicsLayer* contentsClippingMaskLayer)
{
if (contentsClippingMaskLayer == m_contentsClippingMaskLayer)
return;
m_contentsClippingMaskLayer = contentsClippingMaskLayer;
WebLayer* contentsLayer = contentsLayerIfRegistered();
if (!contentsLayer)
return;
WebLayer* contentsClippingMaskWebLayer = m_contentsClippingMaskLayer ? m_contentsClippingMaskLayer->platformLayer() : 0;
contentsLayer->setMaskLayer(contentsClippingMaskWebLayer);
updateContentsRect();
}
void GraphicsLayer::setBackfaceVisibility(bool visible)
{
m_backfaceVisibility = visible;
m_layer->setDoubleSided(m_backfaceVisibility);
}
void GraphicsLayer::setOpacity(float opacity)
{
float clampedOpacity = std::max(std::min(opacity, 1.0f), 0.0f);
m_opacity = clampedOpacity;
platformLayer()->setOpacity(opacity);
}
void GraphicsLayer::setBlendMode(blink::WebBlendMode blendMode)
{
if (m_blendMode == blendMode)
return;
m_blendMode = blendMode;
platformLayer()->setBlendMode(blink::WebBlendMode(blendMode));
}
void GraphicsLayer::setIsRootForIsolatedGroup(bool isolated)
{
if (m_isRootForIsolatedGroup == isolated)
return;
m_isRootForIsolatedGroup = isolated;
platformLayer()->setIsRootForIsolatedGroup(isolated);
}
void GraphicsLayer::setHasGpuRasterizationHint(bool hasHint)
{
m_hasGpuRasterizationHint = hasHint;
m_layer->setHasGpuRasterizationHint(hasHint);
}
void GraphicsLayer::setContentsNeedsDisplay()
{
if (WebLayer* contentsLayer = contentsLayerIfRegistered()) {
contentsLayer->invalidate();
addRepaintRect(contentsRect());
}
}
void GraphicsLayer::setNeedsDisplay()
{
if (drawsContent()) {
m_layer->layer()->invalidate();
addRepaintRect(FloatRect(FloatPoint(), m_size));
for (size_t i = 0; i < m_linkHighlights.size(); ++i)
m_linkHighlights[i]->invalidate();
}
}
void GraphicsLayer::setNeedsDisplayInRect(const FloatRect& rect)
{
if (drawsContent()) {
m_layer->layer()->invalidateRect(rect);
addRepaintRect(rect);
for (size_t i = 0; i < m_linkHighlights.size(); ++i)
m_linkHighlights[i]->invalidate();
}
}
void GraphicsLayer::setContentsRect(const IntRect& rect)
{
if (rect == m_contentsRect)
return;
m_contentsRect = rect;
updateContentsRect();
}
void GraphicsLayer::setContentsToImage(Image* image)
{
RefPtr<NativeImageSkia> nativeImage = image ? image->nativeImageForCurrentFrame() : nullptr;
if (nativeImage) {
if (!m_imageLayer) {
m_imageLayer = adoptPtr(Platform::current()->compositorSupport()->createImageLayer());
registerContentsLayer(m_imageLayer->layer());
}
m_imageLayer->setBitmap(nativeImage->bitmap());
m_imageLayer->layer()->setOpaque(image->currentFrameKnownToBeOpaque());
updateContentsRect();
} else {
if (m_imageLayer) {
unregisterContentsLayer(m_imageLayer->layer());
m_imageLayer.clear();
}
}
setContentsTo(m_imageLayer ? m_imageLayer->layer() : 0);
}
void GraphicsLayer::setContentsToNinePatch(Image* image, const IntRect& aperture)
{
if (m_ninePatchLayer) {
unregisterContentsLayer(m_ninePatchLayer->layer());
m_ninePatchLayer.clear();
}
RefPtr<NativeImageSkia> nativeImage = image ? image->nativeImageForCurrentFrame() : nullptr;
if (nativeImage) {
m_ninePatchLayer = adoptPtr(Platform::current()->compositorSupport()->createNinePatchLayer());
m_ninePatchLayer->setBitmap(nativeImage->bitmap(), aperture);
m_ninePatchLayer->layer()->setOpaque(image->currentFrameKnownToBeOpaque());
registerContentsLayer(m_ninePatchLayer->layer());
}
setContentsTo(m_ninePatchLayer ? m_ninePatchLayer->layer() : 0);
}
bool GraphicsLayer::addAnimation(PassOwnPtr<WebAnimation> popAnimation)
{
OwnPtr<WebAnimation> animation(popAnimation);
ASSERT(animation);
platformLayer()->setAnimationDelegate(this);
platformLayer()->removeAnimation(animation->id(), animation->targetProperty());
return platformLayer()->addAnimation(animation.leakPtr());
}
void GraphicsLayer::pauseAnimation(int animationId, double timeOffset)
{
platformLayer()->pauseAnimation(animationId, timeOffset);
}
void GraphicsLayer::removeAnimation(int animationId)
{
platformLayer()->removeAnimation(animationId);
}
WebLayer* GraphicsLayer::platformLayer() const
{
return m_layer->layer();
}
static bool copyWebCoreFilterOperationsToWebFilterOperations(const FilterOperations& filters, WebFilterOperations& webFilters)
{
for (size_t i = 0; i < filters.size(); ++i) {
const FilterOperation& op = *filters.at(i);
switch (op.type()) {
case FilterOperation::REFERENCE:
return false;
case FilterOperation::GRAYSCALE:
case FilterOperation::SEPIA:
case FilterOperation::SATURATE:
case FilterOperation::HUE_ROTATE: {
float amount = toBasicColorMatrixFilterOperation(op).amount();
switch (op.type()) {
case FilterOperation::GRAYSCALE:
webFilters.appendGrayscaleFilter(amount);
break;
case FilterOperation::SEPIA:
webFilters.appendSepiaFilter(amount);
break;
case FilterOperation::SATURATE:
webFilters.appendSaturateFilter(amount);
break;
case FilterOperation::HUE_ROTATE:
webFilters.appendHueRotateFilter(amount);
break;
default:
ASSERT_NOT_REACHED();
}
break;
}
case FilterOperation::INVERT:
case FilterOperation::OPACITY:
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST: {
float amount = toBasicComponentTransferFilterOperation(op).amount();
switch (op.type()) {
case FilterOperation::INVERT:
webFilters.appendInvertFilter(amount);
break;
case FilterOperation::OPACITY:
webFilters.appendOpacityFilter(amount);
break;
case FilterOperation::BRIGHTNESS:
webFilters.appendBrightnessFilter(amount);
break;
case FilterOperation::CONTRAST:
webFilters.appendContrastFilter(amount);
break;
default:
ASSERT_NOT_REACHED();
}
break;
}
case FilterOperation::BLUR: {
float pixelRadius = toBlurFilterOperation(op).stdDeviation().getFloatValue();
webFilters.appendBlurFilter(pixelRadius);
break;
}
case FilterOperation::DROP_SHADOW: {
const DropShadowFilterOperation& dropShadowOp = toDropShadowFilterOperation(op);
webFilters.appendDropShadowFilter(WebPoint(dropShadowOp.x(), dropShadowOp.y()), dropShadowOp.stdDeviation(), dropShadowOp.color().rgb());
break;
}
case FilterOperation::CUSTOM:
case FilterOperation::VALIDATED_CUSTOM:
return false;
case FilterOperation::NONE:
break;
}
}
return true;
}
bool GraphicsLayer::setFilters(const FilterOperations& filters)
{
SkiaImageFilterBuilder builder;
OwnPtr<WebFilterOperations> webFilters = adoptPtr(Platform::current()->compositorSupport()->createFilterOperations());
FilterOutsets outsets = filters.outsets();
builder.setCropOffset(FloatSize(outsets.left(), outsets.top()));
if (!builder.buildFilterOperations(filters, webFilters.get())) {
webFilters->clear();
m_layer->layer()->setFilters(*webFilters);
m_filters = FilterOperations();
return false;
}
m_layer->layer()->setFilters(*webFilters);
m_filters = filters;
return true;
}
void GraphicsLayer::setBackgroundFilters(const FilterOperations& filters)
{
OwnPtr<WebFilterOperations> webFilters = adoptPtr(Platform::current()->compositorSupport()->createFilterOperations());
if (!copyWebCoreFilterOperationsToWebFilterOperations(filters, *webFilters))
return;
m_layer->layer()->setBackgroundFilters(*webFilters);
}
void GraphicsLayer::addLinkHighlight(LinkHighlightClient* linkHighlight)
{
ASSERT(linkHighlight && !m_linkHighlights.contains(linkHighlight));
m_linkHighlights.append(linkHighlight);
linkHighlight->layer()->setWebLayerClient(this);
updateChildList();
}
void GraphicsLayer::removeLinkHighlight(LinkHighlightClient* linkHighlight)
{
m_linkHighlights.remove(m_linkHighlights.find(linkHighlight));
updateChildList();
}
void GraphicsLayer::setScrollableArea(ScrollableArea* scrollableArea, bool isMainFrame)
{
if (m_scrollableArea == scrollableArea)
return;
m_scrollableArea = scrollableArea;
if (isMainFrame)
m_layer->layer()->setScrollClient(0);
else
m_layer->layer()->setScrollClient(this);
}
void GraphicsLayer::paint(GraphicsContext& context, const IntRect& clip)
{
paintGraphicsLayerContents(context, clip);
}
void GraphicsLayer::notifyAnimationStarted(double monotonicTime, WebAnimation::TargetProperty)
{
if (m_client)
m_client->notifyAnimationStarted(this, monotonicTime);
}
void GraphicsLayer::notifyAnimationFinished(double, WebAnimation::TargetProperty)
{
}
void GraphicsLayer::didScroll()
{
if (m_scrollableArea)
m_scrollableArea->scrollToOffsetWithoutAnimation(m_scrollableArea->minimumScrollPosition() + toIntSize(m_layer->layer()->scrollPosition()));
}
}
#ifndef NDEBUG
void showGraphicsLayerTree(const WebCore::GraphicsLayer* layer)
{
if (!layer)
return;
String output = layer->layerTreeAsText(WebCore::LayerTreeIncludesDebugInfo);
fprintf(stderr, "%s\n", output.utf8().data());
}
#endif