void TiledLayerChromium::prepareToUpdate(const IntRect& contentRect)
{
ASSERT(m_tiler);
m_skipsDraw = false;
if (contentRect.isEmpty()) {
m_updateRect = IntRect();
return;
}
// Invalidate old tiles that were previously used but aren't in use this
// frame so that they can get reused for new tiles.
invalidateTiles(contentRect);
m_tiler->growLayerToContain(contentRect);
if (!m_tiler->numTiles()) {
m_updateRect = IntRect();
return;
}
// Create tiles as needed, expanding a dirty rect to contain all
// the dirty regions currently being drawn.
IntRect dirtyLayerRect;
int left, top, right, bottom;
m_tiler->contentRectToTileIndices(contentRect, left, top, right, bottom);
for (int j = top; j <= bottom; ++j) {
for (int i = left; i <= right; ++i) {
UpdatableTile* tile = tileAt(i, j);
if (!tile)
tile = createTile(i, j);
if (!tile->texture()->isValid(m_tiler->tileSize(), m_textureFormat))
tile->m_dirtyLayerRect = m_tiler->tileLayerRect(tile);
if (!tile->texture()->reserve(m_tiler->tileSize(), m_textureFormat)) {
m_skipsDraw = true;
cleanupResources();
return;
}
dirtyLayerRect.unite(tile->m_dirtyLayerRect);
}
}
// Due to borders, when the paint rect is extended to tile boundaries, it
// may end up overlapping more tiles than the original content rect. Record
// that original rect so we don't upload more tiles than necessary.
m_updateRect = contentRect;
m_paintRect = m_tiler->layerRectToContentRect(dirtyLayerRect);
if (dirtyLayerRect.isEmpty())
return;
textureUpdater()->prepareToUpdate(m_paintRect, m_tiler->tileSize(), m_tiler->hasBorderTexels());
}
CCVideoLayerImpl::~CCVideoLayerImpl()
{
MutexLocker locker(m_providerMutex);
if (m_provider) {
m_provider->setVideoFrameProviderClient(0);
m_provider = 0;
}
for (unsigned i = 0; i < MaxPlanes; ++i)
m_textures[i].m_texture.clear();
cleanupResources();
}
void TiledLayerChromium::setLayerTreeHost(CCLayerTreeHost* host)
{
if (host == layerTreeHost())
return;
if (layerTreeHost())
cleanupResources();
LayerChromium::setLayerTreeHost(host);
if (!host)
return;
createTextureUpdater(host);
setTextureFormat(host->layerRendererCapabilities().bestTextureFormat);
m_sampledTexelFormat = textureUpdater()->sampledTexelFormat(m_textureFormat);
}
ContentLayerChromium::~ContentLayerChromium()
{
cleanupResources();
}
RenderSurfaceChromium::~RenderSurfaceChromium()
{
cleanupResources();
}
VideoLayerChromium::~VideoLayerChromium()
{
cleanupResources();
}
DisplayListData::~DisplayListData() {
cleanupResources();
}
CCVideoLayerImpl::~CCVideoLayerImpl()
{
cleanupResources();
}
void TiledLayerChromium::prepareToUpdateTiles(bool idle, int left, int top, int right, int bottom)
{
// Reset m_updateRect for all tiles.
for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
tile->m_updateRect = IntRect();
}
// Create tiles as needed, expanding a dirty rect to contain all
// the dirty regions currently being drawn. All dirty tiles that are to be painted
// get their m_updateRect set to m_dirtyRect and m_dirtyRect cleared. This way if
// invalidateRect is invoked during prepareToUpdate we don't lose the request.
IntRect dirtyLayerRect;
for (int j = top; j <= bottom; ++j) {
for (int i = left; i <= right; ++i) {
UpdatableTile* tile = tileAt(i, j);
if (!tile)
tile = createTile(i, j);
// Do post commit deletion of current texture when partial texture
// updates are not used.
if (tile->isDirty() && layerTreeHost() && !layerTreeHost()->settings().partialTextureUpdates)
layerTreeHost()->deleteTextureAfterCommit(tile->managedTexture()->steal());
if (!tile->managedTexture()->isValid(m_tiler->tileSize(), m_textureFormat))
tile->m_dirtyRect = m_tiler->tileRect(tile);
if (!tile->managedTexture()->reserve(m_tiler->tileSize(), m_textureFormat)) {
m_skipsIdlePaint = true;
if (!idle) {
m_skipsDraw = true;
cleanupResources();
}
return;
}
dirtyLayerRect.unite(tile->m_dirtyRect);
tile->copyAndClearDirty();
}
}
m_paintRect = dirtyLayerRect;
if (dirtyLayerRect.isEmpty())
return;
// Due to borders, when the paint rect is extended to tile boundaries, it
// may end up overlapping more tiles than the original content rect. Record
// the original tiles so we don't upload more tiles than necessary.
if (!m_paintRect.isEmpty())
m_requestedUpdateTilesRect = IntRect(left, top, right - left + 1, bottom - top + 1);
// Calling prepareToUpdate() calls into WebKit to paint, which may have the side
// effect of disabling compositing, which causes our reference to the texture updater to be deleted.
// However, we can't free the memory backing the GraphicsContext until the paint finishes,
// so we grab a local reference here to hold the updater alive until the paint completes.
RefPtr<LayerTextureUpdater> protector(textureUpdater());
IntRect opaqueRect; // FIXME: unused. remove this and store in the layer to pass to impl for draw culling
textureUpdater()->prepareToUpdate(m_paintRect, m_tiler->tileSize(), m_tiler->hasBorderTexels(), contentsScale(), &opaqueRect);
for (int j = top; j <= bottom; ++j) {
for (int i = left; i <= right; ++i) {
UpdatableTile* tile = tileAt(i, j);
// Tiles are created before prepareToUpdate() is called.
if (!tile)
CRASH();
// Use m_updateRect as copyAndClearDirty above moved the existing dirty rect to m_updateRect.
const IntRect& dirtyRect = tile->m_updateRect;
if (dirtyRect.isEmpty())
continue;
IntRect sourceRect = m_tiler->tileRect(tile);
sourceRect.intersect(dirtyRect);
// Paint rect not guaranteed to line up on tile boundaries, so
// make sure that sourceRect doesn't extend outside of it.
sourceRect.intersect(m_paintRect);
tile->m_updateRect = sourceRect;
if (sourceRect.isEmpty())
continue;
tile->texture()->prepareRect(sourceRect);
}
}
}
CCRenderSurface::~CCRenderSurface()
{
cleanupResources();
}
CCPluginLayerImpl::~CCPluginLayerImpl()
{
cleanupResources();
}
