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::setNeedsDisplayInRect(const IntRect& rect)
{
tileGrid().setNeedsDisplayInRect(rect);
if (m_zoomedOutTileGrid)
m_zoomedOutTileGrid->dropTilesInRect(rect);
updateTileCoverageMap();
}
unsigned TileController::numberOfUnparentedTiles() const
{
unsigned count = tileGrid().numberOfUnparentedTiles();
if (m_zoomedOutTileGrid)
count += m_zoomedOutTileGrid->numberOfUnparentedTiles();
return count;
}
double TileController::retainedTileBackingStoreMemory() const
{
double bytes = tileGrid().retainedTileBackingStoreMemory();
if (m_zoomedOutTileGrid)
bytes += m_zoomedOutTileGrid->retainedTileBackingStoreMemory();
return bytes;
}
bool TileController::tilesWouldChangeForCoverageRect(const FloatRect& rect) const
{
if (bounds().isEmpty())
return false;
return tileGrid().tilesWouldChangeForCoverageRect(rect);
}
void TileController::setTileDebugBorderWidth(float borderWidth)
{
if (m_tileDebugBorderWidth == borderWidth)
return;
m_tileDebugBorderWidth = borderWidth;
tileGrid().updateTileLayerProperties();
}
Vector<RefPtr<PlatformCALayer>> TileController::containerLayers()
{
Vector<RefPtr<PlatformCALayer>> layerList;
if (m_zoomedOutTileGrid)
layerList.append(&m_zoomedOutTileGrid->containerLayer());
layerList.append(&tileGrid().containerLayer());
return layerList;
}
void TileController::setTilesOpaque(bool opaque)
{
if (opaque == m_tilesAreOpaque)
return;
m_tilesAreOpaque = opaque;
tileGrid().updateTileLayerProperties();
}
void TileController::setAcceleratesDrawing(bool acceleratesDrawing)
{
if (m_acceleratesDrawing == acceleratesDrawing)
return;
m_acceleratesDrawing = acceleratesDrawing;
tileGrid().updateTileLayerProperties();
}
void TileController::setTileDebugBorderColor(Color borderColor)
{
if (m_tileDebugBorderColor == borderColor)
return;
m_tileDebugBorderColor = borderColor;
tileGrid().updateTileLayerProperties();
}
void TileController::removeUnparentedTilesNow()
{
tileGrid().removeUnparentedTilesNow();
if (m_zoomedOutTileGrid)
m_zoomedOutTileGrid->removeUnparentedTilesNow();
updateTileCoverageMap();
}
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);
}
int TileController::bottomMarginHeight() const
{
return m_marginBottom / tileGrid().scale();
}
void TileController::prepopulateRect(const FloatRect& rect)
{
if (tileGrid().prepopulateRect(rect))
setNeedsRevalidateTiles();
}
float TileController::contentsScale() const
{
return tileGrid().scale() * m_deviceScaleFactor;
}
int TileController::bottomMarginHeight() const
{
return (m_marginSize * m_marginEdges.bottom()) / tileGrid().scale();
}
int TileController::rightMarginWidth() const
{
return (m_marginSize * m_marginEdges.right()) / tileGrid().scale();
}
// Return the rect in layer coords, not tile coords.
IntRect TileController::tileCoverageRect() const
{
return tileGrid().tileCoverageRect();
}
int TileController::topMarginHeight() const
{
return (m_marginSize * m_marginEdges.top()) / tileGrid().scale();
}
void TileController::revalidateTiles()
{
ASSERT(owningGraphicsLayer()->isCommittingChanges());
tileGrid().revalidateTiles();
}
IntRect TileController::tileGridExtent() const
{
return tileGrid().extent();
}
unsigned TileController::blankPixelCount() const
{
return tileGrid().blankPixelCount();
}
int TileController::rightMarginWidth() const
{
return m_marginRight / tileGrid().scale();
}
void TileController::setNeedsDisplay()
{
tileGrid().setNeedsDisplay();
clearZoomedOutTileGrid();
}
int TileController::topMarginHeight() const
{
return m_marginTop / tileGrid().scale();
}
int TileController::leftMarginWidth() const
{
return m_marginLeft / tileGrid().scale();
}
