Deadlock on applications using JSContext on non-main thread
[WebKit-https.git] / Source / WebCore / platform / graphics / TiledBackingStore.cpp
1 /*
2  Copyright (C) 2010-2012 Nokia Corporation and/or its subsidiary(-ies)
3  
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Library General Public
6  License as published by the Free Software Foundation; either
7  version 2 of the License, or (at your option) any later version.
8  
9  This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  Library General Public License for more details.
13  
14  You should have received a copy of the GNU Library General Public License
15  along with this library; see the file COPYING.LIB.  If not, write to
16  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  Boston, MA 02110-1301, USA.
18  */
19
20 #include "config.h"
21 #include "TiledBackingStore.h"
22
23 #if USE(TILED_BACKING_STORE)
24
25 #include "GraphicsContext.h"
26 #include "TiledBackingStoreClient.h"
27
28 namespace WebCore {
29
30 static const int defaultTileDimension = 512;
31
32 static IntPoint innerBottomRight(const IntRect& rect)
33 {
34     // Actually, the rect does not contain rect.maxX(). Refer to IntRect::contain.
35     return IntPoint(rect.maxX() - 1, rect.maxY() - 1);
36 }
37
38 TiledBackingStore::TiledBackingStore(TiledBackingStoreClient* client, std::unique_ptr<TiledBackingStoreBackend> backend)
39     : m_client(client)
40     , m_backend(WTF::move(backend))
41     , m_tileSize(defaultTileDimension, defaultTileDimension)
42     , m_coverAreaMultiplier(2.0f)
43     , m_contentsScale(1.f)
44     , m_supportsAlpha(false)
45     , m_pendingTileCreation(false)
46 {
47 }
48
49 TiledBackingStore::~TiledBackingStore()
50 {
51 }
52
53 void TiledBackingStore::setTileSize(const IntSize& size)
54 {
55     m_tileSize = size;
56     m_tiles.clear();
57 }
58
59 void TiledBackingStore::setTrajectoryVector(const FloatPoint& trajectoryVector)
60 {
61     m_pendingTrajectoryVector = trajectoryVector;
62     m_pendingTrajectoryVector.normalize();
63 }
64
65 void TiledBackingStore::coverWithTilesIfNeeded()
66 {
67     IntRect visibleRect = this->visibleRect();
68     IntRect rect = mapFromContents(m_client->tiledBackingStoreContentsRect());
69
70     bool didChange = m_trajectoryVector != m_pendingTrajectoryVector || m_visibleRect != visibleRect || m_rect != rect;
71     if (didChange || m_pendingTileCreation)
72         createTiles();
73 }
74
75 void TiledBackingStore::invalidate(const IntRect& contentsDirtyRect)
76 {
77     IntRect dirtyRect(mapFromContents(contentsDirtyRect));
78     IntRect keepRectFitToTileSize = tileRectForCoordinate(tileCoordinateForPoint(m_keepRect.location()));
79     keepRectFitToTileSize.unite(tileRectForCoordinate(tileCoordinateForPoint(innerBottomRight(m_keepRect))));
80
81     // Only iterate on the part of the rect that we know we might have tiles.
82     IntRect coveredDirtyRect = intersection(dirtyRect, keepRectFitToTileSize);
83     Tile::Coordinate topLeft = tileCoordinateForPoint(coveredDirtyRect.location());
84     Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(coveredDirtyRect));
85
86     for (int yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
87         for (int xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
88             RefPtr<Tile> currentTile = tileAt(Tile::Coordinate(xCoordinate, yCoordinate));
89             if (!currentTile)
90                 continue;
91             // Pass the full rect to each tile as coveredDirtyRect might not
92             // contain them completely and we don't want partial tile redraws.
93             currentTile->invalidate(dirtyRect);
94         }
95     }
96 }
97
98 void TiledBackingStore::updateTileBuffers()
99 {
100     m_client->tiledBackingStorePaintBegin();
101
102     Vector<IntRect> paintedArea;
103     Vector<RefPtr<Tile> > dirtyTiles;
104     for (auto& tile : m_tiles.values()) {
105         if (!tile->isDirty())
106             continue;
107         dirtyTiles.append(tile);
108     }
109
110     if (dirtyTiles.isEmpty()) {
111         m_client->tiledBackingStorePaintEnd(paintedArea);
112         return;
113     }
114
115     // FIXME: In single threaded case, tile back buffers could be updated asynchronously 
116     // one by one and then swapped to front in one go. This would minimize the time spent
117     // blocking on tile updates.
118     unsigned size = dirtyTiles.size();
119     for (unsigned n = 0; n < size; ++n) {
120         Vector<IntRect> paintedRects = dirtyTiles[n]->updateBackBuffer();
121         paintedArea.appendVector(paintedRects);
122         dirtyTiles[n]->swapBackBufferToFront();
123     }
124
125     m_client->tiledBackingStorePaintEnd(paintedArea);
126 }
127
128 IntRect TiledBackingStore::visibleRect() const
129 {
130     return mapFromContents(m_client->tiledBackingStoreVisibleRect());
131 }
132
133 void TiledBackingStore::setContentsScale(float scale)
134 {
135     if (scale == m_contentsScale)
136         return;
137
138     m_contentsScale = scale;
139     m_tiles.clear();
140     coverWithTilesIfNeeded();
141 }
142
143 double TiledBackingStore::tileDistance(const IntRect& viewport, const Tile::Coordinate& tileCoordinate) const
144 {
145     if (viewport.intersects(tileRectForCoordinate(tileCoordinate)))
146         return 0;
147
148     IntPoint viewCenter = viewport.location() + IntSize(viewport.width() / 2, viewport.height() / 2);
149     Tile::Coordinate centerCoordinate = tileCoordinateForPoint(viewCenter);
150
151     return std::max(abs(centerCoordinate.y() - tileCoordinate.y()), abs(centerCoordinate.x() - tileCoordinate.x()));
152 }
153
154 // Returns a ratio between 0.0f and 1.0f of the surface of contentsRect covered by rendered tiles.
155 float TiledBackingStore::coverageRatio(const WebCore::IntRect& contentsRect) const
156 {
157     IntRect dirtyRect = mapFromContents(contentsRect);
158     float rectArea = dirtyRect.width() * dirtyRect.height();
159     float coverArea = 0.0f;
160
161     Tile::Coordinate topLeft = tileCoordinateForPoint(dirtyRect.location());
162     Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(dirtyRect));
163
164     for (int yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
165         for (int xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
166             Tile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
167             RefPtr<Tile> currentTile = tileAt(currentCoordinate);
168             if (currentTile && currentTile->isReadyToPaint()) {
169                 IntRect coverRect = intersection(dirtyRect, currentTile->rect());
170                 coverArea += coverRect.width() * coverRect.height();
171             }
172         }
173     }
174     return coverArea / rectArea;
175 }
176
177 bool TiledBackingStore::visibleAreaIsCovered() const
178 {
179     IntRect boundedVisibleContentsRect = intersection(m_client->tiledBackingStoreVisibleRect(), m_client->tiledBackingStoreContentsRect());
180     return coverageRatio(boundedVisibleContentsRect) == 1.0f;
181 }
182
183 void TiledBackingStore::createTiles()
184 {
185     // Update our backing store geometry.
186     const IntRect previousRect = m_rect;
187     m_rect = mapFromContents(m_client->tiledBackingStoreContentsRect());
188     m_trajectoryVector = m_pendingTrajectoryVector;
189     m_visibleRect = visibleRect();
190
191     if (m_rect.isEmpty()) {
192         setCoverRect(IntRect());
193         setKeepRect(IntRect());
194         return;
195     }
196
197     /* We must compute cover and keep rects using the visibleRect, instead of the rect intersecting the visibleRect with m_rect,
198      * because TBS can be used as a backing store of GraphicsLayer and the visible rect usually does not intersect with m_rect.
199      * In the below case, the intersecting rect is an empty.
200      *
201      *  +---------------+
202      *  |               |
203      *  |   m_rect      |
204      *  |       +-------|-----------------------+
205      *  |       | HERE  |  cover or keep        |
206      *  +---------------+      rect             |
207      *          |         +---------+           |
208      *          |         | visible |           |
209      *          |         |  rect   |           |
210      *          |         +---------+           |
211      *          |                               |
212      *          |                               |
213      *          +-------------------------------+
214      *
215      * We must create or keep the tiles in the HERE region.
216      */
217
218     IntRect coverRect;
219     IntRect keepRect;
220     computeCoverAndKeepRect(m_visibleRect, coverRect, keepRect);
221
222     setCoverRect(coverRect);
223     setKeepRect(keepRect);
224
225     if (coverRect.isEmpty())
226         return;
227
228     // Resize tiles at the edge in case the contents size has changed, but only do so
229     // after having dropped tiles outside the keep rect.
230     bool didResizeTiles = false;
231     if (previousRect != m_rect)
232         didResizeTiles = resizeEdgeTiles();
233
234     // Search for the tile position closest to the viewport center that does not yet contain a tile.
235     // Which position is considered the closest depends on the tileDistance function.
236     double shortestDistance = std::numeric_limits<double>::infinity();
237     Vector<Tile::Coordinate> tilesToCreate;
238     unsigned requiredTileCount = 0;
239
240     // Cover areas (in tiles) with minimum distance from the visible rect. If the visible rect is
241     // not covered already it will be covered first in one go, due to the distance being 0 for tiles
242     // inside the visible rect.
243     Tile::Coordinate topLeft = tileCoordinateForPoint(coverRect.location());
244     Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(coverRect));
245     for (int yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
246         for (int xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
247             Tile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
248             if (tileAt(currentCoordinate))
249                 continue;
250             ++requiredTileCount;
251             double distance = tileDistance(m_visibleRect, currentCoordinate);
252             if (distance > shortestDistance)
253                 continue;
254             if (distance < shortestDistance) {
255                 tilesToCreate.clear();
256                 shortestDistance = distance;
257             }
258             tilesToCreate.append(currentCoordinate);
259         }
260     }
261
262     // Now construct the tile(s) within the shortest distance.
263     unsigned tilesToCreateCount = tilesToCreate.size();
264     for (unsigned n = 0; n < tilesToCreateCount; ++n) {
265         Tile::Coordinate coordinate = tilesToCreate[n];
266         setTile(coordinate, m_backend->createTile(this, coordinate));
267     }
268     requiredTileCount -= tilesToCreateCount;
269
270     // Paint the content of the newly created tiles or resized tiles.
271     if (tilesToCreateCount || didResizeTiles)
272         updateTileBuffers();
273
274     // Re-call createTiles on a timer to cover the visible area with the newest shortest distance.
275     m_pendingTileCreation = requiredTileCount;
276     if (m_pendingTileCreation)
277         m_client->tiledBackingStoreHasPendingTileCreation();
278 }
279
280 void TiledBackingStore::adjustForContentsRect(IntRect& rect) const
281 {
282     IntRect bounds = m_rect;
283     IntSize candidateSize = rect.size();
284
285     rect.intersect(bounds);
286
287     if (rect.size() == candidateSize)
288         return;
289
290     /*
291      * In the following case, there is no intersection of the contents rect and the cover rect.
292      * Thus the latter should not be inflated.
293      *
294      *  +---------------+
295      *  |   m_rect      |
296      *  +---------------+
297      *
298      *          +-------------------------------+
299      *          |          cover rect           |
300      *          |         +---------+           |
301      *          |         | visible |           |
302      *          |         |  rect   |           |
303      *          |         +---------+           |
304      *          +-------------------------------+
305      */
306     if (rect.isEmpty())
307         return;
308
309     // Try to create a cover rect of the same size as the candidate, but within content bounds.
310     int pixelsCovered = candidateSize.width() * candidateSize.height();
311
312     if (rect.width() < candidateSize.width())
313         rect.inflateY(((pixelsCovered / rect.width()) - rect.height()) / 2);
314     if (rect.height() < candidateSize.height())
315         rect.inflateX(((pixelsCovered / rect.height()) - rect.width()) / 2);
316
317     rect.intersect(bounds);
318 }
319
320 void TiledBackingStore::computeCoverAndKeepRect(const IntRect& visibleRect, IntRect& coverRect, IntRect& keepRect) const
321 {
322     coverRect = visibleRect;
323     keepRect = visibleRect;
324
325     // If we cover more that the actual viewport we can be smart about which tiles we choose to render.
326     if (m_coverAreaMultiplier > 1) {
327         // The initial cover area covers equally in each direction, according to the coverAreaMultiplier.
328         coverRect.inflateX(visibleRect.width() * (m_coverAreaMultiplier - 1) / 2);
329         coverRect.inflateY(visibleRect.height() * (m_coverAreaMultiplier - 1) / 2);
330         keepRect = coverRect;
331
332         if (m_trajectoryVector != FloatPoint::zero()) {
333             // A null trajectory vector (no motion) means that tiles for the coverArea will be created.
334             // A non-null trajectory vector will shrink the covered rect to visibleRect plus its expansion from its
335             // center toward the cover area edges in the direction of the given vector.
336
337             // E.g. if visibleRect == (10,10)5x5 and coverAreaMultiplier == 3.0:
338             // a (0,0) trajectory vector will create tiles intersecting (5,5)15x15,
339             // a (1,0) trajectory vector will create tiles intersecting (10,10)10x5,
340             // and a (1,1) trajectory vector will create tiles intersecting (10,10)10x10.
341
342             // Multiply the vector by the distance to the edge of the cover area.
343             float trajectoryVectorMultiplier = (m_coverAreaMultiplier - 1) / 2;
344
345             // Unite the visible rect with a "ghost" of the visible rect moved in the direction of the trajectory vector.
346             coverRect = visibleRect;
347             coverRect.move(coverRect.width() * m_trajectoryVector.x() * trajectoryVectorMultiplier,
348                            coverRect.height() * m_trajectoryVector.y() * trajectoryVectorMultiplier);
349
350             coverRect.unite(visibleRect);
351         }
352         ASSERT(keepRect.contains(coverRect));
353     }
354
355     adjustForContentsRect(coverRect);
356
357     // The keep rect is an inflated version of the cover rect, inflated in tile dimensions.
358     keepRect.unite(coverRect);
359     keepRect.inflateX(m_tileSize.width() / 2);
360     keepRect.inflateY(m_tileSize.height() / 2);
361     keepRect.intersect(m_rect);
362
363     ASSERT(coverRect.isEmpty() || keepRect.contains(coverRect));
364 }
365
366 bool TiledBackingStore::resizeEdgeTiles()
367 {
368     bool wasResized = false;
369     Vector<Tile::Coordinate> tilesToRemove;
370     for (auto& tile : m_tiles.values()) {
371         Tile::Coordinate tileCoordinate = tile->coordinate();
372         IntRect tileRect = tile->rect();
373         IntRect expectedTileRect = tileRectForCoordinate(tileCoordinate);
374         if (expectedTileRect.isEmpty())
375             tilesToRemove.append(tileCoordinate);
376         else if (expectedTileRect != tileRect) {
377             tile->resize(expectedTileRect.size());
378             wasResized = true;
379         }
380     }
381     unsigned removeCount = tilesToRemove.size();
382     for (unsigned n = 0; n < removeCount; ++n)
383         removeTile(tilesToRemove[n]);
384     return wasResized;
385 }
386
387 void TiledBackingStore::setKeepRect(const IntRect& keepRect)
388 {
389     // Drop tiles outside the new keepRect.
390
391     FloatRect keepRectF = keepRect;
392
393     Vector<Tile::Coordinate> toRemove;
394     for (auto& tile : m_tiles.values()) {
395         Tile::Coordinate coordinate = tile->coordinate();
396         FloatRect tileRect = tile->rect();
397         if (!tileRect.intersects(keepRectF))
398             toRemove.append(coordinate);
399     }
400     unsigned removeCount = toRemove.size();
401     for (unsigned n = 0; n < removeCount; ++n)
402         removeTile(toRemove[n]);
403
404     m_keepRect = keepRect;
405 }
406
407 void TiledBackingStore::removeAllNonVisibleTiles()
408 {
409     IntRect boundedVisibleRect = mapFromContents(intersection(m_client->tiledBackingStoreVisibleRect(), m_client->tiledBackingStoreContentsRect()));
410     setKeepRect(boundedVisibleRect);
411 }
412
413 PassRefPtr<Tile> TiledBackingStore::tileAt(const Tile::Coordinate& coordinate) const
414 {
415     return m_tiles.get(coordinate);
416 }
417
418 void TiledBackingStore::setTile(const Tile::Coordinate& coordinate, PassRefPtr<Tile> tile)
419 {
420     m_tiles.set(coordinate, tile);
421 }
422
423 void TiledBackingStore::removeTile(const Tile::Coordinate& coordinate)
424 {
425     m_tiles.remove(coordinate);
426 }
427
428 IntRect TiledBackingStore::mapToContents(const IntRect& rect) const
429 {
430     return enclosingIntRect(FloatRect(rect.x() / m_contentsScale,
431         rect.y() / m_contentsScale,
432         rect.width() / m_contentsScale,
433         rect.height() / m_contentsScale));
434 }
435
436 IntRect TiledBackingStore::mapFromContents(const IntRect& rect) const
437 {
438     return enclosingIntRect(FloatRect(rect.x() * m_contentsScale,
439         rect.y() * m_contentsScale,
440         rect.width() * m_contentsScale,
441         rect.height() * m_contentsScale));
442 }
443
444 IntRect TiledBackingStore::tileRectForCoordinate(const Tile::Coordinate& coordinate) const
445 {
446     IntRect rect(coordinate.x() * m_tileSize.width(),
447                  coordinate.y() * m_tileSize.height(),
448                  m_tileSize.width(),
449                  m_tileSize.height());
450
451     rect.intersect(m_rect);
452     return rect;
453 }
454
455 Tile::Coordinate TiledBackingStore::tileCoordinateForPoint(const IntPoint& point) const
456 {
457     int x = point.x() / m_tileSize.width();
458     int y = point.y() / m_tileSize.height();
459     return Tile::Coordinate(std::max(x, 0), std::max(y, 0));
460 }
461
462 void TiledBackingStore::setSupportsAlpha(bool a)
463 {
464     if (a == m_supportsAlpha)
465         return;
466     m_supportsAlpha = a;
467     invalidate(m_rect);
468 }
469
470 }
471
472 #endif