, m_tileCreationTimer(new TileTimer(this, &TiledBackingStore::tileCreationTimerFired))
, m_tileSize(defaultTileWidth, defaultTileHeight)
, m_tileCreationDelay(0.01)
-#if !ENABLE(TILED_BACKING_STORE_EARLY_MERGE)
- , m_keepAreaMultiplier(2.f, 3.5f)
- , m_coverAreaMultiplier(1.5f, 2.5f)
-#else
, m_keepAreaMultiplier(3.5f)
, m_coverAreaMultiplier(2.5f)
-#endif
, m_contentsScale(1.f)
, m_pendingScale(0)
, m_contentsFrozen(false)
-#if PLATFORM(EFL)
+#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
, m_maxTileCount(0)
#endif
{
-#if ENABLE(TILED_BACKING_STORE_EARLY_MERGE)
ASSERT(m_coverAreaMultiplier <= m_keepAreaMultiplier);
-#endif
}
TiledBackingStore::~TiledBackingStore()
m_tileCreationDelay = delay;
}
-#if !ENABLE(TILED_BACKING_STORE_EARLY_MERGE)
-void TiledBackingStore::setKeepAndCoverAreaMultipliers(const FloatSize& keepMultiplier, const FloatSize& coverMultiplier)
-#else
void TiledBackingStore::setKeepAndCoverAreaMultipliers(float keepMultiplier, float coverMultiplier)
-#endif
{
-#if ENABLE(TILED_BACKING_STORE_EARLY_MERGE)
ASSERT(coverMultiplier <= keepMultiplier);
-#endif
m_keepAreaMultiplier = keepMultiplier;
m_coverAreaMultiplier = coverMultiplier;
startTileCreationTimer();
}
-#if ENABLE(TILED_BACKING_STORE_EARLY_MERGE)
void TiledBackingStore::setVisibleRectTrajectoryVector(const FloatPoint& vector)
{
if (m_visibleRectTrajectoryVector == vector)
m_visibleRectTrajectoryVector = vector;
startTileCreationTimer();
}
-#endif
void TiledBackingStore::invalidate(const IntRect& contentsDirtyRect)
{
currentTile->invalidate(dirtyRect);
}
}
-
+#if !ENABLE(TIZEN_RECORDING_SURFACE_PAINT_THREAD)
startTileBufferUpdateTimer();
+#else
+ if (m_client->recordingSurfaceSetEnableGet() == false)
+ startTileBufferUpdateTimer();
+#endif
+}
+
+#if ENABLE(TIZEN_RECORDING_SURFACE_SET)
+void TiledBackingStore::setDirtyUnionRect(const IntRect& rect)
+{
+ m_dirtyUnionRect = rect;
+}
+
+void TiledBackingStore::uniteDirtyUnionRect(const IntRect& rect)
+{
+ m_dirtyUnionRect.unite(rect);
+}
+#endif
+
+
+#if ENABLE(TIZEN_RECORDING_SURFACE_PAINT_THREAD)
+void TiledBackingStore::updateTileBuffersBegin()
+{
+ if (!m_client->tiledBackingStoreUpdatesAllowed() || m_contentsFrozen)
+ return;
+
+ invalidate(m_dirtyUnionRect);
+ m_client->tiledBackingStorePaintBegin();
+ m_dirtyTiles.clear();
+ TileMap::iterator end = m_tiles.end();
+ for (TileMap::iterator it = m_tiles.begin(); it != end; ++it) {
+ if (!it->second->isDirty())
+ continue;
+ m_dirtyTiles.append(it->second);
+ }
}
void TiledBackingStore::updateTileBuffers()
{
+ if (m_client->recordingSurfaceSetEnableGet()) {
+ if (!m_client->tiledBackingStoreUpdatesAllowed() || m_contentsFrozen)
+ return;
+
+ Vector<IntRect> paintedArea;
+ if (m_dirtyTiles.isEmpty()) {
+ m_client->tiledBackingStorePaintEnd(paintedArea);
+ return;
+ }
+ // FIXME: In single threaded case, tile back buffers could be updated asynchronously
+ // one by one and then swapped to front in one go. This would minimize the time spent
+ // blocking on tile updates.
+ unsigned size = m_dirtyTiles.size();
+ for (unsigned n = 0; n < size; ++n) {
+ Vector<IntRect> paintedRects = m_dirtyTiles[n]->updateBackBuffer();
+ paintedArea.append(paintedRects);
+ m_dirtyTiles[n]->swapBackBufferToFront();
+ }
+ m_client->tiledBackingStorePaintEnd(paintedArea);
+ } else {
+ if (!m_client->tiledBackingStoreUpdatesAllowed() || m_contentsFrozen)
+ return;
+
+ m_client->tiledBackingStorePaintBegin();
+
+ Vector<IntRect> paintedArea;
+ Vector<RefPtr<Tile> > dirtyTiles;
+ TileMap::iterator end = m_tiles.end();
+ for (TileMap::iterator it = m_tiles.begin(); it != end; ++it) {
+ if (!it->second->isDirty())
+ continue;
+ dirtyTiles.append(it->second);
+ }
+
+ if (dirtyTiles.isEmpty()) {
+ m_client->tiledBackingStorePaintEnd(paintedArea);
+ return;
+ }
+
+ // FIXME: In single threaded case, tile back buffers could be updated asynchronously
+ // one by one and then swapped to front in one go. This would minimize the time spent
+ // blocking on tile updates.
+ unsigned size = dirtyTiles.size();
+ for (unsigned n = 0; n < size; ++n) {
+ Vector<IntRect> paintedRects = dirtyTiles[n]->updateBackBuffer();
+ paintedArea.append(paintedRects);
+ dirtyTiles[n]->swapBackBufferToFront();
+ }
+
+ m_client->tiledBackingStorePaintEnd(paintedArea);
+ }
+}
+#else
+void TiledBackingStore::updateTileBuffers()
+{
if (!m_client->tiledBackingStoreUpdatesAllowed() || m_contentsFrozen)
return;
m_client->tiledBackingStorePaintEnd(paintedArea);
}
+#endif
void TiledBackingStore::paint(GraphicsContext* context, const IntRect& rect)
{
void TiledBackingStore::adjustVisibleRect()
{
- IntRect visibleRect = mapFromContents(m_client->tiledBackingStoreVisibleRect());
+ IntRect visibleRect = visibleContentsRect();
if (m_previousVisibleRect == visibleRect)
return;
m_previousVisibleRect = visibleRect;
-#if PLATFORM(EFL)
+#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
m_maxTileCount = (ceil((visibleRect.width()*m_keepAreaMultiplier)/m_tileSize.width()) + 1)
* (ceil((visibleRect.height()*m_keepAreaMultiplier)/m_tileSize.height()) + 1);
#endif
startTileCreationTimer();
}
+IntRect TiledBackingStore::visibleContentsRect()
+{
+ return mapFromContents(intersection(m_client->tiledBackingStoreVisibleRect(), m_client->tiledBackingStoreContentsRect()));
+}
+
void TiledBackingStore::setContentsScale(float scale)
{
if (m_pendingScale == m_contentsScale) {
{
if (m_contentsFrozen)
return;
-
- IntRect visibleRect = mapFromContents(m_client->tiledBackingStoreVisibleRect());
+
+ IntRect visibleRect = visibleContentsRect();
m_previousVisibleRect = visibleRect;
if (visibleRect.isEmpty())
return;
-#if !ENABLE(TILED_BACKING_STORE_EARLY_MERGE)
- // Remove tiles that extend outside the current contents rect.
- dropOverhangingTiles();
-
- IntRect keepRect = visibleRect;
- // Inflates to both sides, so divide inflate delta by 2
- keepRect.inflateX(visibleRect.width() * (m_keepAreaMultiplier.width() - 1.f) / 2);
- keepRect.inflateY(visibleRect.height() * (m_keepAreaMultiplier.height() - 1.f) / 2);
- keepRect.intersect(contentsRect());
-
- dropTilesOutsideRect(keepRect);
-
- IntRect coverRect = visibleRect;
- // Inflates to both sides, so divide inflate delta by 2
- coverRect.inflateX(visibleRect.width() * (m_coverAreaMultiplier.width() - 1.f) / 2);
- coverRect.inflateY(visibleRect.height() * (m_coverAreaMultiplier.height() - 1.f) / 2);
- coverRect.intersect(contentsRect());
-#else
// Resize tiles on edges in case the contents size has changed.
bool didResizeTiles = resizeEdgeTiles();
IntRect keepRect = computeKeepRect(visibleRect);
-
-#if !PLATFORM(EFL)
+
+#if !ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
dropTilesOutsideRect(keepRect);
#endif
IntRect coverRect = computeCoverRect(visibleRect);
ASSERT(keepRect.contains(coverRect));
-#endif
-
+
// Search for the tile position closest to the viewport center that does not yet contain a tile.
// Which position is considered the closest depends on the tileDistance function.
double shortestDistance = std::numeric_limits<double>::infinity();
// Now construct the tile(s)
unsigned tilesToCreateCount = tilesToCreate.size();
-#if PLATFORM(EFL)
+#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
// drop tiles as many as tiles which will be created this time
dropTilesOutsideRect(keepRect, tilesToCreateCount);
#endif
requiredTileCount -= tilesToCreateCount;
// Paint the content of the newly created tiles
-#if !ENABLE(TILED_BACKING_STORE_EARLY_MERGE)
- if (tilesToCreateCount)
-#else
+#if !ENABLE(TIZEN_RECORDING_SURFACE_PAINT_THREAD)
if (tilesToCreateCount || didResizeTiles)
-#endif
updateTileBuffers();
+#else
+ if (m_client->recordingSurfaceSetEnableGet()) {
+ if (tilesToCreateCount || didResizeTiles)
+ updateTileBuffersBegin();
+ updateTileBuffers();
+ } else {
+ if (tilesToCreateCount || didResizeTiles)
+ updateTileBuffers();
+ }
+#endif
// Keep creating tiles until the whole coverRect is covered.
if (requiredTileCount)
m_tileCreationTimer->startOneShot(m_tileCreationDelay);
}
-#if !ENABLE(TILED_BACKING_STORE_EARLY_MERGE)
-void TiledBackingStore::dropOverhangingTiles()
-{
- IntRect contentsRect = this->contentsRect();
-
- Vector<Tile::Coordinate> tilesToRemove;
- TileMap::iterator end = m_tiles.end();
- for (TileMap::iterator it = m_tiles.begin(); it != end; ++it) {
- Tile::Coordinate tileCoordinate = it->second->coordinate();
- IntRect tileRect = it->second->rect();
- IntRect expectedTileRect = tileRectForCoordinate(tileCoordinate);
- if (expectedTileRect != tileRect || !contentsRect.contains(tileRect))
- tilesToRemove.append(tileCoordinate);
- }
- unsigned removeCount = tilesToRemove.size();
- for (unsigned n = 0; n < removeCount; ++n)
- removeTile(tilesToRemove[n]);
-}
-#else
IntRect TiledBackingStore::computeKeepRect(const IntRect& visibleRect) const
{
IntRect result = visibleRect;
removeTile(tilesToRemove[n]);
return wasResized;
}
-#endif
void TiledBackingStore::dropTilesOutsideRect(const IntRect& keepRect)
{
removeTile(toRemove[n]);
}
-#if PLATFORM(EFL)
+#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
void TiledBackingStore::dropTilesOutsideRect(const IntRect& keepRect, unsigned tileCount)
{
if (m_tiles.size() + tileCount <= m_maxTileCount)
{
if (m_tileBufferUpdateTimer->isActive() || !m_client->tiledBackingStoreUpdatesAllowed() || m_contentsFrozen)
return;
+
m_tileBufferUpdateTimer->startOneShot(0);
}
void TiledBackingStore::tileBufferUpdateTimerFired(TileTimer*)
{
+#if ENABLE(TIZEN_RECORDING_SURFACE_PAINT_THREAD)
+ if (m_client->recordingSurfaceSetEnableGet())
+ m_client->scheduleUpdateTileBuffersAsync();
+ else
+ updateTileBuffers();
+#else
updateTileBuffers();
+#endif
}
void TiledBackingStore::startTileCreationTimer()
projects / framework / web / webkit-efl.git / blobdiff