void CCScrollbarLayerImpl::paint(GraphicsContext* context)
{
ScrollbarTheme* theme = ScrollbarTheme::theme(); // FIXME: should make impl-side clone if needed
context->clearRect(IntRect(IntPoint(), contentBounds()));
theme->paint(&m_scrollbar, context, IntRect(IntPoint(), contentBounds()));
}
IntRect CCLayerImpl::layerRectToContentRect(const WebKit::WebRect& layerRect)
{
float widthScale = static_cast<float>(contentBounds().width()) / bounds().width();
float heightScale = static_cast<float>(contentBounds().height()) / bounds().height();
FloatRect contentRect(layerRect.x, layerRect.y, layerRect.width, layerRect.height);
contentRect.scale(widthScale, heightScale);
return enclosingIntRect(contentRect);
}
void TiledLayerChromium::updateCompositorResources(GraphicsContext3D*, CCTextureUpdater& updater)
{
// Painting could cause compositing to get turned off, which may cause the tiler to become invalidated mid-update.
if (m_skipsDraw || m_requestedUpdateTilesRect.isEmpty() || m_tiler->isEmpty())
return;
int left = m_requestedUpdateTilesRect.x();
int top = m_requestedUpdateTilesRect.y();
int right = m_requestedUpdateTilesRect.maxX() - 1;
int bottom = m_requestedUpdateTilesRect.maxY() - 1;
for (int j = top; j <= bottom; ++j) {
for (int i = left; i <= right; ++i) {
UpdatableTile* tile = tileAt(i, j);
// Required tiles are created in prepareToUpdate(). A tile should
// never be removed between the call to prepareToUpdate() and the
// call to updateCompositorResources().
if (!tile)
CRASH();
IntRect sourceRect = tile->m_updateRect;
if (tile->m_updateRect.isEmpty())
continue;
ASSERT(tile->managedTexture()->isReserved());
const IntPoint anchor = m_tiler->tileRect(tile).location();
// Calculate tile-space rectangle to upload into.
IntRect destRect(IntPoint(sourceRect.x() - anchor.x(), sourceRect.y() - anchor.y()), sourceRect.size());
if (destRect.x() < 0)
CRASH();
if (destRect.y() < 0)
CRASH();
// Offset from paint rectangle to this tile's dirty rectangle.
IntPoint paintOffset(sourceRect.x() - m_paintRect.x(), sourceRect.y() - m_paintRect.y());
if (paintOffset.x() < 0)
CRASH();
if (paintOffset.y() < 0)
CRASH();
if (paintOffset.x() + destRect.width() > m_paintRect.width())
CRASH();
if (paintOffset.y() + destRect.height() > m_paintRect.height())
CRASH();
if (tile->m_partialUpdate)
updater.appendPartial(tile->texture(), sourceRect, destRect);
else
updater.append(tile->texture(), sourceRect, destRect);
}
}
// The updateRect should be in layer space. So we have to convert the paintRect from content space to layer space.
m_updateRect = FloatRect(m_paintRect);
float widthScale = bounds().width() / static_cast<float>(contentBounds().width());
float heightScale = bounds().height() / static_cast<float>(contentBounds().height());
m_updateRect.scale(widthScale, heightScale);
}
void CCTextureLayerImpl::appendQuads(CCQuadSink& quadList, const CCSharedQuadState* sharedQuadState, bool&)
{
if (!m_externalTextureResource)
return;
IntRect quadRect(IntPoint(), contentBounds());
quadList.append(CCTextureDrawQuad::create(sharedQuadState, quadRect, m_externalTextureResource, m_premultipliedAlpha, m_uvRect, m_flipped));
}
void CCLayerImpl::appendDebugBorderQuad(CCQuadCuller& quadList, const CCSharedQuadState* sharedQuadState) const
{
if (!hasDebugBorders())
return;
IntRect layerRect(IntPoint(), contentBounds());
quadList.append(CCDebugBorderDrawQuad::create(sharedQuadState, layerRect, debugBorderColor(), debugBorderWidth()));
}
TransformationMatrix TiledLayerChromium::tilingTransform() const
{
TransformationMatrix transform = drawTransform();
if (contentBounds().isEmpty())
return transform;
transform.scaleNonUniform(bounds().width() / static_cast<double>(contentBounds().width()),
bounds().height() / static_cast<double>(contentBounds().height()));
// Tiler draws with a different origin from other layers.
transform.translate(-contentBounds().width() / 2.0, -contentBounds().height() / 2.0);
transform.translate(-scrollPosition().x(), -scrollPosition().y());
return transform;
}
void CCLayerImpl::appendDebugBorderQuad(CCQuadSink& quadList, const CCSharedQuadState* sharedQuadState, CCAppendQuadsData& appendQuadsData) const
{
if (!hasDebugBorders())
return;
IntRect contentRect(IntPoint(), contentBounds());
quadList.append(CCDebugBorderDrawQuad::create(sharedQuadState, contentRect, debugBorderColor(), debugBorderWidth()).PassAs<CCDrawQuad>(), appendQuadsData);
}
void CCIOSurfaceLayerImpl::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData)
{
CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
IntRect quadRect(IntPoint(), contentBounds());
quadSink.append(CCIOSurfaceDrawQuad::create(sharedQuadState, quadRect, m_ioSurfaceSize, m_ioSurfaceTextureId, CCIOSurfaceDrawQuad::Flipped), appendQuadsData);
}
void CCTextureLayerImpl::appendQuads(CCQuadSink& quadSink, bool&)
{
if (!m_externalTextureResource)
return;
CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
appendDebugBorderQuad(quadSink, sharedQuadState);
IntRect quadRect(IntPoint(), contentBounds());
quadSink.append(CCTextureDrawQuad::create(sharedQuadState, quadRect, m_externalTextureResource, m_premultipliedAlpha, m_uvRect, m_flipped));
}
IntRect TiledLayerChromium::idlePaintRect(const IntRect& visibleLayerRect)
{
IntRect prepaintRect = visibleLayerRect;
// FIXME: This can be made a lot larger if we can:
// - reserve memory at a lower priority than for visible content
// - only reserve idle paint tiles up to a memory reclaim threshold and
// - insure we play nicely with other layers
prepaintRect.inflateX(m_tiler->tileSize().width());
prepaintRect.inflateY(m_tiler->tileSize().height());
prepaintRect.intersect(IntRect(IntPoint::zero(), contentBounds()));
return prepaintRect;
}
void TiledLayerChromium::updateTileSizeAndTilingOption()
{
if (!m_tiler)
return;
const IntSize tileSize(min(defaultTileSize, contentBounds().width()), min(defaultTileSize, contentBounds().height()));
// Tile if both dimensions large, or any one dimension large and the other
// extends into a second tile. This heuristic allows for long skinny layers
// (e.g. scrollbars) that are Nx1 tiles to minimize wasted texture space.
const bool anyDimensionLarge = contentBounds().width() > maxUntiledSize || contentBounds().height() > maxUntiledSize;
const bool anyDimensionOneTile = contentBounds().width() <= defaultTileSize || contentBounds().height() <= defaultTileSize;
const bool autoTiled = anyDimensionLarge && !anyDimensionOneTile;
bool isTiled;
if (m_tilingOption == AlwaysTile)
isTiled = true;
else if (m_tilingOption == NeverTile)
isTiled = false;
else
isTiled = autoTiled;
IntSize requestedSize = isTiled ? tileSize : contentBounds();
const int maxSize = layerTreeHost()->layerRendererCapabilities().maxTextureSize;
IntSize clampedSize = requestedSize.shrunkTo(IntSize(maxSize, maxSize));
m_tiler->setTileSize(clampedSize);
}
void CCScrollbarLayerImpl::willDraw(CCRenderer* layerRenderer, CCGraphicsContext* context)
{
CCLayerImpl::willDraw(layerRenderer, context);
if (bounds().isEmpty() || contentBounds().isEmpty())
return;
if (!m_texture)
m_texture = ManagedTexture::create(layerRenderer->implTextureManager());
// The context could have been lost since the last frame and the old texture
// manager may no longer be valid.
m_texture->setTextureManager(layerRenderer->implTextureManager());
IntSize textureSize = contentBounds();
if (!m_texture->reserve(textureSize, GraphicsContext3D::RGBA))
return;
PlatformCanvas canvas;
canvas.resize(textureSize);
{
PlatformCanvas::Painter painter(&canvas, PlatformCanvas::Painter::GrayscaleText);
paint(painter.context());
}
{
PlatformCanvas::AutoLocker locker(&canvas);
m_texture->bindTexture(context, layerRenderer->implTextureAllocator());
// FIXME: Skia uses BGRA actually, we correct that with the swizzle pixel shader.
GraphicsContext3D* context3d = context->context3D();
if (!context3d) {
// FIXME: Implement this path for software compositing.
return;
}
GLC(context3d, context3d->texImage2D(GraphicsContext3D::TEXTURE_2D, 0, m_texture->format(), canvas.size().width(), canvas.size().height(), 0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, locker.pixels()));
}
}
void TiledLayerChromium::updateBounds()
{
IntSize oldBounds = m_tiler->bounds();
IntSize newBounds = contentBounds();
if (oldBounds == newBounds)
return;
m_tiler->setBounds(newBounds);
// Invalidate any areas that the new bounds exposes.
Region oldRegion(IntRect(IntPoint(), oldBounds));
Region newRegion(IntRect(IntPoint(), newBounds));
newRegion.subtract(oldRegion);
Vector<IntRect> rects = newRegion.rects();
for (size_t i = 0; i < rects.size(); ++i)
invalidateRect(rects[i]);
}
void ContentLayerChromium::paintContentsIfDirty()
{
ASSERT(drawsContent());
updateTileSizeAndTilingOption();
const IntRect& layerRect = visibleLayerRect();
if (layerRect.isEmpty())
return;
IntRect dirty = enclosingIntRect(m_dirtyRect);
dirty.intersect(IntRect(IntPoint(), contentBounds()));
invalidateRect(dirty);
if (!drawsContent())
return;
prepareToUpdate(layerRect);
resetNeedsDisplay();
}
void CCScrollbarLayerImpl::appendQuads(CCQuadCuller& quadList, const CCSharedQuadState* sharedQuadState, bool&)
{
ScrollbarThemeComposite* theme = static_cast<ScrollbarThemeComposite*>(ScrollbarTheme::theme());
if (!theme)
return;
bool premultipledAlpha = false;
FloatRect uvRect(0, 0, 1, 1);
bool flipped = false;
IntRect thumbRect = theme->thumbRect(&m_scrollbar);
thumbRect.move(-m_scrollbar.x(), -m_scrollbar.y());
if (m_thumbTextureId && theme->hasThumb(&m_scrollbar) && !thumbRect.isEmpty()) {
OwnPtr<CCTextureDrawQuad> quad = CCTextureDrawQuad::create(sharedQuadState, thumbRect, m_thumbTextureId, premultipledAlpha, uvRect, flipped);
quad->setNeedsBlending();
quadList.append(quad.release());
}
if (!m_backgroundTextureId)
return;
IntRect backgroundRect(IntPoint(), contentBounds());
quadList.append(CCTextureDrawQuad::create(sharedQuadState, backgroundRect, m_backgroundTextureId, premultipledAlpha, uvRect, flipped));
}
void TiledLayerChromium::protectVisibleTileTextures()
{
protectTileTextures(IntRect(IntPoint::zero(), contentBounds()));
}
