[CoordGraphics] TiledBackingStore unnecessarily tracks alpha support value
[WebKit-https.git] / Source / WebCore / platform / graphics / texmap / coordinated / 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(COORDINATED_GRAPHICS)
24 #include "GraphicsContext.h"
25 #include "TiledBackingStoreClient.h"
26 #include <wtf/CheckedArithmetic.h>
27 #include <wtf/MemoryPressureHandler.h>
28
29 namespace WebCore {
30
31 static const int defaultTileDimension = 512;
32
33 static IntPoint innerBottomRight(const IntRect& rect)
34 {
35     // Actually, the rect does not contain rect.maxX(). Refer to IntRect::contain.
36     return IntPoint(rect.maxX() - 1, rect.maxY() - 1);
37 }
38
39 TiledBackingStore::TiledBackingStore(TiledBackingStoreClient& client, float contentsScale)
40     : m_client(client)
41     , m_tileSize(defaultTileDimension, defaultTileDimension)
42     , m_coverAreaMultiplier(2.0f)
43     , m_contentsScale(contentsScale)
44     , m_pendingTileCreation(false)
45 {
46 }
47
48 TiledBackingStore::~TiledBackingStore() = default;
49
50 void TiledBackingStore::setTrajectoryVector(const FloatPoint& trajectoryVector)
51 {
52     m_pendingTrajectoryVector = trajectoryVector;
53     m_pendingTrajectoryVector.normalize();
54 }
55
56 void TiledBackingStore::createTilesIfNeeded(const IntRect& unscaledVisibleRect, const IntRect& contentsRect)
57 {
58     IntRect scaledContentsRect = mapFromContents(contentsRect);
59     IntRect visibleRect = mapFromContents(unscaledVisibleRect);
60     float coverAreaMultiplier = MemoryPressureHandler::singleton().isUnderMemoryPressure() ? 1.0f : 2.0f;
61
62     bool didChange = m_trajectoryVector != m_pendingTrajectoryVector || m_visibleRect != visibleRect || m_rect != scaledContentsRect || m_coverAreaMultiplier != coverAreaMultiplier;
63     if (didChange || m_pendingTileCreation)
64         createTiles(visibleRect, scaledContentsRect, coverAreaMultiplier);
65 }
66
67 void TiledBackingStore::invalidate(const IntRect& contentsDirtyRect)
68 {
69     IntRect dirtyRect(mapFromContents(contentsDirtyRect));
70     IntRect keepRectFitToTileSize = tileRectForCoordinate(tileCoordinateForPoint(m_keepRect.location()));
71     keepRectFitToTileSize.unite(tileRectForCoordinate(tileCoordinateForPoint(innerBottomRight(m_keepRect))));
72
73     // Only iterate on the part of the rect that we know we might have tiles.
74     IntRect coveredDirtyRect = intersection(dirtyRect, keepRectFitToTileSize);
75     Tile::Coordinate topLeft = tileCoordinateForPoint(coveredDirtyRect.location());
76     Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(coveredDirtyRect));
77
78     for (int yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
79         for (int xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
80             Tile* currentTile = m_tiles.get(Tile::Coordinate(xCoordinate, yCoordinate));
81             if (!currentTile)
82                 continue;
83             // Pass the full rect to each tile as coveredDirtyRect might not
84             // contain them completely and we don't want partial tile redraws.
85             currentTile->invalidate(dirtyRect);
86         }
87     }
88 }
89
90 Vector<std::reference_wrapper<Tile>> TiledBackingStore::dirtyTiles()
91 {
92     Vector<std::reference_wrapper<Tile>> tiles;
93     for (auto& tile : m_tiles.values()) {
94         if (tile->isDirty())
95             tiles.append(*tile);
96     }
97
98     return tiles;
99 }
100
101 double TiledBackingStore::tileDistance(const IntRect& viewport, const Tile::Coordinate& tileCoordinate) const
102 {
103     if (viewport.intersects(tileRectForCoordinate(tileCoordinate)))
104         return 0;
105
106     IntPoint viewCenter = viewport.location() + IntSize(viewport.width() / 2, viewport.height() / 2);
107     Tile::Coordinate centerCoordinate = tileCoordinateForPoint(viewCenter);
108
109     return std::max(abs(centerCoordinate.y() - tileCoordinate.y()), abs(centerCoordinate.x() - tileCoordinate.x()));
110 }
111
112 // Returns a ratio between 0.0f and 1.0f of the surface covered by rendered tiles.
113 float TiledBackingStore::coverageRatio(const WebCore::IntRect& dirtyRect) const
114 {
115     float rectArea = dirtyRect.width() * dirtyRect.height();
116     float coverArea = 0.0f;
117
118     Tile::Coordinate topLeft = tileCoordinateForPoint(dirtyRect.location());
119     Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(dirtyRect));
120
121     for (int yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
122         for (int xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
123             Tile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
124             Tile* currentTile = m_tiles.get(currentCoordinate);
125             if (currentTile && currentTile->isReadyToPaint()) {
126                 IntRect coverRect = intersection(dirtyRect, currentTile->rect());
127                 coverArea += coverRect.width() * coverRect.height();
128             }
129         }
130     }
131     return coverArea / rectArea;
132 }
133
134 bool TiledBackingStore::visibleAreaIsCovered() const
135 {
136     return coverageRatio(intersection(m_visibleRect, m_rect)) == 1.0f;
137 }
138
139 void TiledBackingStore::createTiles(const IntRect& visibleRect, const IntRect& scaledContentsRect, float coverAreaMultiplier)
140 {
141     // Update our backing store geometry.
142     const IntRect previousRect = m_rect;
143     m_rect = scaledContentsRect;
144     m_trajectoryVector = m_pendingTrajectoryVector;
145     m_visibleRect = visibleRect;
146     m_coverAreaMultiplier = coverAreaMultiplier;
147
148     if (m_rect.isEmpty()) {
149         setCoverRect(IntRect());
150         setKeepRect(IntRect());
151         return;
152     }
153
154     /* We must compute cover and keep rects using the visibleRect, instead of the rect intersecting the visibleRect with m_rect,
155      * because TBS can be used as a backing store of GraphicsLayer and the visible rect usually does not intersect with m_rect.
156      * In the below case, the intersecting rect is an empty.
157      *
158      *  +---------------+
159      *  |               |
160      *  |   m_rect      |
161      *  |       +-------|-----------------------+
162      *  |       | HERE  |  cover or keep        |
163      *  +---------------+      rect             |
164      *          |         +---------+           |
165      *          |         | visible |           |
166      *          |         |  rect   |           |
167      *          |         +---------+           |
168      *          |                               |
169      *          |                               |
170      *          +-------------------------------+
171      *
172      * We must create or keep the tiles in the HERE region.
173      */
174
175     IntRect coverRect;
176     IntRect keepRect;
177     computeCoverAndKeepRect(m_visibleRect, coverRect, keepRect);
178
179     setCoverRect(coverRect);
180     setKeepRect(keepRect);
181
182     if (coverRect.isEmpty())
183         return;
184
185     // Resize tiles at the edge in case the contents size has changed, but only do so
186     // after having dropped tiles outside the keep rect.
187     if (previousRect != m_rect)
188         resizeEdgeTiles();
189
190     // Search for the tile position closest to the viewport center that does not yet contain a tile.
191     // Which position is considered the closest depends on the tileDistance function.
192     double shortestDistance = std::numeric_limits<double>::infinity();
193     Vector<Tile::Coordinate> tilesToCreate;
194     unsigned requiredTileCount = 0;
195
196     // Cover areas (in tiles) with minimum distance from the visible rect. If the visible rect is
197     // not covered already it will be covered first in one go, due to the distance being 0 for tiles
198     // inside the visible rect.
199     Tile::Coordinate topLeft = tileCoordinateForPoint(coverRect.location());
200     Tile::Coordinate bottomRight = tileCoordinateForPoint(innerBottomRight(coverRect));
201     for (int yCoordinate = topLeft.y(); yCoordinate <= bottomRight.y(); ++yCoordinate) {
202         for (int xCoordinate = topLeft.x(); xCoordinate <= bottomRight.x(); ++xCoordinate) {
203             Tile::Coordinate currentCoordinate(xCoordinate, yCoordinate);
204             if (m_tiles.contains(currentCoordinate))
205                 continue;
206             ++requiredTileCount;
207             double distance = tileDistance(m_visibleRect, currentCoordinate);
208             if (distance > shortestDistance)
209                 continue;
210             if (distance < shortestDistance) {
211                 tilesToCreate.clear();
212                 shortestDistance = distance;
213             }
214             tilesToCreate.append(currentCoordinate);
215         }
216     }
217
218     // Now construct the tile(s) within the shortest distance.
219     unsigned tilesToCreateCount = tilesToCreate.size();
220     for (unsigned n = 0; n < tilesToCreateCount; ++n) {
221         Tile::Coordinate coordinate = tilesToCreate[n];
222         m_tiles.add(coordinate, std::make_unique<Tile>(*this, coordinate));
223     }
224     requiredTileCount -= tilesToCreateCount;
225
226     // Re-call createTiles on a timer to cover the visible area with the newest shortest distance.
227     m_pendingTileCreation = requiredTileCount;
228     if (m_pendingTileCreation)
229         m_client.tiledBackingStoreHasPendingTileCreation();
230 }
231
232 void TiledBackingStore::adjustForContentsRect(IntRect& rect) const
233 {
234     IntRect bounds = m_rect;
235     IntSize candidateSize = rect.size();
236
237     rect.intersect(bounds);
238
239     if (rect.size() == candidateSize)
240         return;
241
242     /*
243      * In the following case, there is no intersection of the contents rect and the cover rect.
244      * Thus the latter should not be inflated.
245      *
246      *  +---------------+
247      *  |   m_rect      |
248      *  +---------------+
249      *
250      *          +-------------------------------+
251      *          |          cover rect           |
252      *          |         +---------+           |
253      *          |         | visible |           |
254      *          |         |  rect   |           |
255      *          |         +---------+           |
256      *          +-------------------------------+
257      */
258     if (rect.isEmpty())
259         return;
260
261     // Try to create a cover rect of the same size as the candidate, but within content bounds.
262     int pixelsCovered = 0;
263     if (!WTF::safeMultiply(candidateSize.width(), candidateSize.height(), pixelsCovered))
264         pixelsCovered = std::numeric_limits<int>::max();
265
266     if (rect.width() < candidateSize.width())
267         rect.inflateY(((pixelsCovered / rect.width()) - rect.height()) / 2);
268     if (rect.height() < candidateSize.height())
269         rect.inflateX(((pixelsCovered / rect.height()) - rect.width()) / 2);
270
271     rect.intersect(bounds);
272 }
273
274 void TiledBackingStore::computeCoverAndKeepRect(const IntRect& visibleRect, IntRect& coverRect, IntRect& keepRect) const
275 {
276     coverRect = visibleRect;
277     keepRect = visibleRect;
278
279     // If we cover more that the actual viewport we can be smart about which tiles we choose to render.
280     if (m_coverAreaMultiplier > 1) {
281         // The initial cover area covers equally in each direction, according to the coverAreaMultiplier.
282         coverRect.inflateX(visibleRect.width() * (m_coverAreaMultiplier - 1) / 2);
283         coverRect.inflateY(visibleRect.height() * (m_coverAreaMultiplier - 1) / 2);
284         keepRect = coverRect;
285
286         if (m_trajectoryVector != FloatPoint::zero()) {
287             // A null trajectory vector (no motion) means that tiles for the coverArea will be created.
288             // A non-null trajectory vector will shrink the covered rect to visibleRect plus its expansion from its
289             // center toward the cover area edges in the direction of the given vector.
290
291             // E.g. if visibleRect == (10,10)5x5 and coverAreaMultiplier == 3.0:
292             // a (0,0) trajectory vector will create tiles intersecting (5,5)15x15,
293             // a (1,0) trajectory vector will create tiles intersecting (10,10)10x5,
294             // and a (1,1) trajectory vector will create tiles intersecting (10,10)10x10.
295
296             // Multiply the vector by the distance to the edge of the cover area.
297             float trajectoryVectorMultiplier = (m_coverAreaMultiplier - 1) / 2;
298
299             // Unite the visible rect with a "ghost" of the visible rect moved in the direction of the trajectory vector.
300             coverRect = visibleRect;
301             coverRect.move(coverRect.width() * m_trajectoryVector.x() * trajectoryVectorMultiplier, coverRect.height() * m_trajectoryVector.y() * trajectoryVectorMultiplier);
302
303             coverRect.unite(visibleRect);
304         }
305         ASSERT(keepRect.contains(coverRect));
306     }
307
308     adjustForContentsRect(coverRect);
309
310     // The keep rect is an inflated version of the cover rect, inflated in tile dimensions.
311     keepRect.unite(coverRect);
312     keepRect.inflateX(m_tileSize.width() / 2);
313     keepRect.inflateY(m_tileSize.height() / 2);
314     keepRect.intersect(m_rect);
315
316     ASSERT(coverRect.isEmpty() || keepRect.contains(coverRect));
317 }
318
319 void TiledBackingStore::resizeEdgeTiles()
320 {
321     Vector<Tile::Coordinate> tilesToRemove;
322     for (auto& tile : m_tiles.values()) {
323         Tile::Coordinate tileCoordinate = tile->coordinate();
324         IntRect tileRect = tile->rect();
325         IntRect expectedTileRect = tileRectForCoordinate(tileCoordinate);
326         if (expectedTileRect.isEmpty())
327             tilesToRemove.append(tileCoordinate);
328         else if (expectedTileRect != tileRect)
329             tile->resize(expectedTileRect.size());
330     }
331
332     for (auto& coordinateToRemove : tilesToRemove)
333         m_tiles.remove(coordinateToRemove);
334 }
335
336 void TiledBackingStore::setKeepRect(const IntRect& keepRect)
337 {
338     // Drop tiles outside the new keepRect.
339
340     FloatRect keepRectF = keepRect;
341
342     Vector<Tile::Coordinate> toRemove;
343     for (auto& tile : m_tiles.values()) {
344         Tile::Coordinate coordinate = tile->coordinate();
345         FloatRect tileRect = tile->rect();
346         if (!tileRect.intersects(keepRectF))
347             toRemove.append(coordinate);
348     }
349
350     for (auto& coordinateToRemove : toRemove)
351         m_tiles.remove(coordinateToRemove);
352
353     m_keepRect = keepRect;
354 }
355
356 void TiledBackingStore::removeAllNonVisibleTiles(const IntRect& unscaledVisibleRect, const IntRect& contentsRect)
357 {
358     IntRect boundedVisibleRect = mapFromContents(intersection(unscaledVisibleRect, contentsRect));
359     setKeepRect(boundedVisibleRect);
360 }
361
362 IntRect TiledBackingStore::mapToContents(const IntRect& rect) const
363 {
364     return enclosingIntRect(FloatRect(rect.x() / m_contentsScale,
365         rect.y() / m_contentsScale,
366         rect.width() / m_contentsScale,
367         rect.height() / m_contentsScale));
368 }
369
370 IntRect TiledBackingStore::mapFromContents(const IntRect& rect) const
371 {
372     return enclosingIntRect(FloatRect(rect.x() * m_contentsScale,
373         rect.y() * m_contentsScale,
374         rect.width() * m_contentsScale,
375         rect.height() * m_contentsScale));
376 }
377
378 IntRect TiledBackingStore::tileRectForCoordinate(const Tile::Coordinate& coordinate) const
379 {
380     IntRect rect(coordinate.x() * m_tileSize.width(),
381         coordinate.y() * m_tileSize.height(),
382         m_tileSize.width(),
383         m_tileSize.height());
384
385     rect.intersect(m_rect);
386     return rect;
387 }
388
389 Tile::Coordinate TiledBackingStore::tileCoordinateForPoint(const IntPoint& point) const
390 {
391     int x = point.x() / m_tileSize.width();
392     int y = point.y() / m_tileSize.height();
393     return Tile::Coordinate(std::max(x, 0), std::max(y, 0));
394 }
395
396 }
397
398 #endif