void GraphicsLayerChromium::updateChildList()
{
WebLayer* childHost = m_transformLayer ? m_transformLayer.get() : m_layer->layer();
childHost->removeAllChildren();
clearContentsLayerIfUnregistered();
if (m_transformLayer) {
// Add the primary layer first. Even if we have negative z-order children, the primary layer always comes behind.
childHost->addChild(m_layer->layer());
} else if (m_contentsLayer) {
// FIXME: add the contents layer in the correct order with negative z-order children.
// This does not cause visible rendering issues because currently contents layers are only used
// for replaced elements that don't have children.
childHost->addChild(m_contentsLayer);
}
const Vector<GraphicsLayer*>& childLayers = children();
size_t numChildren = childLayers.size();
for (size_t i = 0; i < numChildren; ++i) {
GraphicsLayerChromium* curChild = static_cast<GraphicsLayerChromium*>(childLayers[i]);
childHost->addChild(curChild->platformLayer());
}
if (m_linkHighlight)
childHost->addChild(m_linkHighlight->layer());
if (m_transformLayer && m_contentsLayer) {
// If we have a transform layer, then the contents layer is parented in the
// primary layer (which is itself a child of the transform layer).
m_layer->layer()->removeAllChildren();
m_layer->layer()->addChild(m_contentsLayer);
}
}
void GraphicsLayerChromium::setReplicatedByLayer(GraphicsLayer* layer)
{
GraphicsLayerChromium* layerChromium = static_cast<GraphicsLayerChromium*>(layer);
GraphicsLayer::setReplicatedByLayer(layer);
LayerChromium* replicaLayer = layerChromium ? layerChromium->primaryLayer() : 0;
primaryLayer()->setReplicaLayer(replicaLayer);
}
TEST_F(ScrollingCoordinatorChromiumTest, touchOverflowScrolling)
{
registerMockedHttpURLLoad("touch-overflow-scrolling.html");
navigateTo(m_baseURL + "touch-overflow-scrolling.html");
// Verify the properties of the accelerated scrolling element starting from the RenderObject
// all the way to the WebLayer.
Element* scrollableElement = m_webViewImpl->mainFrameImpl()->frame()->document()->getElementById("scrollable");
ASSERT(scrollableElement);
RenderObject* renderer = scrollableElement->renderer();
ASSERT_TRUE(renderer->isBoxModelObject());
ASSERT_TRUE(renderer->hasLayer());
RenderLayer* layer = toRenderBoxModelObject(renderer)->layer();
ASSERT_TRUE(layer->usesCompositedScrolling());
ASSERT_TRUE(layer->isComposited());
RenderLayerBacking* layerBacking = layer->backing();
ASSERT_TRUE(layerBacking->hasScrollingLayer());
ASSERT(layerBacking->scrollingContentsLayer());
GraphicsLayerChromium* graphicsLayerChromium = static_cast<GraphicsLayerChromium*>(layerBacking->scrollingContentsLayer());
ASSERT_EQ(layer, graphicsLayerChromium->scrollableArea());
WebLayer* webScrollLayer = static_cast<WebLayer*>(layerBacking->scrollingContentsLayer()->platformLayer());
ASSERT_TRUE(webScrollLayer->scrollable());
}
void GraphicsLayerChromium::setReplicatedByLayer(GraphicsLayer* layer)
{
GraphicsLayerChromium* layerChromium = static_cast<GraphicsLayerChromium*>(layer);
GraphicsLayer::setReplicatedByLayer(layer);
WebLayer* webReplicaLayer = layerChromium ? layerChromium->platformLayer() : 0;
platformLayer()->setReplicaLayer(webReplicaLayer);
}
void GraphicsLayerChromium::setReplicatedByLayer(GraphicsLayer* layer)
{
GraphicsLayerChromium* layerChromium = static_cast<GraphicsLayerChromium*>(layer);
GraphicsLayer::setReplicatedByLayer(layer);
WebLayer webReplicaLayer;
if (layerChromium)
webReplicaLayer = layerChromium->primaryLayer();
primaryLayer().setReplicaLayer(webReplicaLayer);
}
void ScrollingCoordinatorChromium::scrollableAreaScrollLayerDidChange(ScrollableArea* scrollableArea, GraphicsLayer* scrollLayer)
{
if (!scrollLayer)
return;
GraphicsLayerChromium* layer = static_cast<GraphicsLayerChromium*>(scrollLayer);
layer->setScrollableArea(scrollableArea);
if (WebLayer* webLayer = scrollLayer->platformLayer()) {
webLayer->setScrollable(true);
webLayer->setScrollPosition(scrollableArea->scrollPosition());
webLayer->setMaxScrollPosition(IntSize(scrollableArea->scrollSize(HorizontalScrollbar), scrollableArea->scrollSize(VerticalScrollbar)));
}
}
void ScrollingCoordinatorChromium::scrollableAreaScrollLayerDidChange(ScrollableArea* scrollableArea)
{
GraphicsLayerChromium* scrollLayer = static_cast<GraphicsLayerChromium*>(scrollLayerForScrollableArea(scrollableArea));
if (scrollLayer)
scrollLayer->setScrollableArea(scrollableArea);
WebLayer* webLayer = scrollingWebLayerForScrollableArea(scrollableArea);
if (webLayer) {
webLayer->setScrollable(true);
webLayer->setScrollPosition(IntPoint(scrollableArea->scrollPosition() - scrollableArea->minimumScrollPosition()));
webLayer->setMaxScrollPosition(IntSize(scrollableArea->scrollSize(HorizontalScrollbar), scrollableArea->scrollSize(VerticalScrollbar)));
}
if (WebScrollbarLayer* scrollbarLayer = getWebScrollbarLayer(scrollableArea, HorizontalScrollbar))
setupScrollbarLayer(horizontalScrollbarLayerForScrollableArea(scrollableArea), scrollbarLayer, webLayer);
if (WebScrollbarLayer* scrollbarLayer = getWebScrollbarLayer(scrollableArea, VerticalScrollbar))
setupScrollbarLayer(verticalScrollbarLayerForScrollableArea(scrollableArea), scrollbarLayer, webLayer);
}
void GraphicsLayerChromium::updateChildList()
{
Vector<WebLayer> newChildren;
if (!m_transformLayer.isNull()) {
// Add the primary layer first. Even if we have negative z-order children, the primary layer always comes behind.
newChildren.append(m_layer);
} else if (!m_contentsLayer.isNull()) {
// FIXME: add the contents layer in the correct order with negative z-order children.
// This does not cause visible rendering issues because currently contents layers are only used
// for replaced elements that don't have children.
newChildren.append(m_contentsLayer);
}
const Vector<GraphicsLayer*>& childLayers = children();
size_t numChildren = childLayers.size();
for (size_t i = 0; i < numChildren; ++i) {
GraphicsLayerChromium* curChild = static_cast<GraphicsLayerChromium*>(childLayers[i]);
newChildren.append(curChild->layerForParent());
}
if (m_linkHighlight)
newChildren.append(m_linkHighlight->contentLayer());
for (size_t i = 0; i < newChildren.size(); ++i)
newChildren[i].removeFromParent();
WebVector<WebLayer> newWebChildren;
newWebChildren.assign(newChildren.data(), newChildren.size());
if (!m_transformLayer.isNull()) {
m_transformLayer.setChildren(newWebChildren);
if (!m_contentsLayer.isNull()) {
// If we have a transform layer, then the contents layer is parented in the
// primary layer (which is itself a child of the transform layer).
m_layer.removeAllChildren();
m_layer.addChild(m_contentsLayer);
}
} else
m_layer.setChildren(newWebChildren);
}
RenderLayer* LinkHighlight::computeEnclosingCompositingLayer()
{
if (!m_node || !m_node->renderer())
return 0;
RenderLayer* renderLayer = m_node->renderer()->enclosingLayer();
// Find the nearest enclosing composited layer and attach to it. We may need to cross frame boundaries
// to find a suitable layer.
while (renderLayer && !renderLayer->isComposited()) {
if (!renderLayer->parent()) {
// See if we've reached the root in an enclosed frame.
if (renderLayer->renderer()->frame()->ownerRenderer())
renderLayer = renderLayer->renderer()->frame()->ownerRenderer()->enclosingLayer();
else
renderLayer = 0;
} else
renderLayer = renderLayer->parent();
}
if (!renderLayer || !renderLayer->isComposited())
return 0;
GraphicsLayerChromium* newGraphicsLayer = static_cast<GraphicsLayerChromium*>(renderLayer->backing()->graphicsLayer());
m_clipLayer->setSublayerTransform(SkMatrix44());
if (!newGraphicsLayer->drawsContent()) {
m_clipLayer->setSublayerTransform(newGraphicsLayer->platformLayer()->transform());
newGraphicsLayer = static_cast<GraphicsLayerChromium*>(m_owningWebViewImpl->nonCompositedContentHost()->topLevelRootLayer());
}
if (m_currentGraphicsLayer != newGraphicsLayer) {
if (m_currentGraphicsLayer)
clearGraphicsLayerLinkHighlightPointer();
m_currentGraphicsLayer = newGraphicsLayer;
m_currentGraphicsLayer->setLinkHighlight(this);
}
return renderLayer;
}
RenderLayer* LinkHighlight::computeEnclosingCompositingLayer()
{
if (!m_node || !m_node->renderer())
return 0;
// Find the nearest enclosing composited layer and attach to it. We may need to cross frame boundaries
// to find a suitable layer.
RenderLayerModelObject* renderer = toRenderLayerModelObject(m_node->renderer());
RenderLayerModelObject* repaintContainer;
do {
repaintContainer = renderer->containerForRepaint();
if (!repaintContainer) {
renderer = renderer->frame()->ownerRenderer();
if (!renderer)
return 0;
}
} while (!repaintContainer);
RenderLayer* renderLayer = repaintContainer->layer();
if (!renderLayer || !renderLayer->isComposited())
return 0;
GraphicsLayerChromium* newGraphicsLayer = static_cast<GraphicsLayerChromium*>(renderLayer->backing()->graphicsLayer());
m_clipLayer->setSublayerTransform(SkMatrix44());
m_usingNonCompositedContentHost = !newGraphicsLayer->drawsContent();
if (m_usingNonCompositedContentHost ) {
m_clipLayer->setSublayerTransform(newGraphicsLayer->platformLayer()->transform());
newGraphicsLayer = static_cast<GraphicsLayerChromium*>(m_owningWebViewImpl->nonCompositedContentHost()->topLevelRootLayer());
}
if (m_currentGraphicsLayer != newGraphicsLayer) {
if (m_currentGraphicsLayer)
clearGraphicsLayerLinkHighlightPointer();
m_currentGraphicsLayer = newGraphicsLayer;
m_currentGraphicsLayer->setLinkHighlight(this);
}
return renderLayer;
}
void GraphicsLayerChromium::updateSublayerList()
{
Vector<RefPtr<LayerChromium> > newSublayers;
if (m_transformLayer) {
// Add the primary layer first. Even if we have negative z-order children, the primary layer always comes behind.
newSublayers.append(m_layer.get());
} else if (m_contentsLayer) {
// FIXME: add the contents layer in the correct order with negative z-order children.
// This does not cause visible rendering issues because currently contents layers are only used
// for replaced elements that don't have children.
newSublayers.append(m_contentsLayer.get());
}
const Vector<GraphicsLayer*>& childLayers = children();
size_t numChildren = childLayers.size();
for (size_t i = 0; i < numChildren; ++i) {
GraphicsLayerChromium* curChild = static_cast<GraphicsLayerChromium*>(childLayers[i]);
LayerChromium* childLayer = curChild->layerForSuperlayer();
newSublayers.append(childLayer);
}
for (size_t i = 0; i < newSublayers.size(); ++i)
newSublayers[i]->removeFromSuperlayer();
if (m_transformLayer) {
m_transformLayer->setSublayers(newSublayers);
if (m_contentsLayer) {
// If we have a transform layer, then the contents layer is parented in the
// primary layer (which is itself a child of the transform layer).
m_layer->removeAllSublayers();
m_layer->addSublayer(m_contentsLayer);
}
} else
m_layer->setSublayers(newSublayers);
}
