bool LinkHighlight::computeHighlightLayerPathAndPosition(const LayoutBoxModelObject* paintInvalidationContainer)
{
if (!m_node || !m_node->layoutObject() || !m_currentGraphicsLayer)
return false;
ASSERT(paintInvalidationContainer);
// FIXME: This is defensive code to avoid crashes such as those described in
// crbug.com/440887. This should be cleaned up once we fix the root cause of
// of the paint invalidation container not being composited.
if (!paintInvalidationContainer->layer()->compositedDeprecatedPaintLayerMapping() && !paintInvalidationContainer->layer()->groupedMapping())
return false;
// Get quads for node in absolute coordinates.
Vector<FloatQuad> quads;
computeQuads(*m_node, quads);
ASSERT(quads.size());
Path newPath;
FloatPoint positionAdjustForCompositedScrolling = IntPoint(m_currentGraphicsLayer->offsetFromRenderer());
for (size_t quadIndex = 0; quadIndex < quads.size(); ++quadIndex) {
FloatQuad absoluteQuad = quads[quadIndex];
// FIXME: this hack should not be necessary. It's a consequence of the fact that composited layers for scrolling are represented
// differently in Blink than other composited layers.
if (paintInvalidationContainer->layer()->needsCompositedScrolling() && m_node->layoutObject() != paintInvalidationContainer)
absoluteQuad.move(-positionAdjustForCompositedScrolling.x(), -positionAdjustForCompositedScrolling.y());
// Transform node quads in target absolute coords to local coordinates in the compositor layer.
FloatQuad transformedQuad;
convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->layoutObject(), paintInvalidationContainer, transformedQuad);
// FIXME: for now, we'll only use rounded paths if we have a single node quad. The reason for this is that
// we may sometimes get a chain of adjacent boxes (e.g. for text nodes) which end up looking like sausage
// links: these should ideally be merged into a single rect before creating the path, but that's
// another CL.
if (quads.size() == 1 && transformedQuad.isRectilinear()
&& !m_owningWebViewImpl->settingsImpl()->mockGestureTapHighlightsEnabled()) {
FloatSize rectRoundingRadii(3, 3);
newPath.addRoundedRect(transformedQuad.boundingBox(), rectRoundingRadii);
} else
addQuadToPath(transformedQuad, newPath);
}
FloatRect boundingRect = newPath.boundingRect();
newPath.translate(-toFloatSize(boundingRect.location()));
bool pathHasChanged = !(newPath == m_path);
if (pathHasChanged) {
m_path = newPath;
m_contentLayer->layer()->setBounds(enclosingIntRect(boundingRect).size());
}
m_contentLayer->layer()->setPosition(boundingRect.location());
return pathHasChanged;
}
bool LinkHighlightImpl::computeHighlightLayerPathAndPosition(const LayoutBoxModelObject& paintInvalidationContainer)
{
if (!m_node || !m_node->layoutObject() || !m_currentGraphicsLayer)
return false;
// FIXME: This is defensive code to avoid crashes such as those described in
// crbug.com/440887. This should be cleaned up once we fix the root cause of
// of the paint invalidation container not being composited.
if (!paintInvalidationContainer.layer()->compositedLayerMapping() && !paintInvalidationContainer.layer()->groupedMapping())
return false;
// Get quads for node in absolute coordinates.
Vector<FloatQuad> quads;
computeQuads(*m_node, quads);
DCHECK(quads.size());
Path newPath;
for (size_t quadIndex = 0; quadIndex < quads.size(); ++quadIndex) {
FloatQuad absoluteQuad = quads[quadIndex];
// Scrolling content layers have the same offset from layout object as the non-scrolling layers. Thus we need
// to adjust for their scroll offset.
if (m_isScrollingGraphicsLayer) {
DoubleSize adjustedScrollOffset = paintInvalidationContainer.layer()->getScrollableArea()->adjustedScrollOffset();
absoluteQuad.move(adjustedScrollOffset.width(), adjustedScrollOffset.height());
}
// Transform node quads in target absolute coords to local coordinates in the compositor layer.
FloatQuad transformedQuad;
convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->layoutObject(), paintInvalidationContainer, transformedQuad);
// FIXME: for now, we'll only use rounded paths if we have a single node quad. The reason for this is that
// we may sometimes get a chain of adjacent boxes (e.g. for text nodes) which end up looking like sausage
// links: these should ideally be merged into a single rect before creating the path, but that's
// another CL.
if (quads.size() == 1 && transformedQuad.isRectilinear()
&& !m_owningWebViewImpl->settingsImpl()->mockGestureTapHighlightsEnabled()) {
FloatSize rectRoundingRadii(3, 3);
newPath.addRoundedRect(transformedQuad.boundingBox(), rectRoundingRadii);
} else {
addQuadToPath(transformedQuad, newPath);
}
}
FloatRect boundingRect = newPath.boundingRect();
newPath.translate(-toFloatSize(boundingRect.location()));
bool pathHasChanged = !(newPath == m_path);
if (pathHasChanged) {
m_path = newPath;
m_contentLayer->layer()->setBounds(enclosingIntRect(boundingRect).size());
}
m_contentLayer->layer()->setPosition(boundingRect.location());
return pathHasChanged;
}
bool LinkHighlight::computeHighlightLayerPathAndPosition(RenderLayer* compositingLayer)
{
if (!m_node || !m_node->renderer() || !m_currentGraphicsLayer)
return false;
ASSERT(compositingLayer);
// Get quads for node in absolute coordinates.
Vector<FloatQuad> quads;
computeQuads(m_node.get(), quads);
ASSERT(quads.size());
// Adjust for offset between target graphics layer and the node's renderer.
FloatPoint positionAdjust = IntPoint(m_currentGraphicsLayer->offsetFromRenderer());
Path newPath;
for (size_t quadIndex = 0; quadIndex < quads.size(); ++quadIndex) {
FloatQuad absoluteQuad = quads[quadIndex];
absoluteQuad.move(-positionAdjust.x(), -positionAdjust.y());
// Transform node quads in target absolute coords to local coordinates in the compositor layer.
FloatQuad transformedQuad;
convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->renderer(), compositingLayer->renderer(), transformedQuad);
// FIXME: for now, we'll only use rounded paths if we have a single node quad. The reason for this is that
// we may sometimes get a chain of adjacent boxes (e.g. for text nodes) which end up looking like sausage
// links: these should ideally be merged into a single rect before creating the path, but that's
// another CL.
if (quads.size() == 1 && transformedQuad.isRectilinear()) {
FloatSize rectRoundingRadii(3, 3);
newPath.addRoundedRect(transformedQuad.boundingBox(), rectRoundingRadii);
} else
addQuadToPath(transformedQuad, newPath);
}
FloatRect boundingRect = newPath.boundingRect();
newPath.translate(-toFloatSize(boundingRect.location()));
bool pathHasChanged = !(newPath == m_path);
if (pathHasChanged) {
m_path = newPath;
m_contentLayer->layer()->setBounds(enclosingIntRect(boundingRect).size());
}
m_contentLayer->layer()->setPosition(boundingRect.location());
return pathHasChanged;
}
bool LinkHighlight::computeHighlightLayerPathAndPosition(RenderLayer* compositingLayer)
{
if (!m_node || !m_node->renderer())
return false;
bool pathHasChanged = false;
FloatRect boundingRect = m_node->pixelSnappedBoundingBox();
// FIXME: If we ever use a more sophisticated highlight path, we'll need
// to devise a way of detecting when it changes.
if (boundingRect.size() != m_path.boundingRect().size()) {
FloatSize rectRoundingRadii(3, 3);
m_path.clear();
m_path.addRoundedRect(boundingRect, rectRoundingRadii);
// Always treat the path as being at the origin of this layer.
m_path.translate(FloatPoint() - boundingRect.location());
pathHasChanged = true;
}
FloatRect nodeBounds = boundingRect;
// This is a simplified, but basically correct, transformation of the target location, converted
// from its containing frame view to window coordinates and then back to the containing frame view
// of the composited layer.
// FIXME: We also need to transform the target's size in case of scaling. This can be done by also transforming
// the full rects in the xToY calls, and transforming both the upper-left and lower right corners
// to local coordinates at the end..
ASSERT(compositingLayer);
IntPoint targetWindow = m_node->renderer()->frame()->view()->contentsToWindow(enclosingIntRect(nodeBounds).location());
IntPoint targetCompositorAbsolute = compositingLayer->renderer()->frame()->view()->windowToContents(targetWindow);
FloatPoint targetCompositorLocal = compositingLayer->renderer()->absoluteToLocal(targetCompositorAbsolute, false, true);
m_contentLayer->layer()->setBounds(WebSize(enclosingIntRect(nodeBounds).size()));
m_contentLayer->layer()->setPosition(WebFloatPoint(targetCompositorLocal));
return pathHasChanged;
}
bool LinkHighlight::computeHighlightLayerPathAndPosition(RenderLayer* compositingLayer)
{
if (!m_node || !m_node->renderer())
return false;
ASSERT(compositingLayer);
// Get quads for node in absolute coordinates.
Vector<FloatQuad> quads;
m_node->renderer()->absoluteQuads(quads);
ASSERT(quads.size());
FloatRect positionAdjust;
if (!m_usingNonCompositedContentHost) {
const RenderStyle* style = m_node->renderer()->style();
// If we have a box shadow, and are non-relative, then must manually adjust
// for its size.
if (const ShadowData* shadow = style->boxShadow()) {
int outlineSize = m_node->renderer()->outlineStyleForRepaint()->outlineSize();
shadow->adjustRectForShadow(positionAdjust, outlineSize);
}
// If absolute or fixed, need to subtract out our fixed positioning.
// FIXME: should we use RenderLayer::staticBlockPosition() here instead?
// Perhaps consider this if out-of-flow elements cause further problems.
if (m_node->renderer()->isOutOfFlowPositioned()) {
FloatPoint delta(style->left().getFloatValue(), style->top().getFloatValue());
positionAdjust.moveBy(delta);
}
}
Path newPath;
for (unsigned quadIndex = 0; quadIndex < quads.size(); ++quadIndex) {
FloatQuad localQuad = m_node->renderer()->absoluteToLocalQuad(quads[quadIndex], UseTransforms);
localQuad.move(-positionAdjust.location().x(), -positionAdjust.location().y());
FloatQuad absoluteQuad = m_node->renderer()->localToAbsoluteQuad(localQuad, UseTransforms);
// Transform node quads in target absolute coords to local coordinates in the compositor layer.
FloatQuad transformedQuad;
convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->renderer(), compositingLayer->renderer(), transformedQuad);
// FIXME: for now, we'll only use rounded paths if we have a single node quad. The reason for this is that
// we may sometimes get a chain of adjacent boxes (e.g. for text nodes) which end up looking like sausage
// links: these should ideally be merged into a single rect before creating the path, but that's
// another CL.
if (quads.size() == 1 && transformedQuad.isRectilinear()) {
FloatSize rectRoundingRadii(3, 3);
newPath.addRoundedRect(transformedQuad.boundingBox(), rectRoundingRadii);
} else
addQuadToPath(transformedQuad, newPath);
}
FloatRect boundingRect = newPath.boundingRect();
newPath.translate(-toFloatSize(boundingRect.location()));
bool pathHasChanged = !(newPath == m_path);
if (pathHasChanged) {
m_path = newPath;
m_contentLayer->layer()->setBounds(enclosingIntRect(boundingRect).size());
}
m_contentLayer->layer()->setPosition(boundingRect.location());
return pathHasChanged;
}
