void TileController::setZoomedOutContentsScale(float scale)
{
ASSERT(owningGraphicsLayer()->isCommittingChanges());
float deviceScaleFactor = owningGraphicsLayer()->platformCALayerDeviceScaleFactor();
scale /= deviceScaleFactor;
if (m_zoomedOutContentsScale == scale)
return;
m_zoomedOutContentsScale = scale;
if (m_zoomedOutTileGrid && m_zoomedOutTileGrid->scale() != m_zoomedOutContentsScale)
clearZoomedOutTileGrid();
}
IntSize TileController::tileSize() const
{
if (m_inLiveResize || m_tileSizeLocked)
return tileGrid().tileSize();
const int kLowestCommonDenominatorMaxTileSize = 4 * 1024;
IntSize maxTileSize(kLowestCommonDenominatorMaxTileSize, kLowestCommonDenominatorMaxTileSize);
#if USE(IOSURFACE)
IntSize surfaceSizeLimit = IOSurface::maximumSize();
surfaceSizeLimit.scale(1 / m_deviceScaleFactor);
maxTileSize = maxTileSize.shrunkTo(surfaceSizeLimit);
#endif
if (owningGraphicsLayer()->platformCALayerUseGiantTiles())
return maxTileSize;
IntSize tileSize(kDefaultTileSize, kDefaultTileSize);
if (m_scrollability == NotScrollable) {
IntSize scaledSize = expandedIntSize(boundsWithoutMargin().size() * tileGrid().scale());
tileSize = scaledSize.constrainedBetween(IntSize(kDefaultTileSize, kDefaultTileSize), maxTileSize);
} else if (m_scrollability == VerticallyScrollable)
tileSize.setWidth(std::min(std::max<int>(ceilf(boundsWithoutMargin().width() * tileGrid().scale()), kDefaultTileSize), maxTileSize.width()));
LOG_WITH_STREAM(Scrolling, stream << "TileController::tileSize newSize=" << tileSize);
m_tileSizeLocked = true;
return tileSize;
}
void TileController::tileSizeChangeTimerFired()
{
if (!owningGraphicsLayer())
return;
m_tileSizeLocked = false;
setNeedsRevalidateTiles();
}
TileController::TileController(PlatformCALayer* rootPlatformLayer)
: m_tileCacheLayer(rootPlatformLayer)
, m_tileGrid(std::make_unique<TileGrid>(*this))
, m_tileRevalidationTimer(*this, &TileController::tileRevalidationTimerFired)
, m_tileSizeChangeTimer(*this, &TileController::tileSizeChangeTimerFired, tileSizeUpdateDelay)
, m_deviceScaleFactor(owningGraphicsLayer()->platformCALayerDeviceScaleFactor())
, m_marginEdges(false, false, false, false)
{
}
void TileController::setCoverageRect(const FloatRect& rect)
{
ASSERT(owningGraphicsLayer()->isCommittingChanges());
if (m_coverageRect == rect)
return;
m_coverageRect = rect;
setNeedsRevalidateTiles();
}
void TileController::setContentsScale(float scale)
{
ASSERT(owningGraphicsLayer()->isCommittingChanges());
float deviceScaleFactor = owningGraphicsLayer()->platformCALayerDeviceScaleFactor();
// The scale we get is the product of the page scale factor and device scale factor.
// Divide by the device scale factor so we'll get the page scale factor.
scale /= deviceScaleFactor;
if (tileGrid().scale() == scale && m_deviceScaleFactor == deviceScaleFactor && !m_hasTilesWithTemporaryScaleFactor)
return;
m_hasTilesWithTemporaryScaleFactor = false;
m_deviceScaleFactor = deviceScaleFactor;
if (m_coverageMap)
m_coverageMap->setDeviceScaleFactor(deviceScaleFactor);
if (m_zoomedOutTileGrid && m_zoomedOutTileGrid->scale() == scale) {
m_tileGrid = WTFMove(m_zoomedOutTileGrid);
m_tileGrid->setIsZoomedOutTileGrid(false);
m_tileGrid->revalidateTiles();
tileGridsChanged();
return;
}
if (m_zoomedOutContentsScale && m_zoomedOutContentsScale == tileGrid().scale() && tileGrid().scale() != scale && !m_hasTilesWithTemporaryScaleFactor) {
m_zoomedOutTileGrid = WTFMove(m_tileGrid);
m_zoomedOutTileGrid->setIsZoomedOutTileGrid(true);
m_tileGrid = std::make_unique<TileGrid>(*this);
tileGridsChanged();
}
tileGrid().setScale(scale);
tileGrid().setNeedsDisplay();
}
void TileController::tileRevalidationTimerFired()
{
if (!owningGraphicsLayer())
return;
if (m_isInWindow) {
setNeedsRevalidateTiles();
return;
}
// If we are not visible get rid of the zoomed-out tiles.
clearZoomedOutTileGrid();
TileGrid::TileValidationPolicy validationPolicy = (shouldAggressivelyRetainTiles() ? 0 : TileGrid::PruneSecondaryTiles) | TileGrid::UnparentAllTiles;
tileGrid().revalidateTiles(validationPolicy);
}
TileController::TileController(PlatformCALayer* rootPlatformLayer)
: m_tileCacheLayer(rootPlatformLayer)
, m_tileGrid(std::make_unique<TileGrid>(*this))
, m_tileRevalidationTimer(*this, &TileController::tileRevalidationTimerFired)
, m_zoomedOutContentsScale(0)
, m_deviceScaleFactor(owningGraphicsLayer()->platformCALayerDeviceScaleFactor())
, m_tileCoverage(CoverageForVisibleArea)
, m_marginTop(0)
, m_marginBottom(0)
, m_marginLeft(0)
, m_marginRight(0)
, m_isInWindow(false)
, m_scrollingPerformanceLoggingEnabled(false)
, m_unparentsOffscreenTiles(false)
, m_acceleratesDrawing(false)
, m_tilesAreOpaque(false)
, m_hasTilesWithTemporaryScaleFactor(false)
, m_tileDebugBorderWidth(0)
, m_indicatorMode(SynchronousScrollingBecauseOfLackOfScrollingCoordinatorIndication)
, m_topContentInset(0)
{
}
RefPtr<PlatformCALayer> TileController::createTileLayer(const IntRect& tileRect, TileGrid& grid)
{
RefPtr<PlatformCALayer> layer = m_tileCacheLayer->createCompatibleLayerOrTakeFromPool(PlatformCALayer::LayerTypeTiledBackingTileLayer, &grid, tileRect.size());
layer->setAnchorPoint(FloatPoint3D());
layer->setPosition(tileRect.location());
layer->setBorderColor(m_tileDebugBorderColor);
layer->setBorderWidth(m_tileDebugBorderWidth);
layer->setEdgeAntialiasingMask(0);
layer->setOpaque(m_tilesAreOpaque);
#ifndef NDEBUG
layer->setName("Tile");
#endif
float temporaryScaleFactor = owningGraphicsLayer()->platformCALayerContentsScaleMultiplierForNewTiles(m_tileCacheLayer);
m_hasTilesWithTemporaryScaleFactor |= temporaryScaleFactor != 1;
layer->setContentsScale(m_deviceScaleFactor * temporaryScaleFactor);
layer->setAcceleratesDrawing(m_acceleratesDrawing);
layer->setNeedsDisplay();
return layer;
}
void TileController::tileCacheLayerBoundsChanged()
{
ASSERT(owningGraphicsLayer()->isCommittingChanges());
setNeedsRevalidateTiles();
notePendingTileSizeChange();
}
void TileController::setNeedsRevalidateTiles()
{
owningGraphicsLayer()->platformCALayerSetNeedsToRevalidateTiles();
}
void TileController::tileGridsChanged()
{
return owningGraphicsLayer()->platformCALayerCustomSublayersChanged(m_tileCacheLayer);
}
bool TileController::shouldTemporarilyRetainTileCohorts() const
{
return owningGraphicsLayer()->platformCALayerShouldTemporarilyRetainTileCohorts(m_tileCacheLayer);
}
bool TileController::shouldAggressivelyRetainTiles() const
{
return owningGraphicsLayer()->platformCALayerShouldAggressivelyRetainTiles(m_tileCacheLayer);
}
void TileController::revalidateTiles()
{
ASSERT(owningGraphicsLayer()->isCommittingChanges());
tileGrid().revalidateTiles();
}
IntSize TileController::tileSize() const
{
return owningGraphicsLayer()->platformCALayerTileSize();
}