Reduce PassRefPtr in WebKit2 - 3
[WebKit-https.git] / Source / WebKit2 / Shared / CoordinatedGraphics / CoordinatedBackingStore.cpp
1 /*
2  Copyright (C) 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 "CoordinatedBackingStore.h"
22
23 #if USE(COORDINATED_GRAPHICS)
24 #include <WebCore/CoordinatedSurface.h>
25 #include <WebCore/GraphicsLayer.h>
26 #include <WebCore/TextureMapper.h>
27 #include <WebCore/TextureMapperGL.h>
28
29 using namespace WebCore;
30
31 namespace WebKit {
32
33 void CoordinatedBackingStoreTile::swapBuffers(TextureMapper* textureMapper)
34 {
35     if (!m_surface)
36         return;
37
38     FloatRect tileRect(m_tileRect);
39     tileRect.scale(1. / m_scale);
40     bool shouldReset = false;
41     if (tileRect != rect()) {
42         setRect(tileRect);
43         shouldReset = true;
44     }
45     RefPtr<BitmapTexture> texture = this->texture();
46     if (!texture) {
47         texture = textureMapper->createTexture();
48         setTexture(texture.get());
49         shouldReset = true;
50     }
51
52     ASSERT(textureMapper->maxTextureSize().width() >= m_tileRect.size().width());
53     ASSERT(textureMapper->maxTextureSize().height() >= m_tileRect.size().height());
54     if (shouldReset)
55         texture->reset(m_tileRect.size(), m_surface->supportsAlpha());
56
57     m_surface->copyToTexture(texture, m_sourceRect, m_surfaceOffset);
58     m_surface = nullptr;
59 }
60
61 void CoordinatedBackingStoreTile::setBackBuffer(const IntRect& tileRect, const IntRect& sourceRect, PassRefPtr<CoordinatedSurface> buffer, const IntPoint& offset)
62 {
63     m_sourceRect = sourceRect;
64     m_tileRect = tileRect;
65     m_surfaceOffset = offset;
66     m_surface = buffer;
67 }
68
69 void CoordinatedBackingStore::createTile(uint32_t id, float scale)
70 {
71     m_tiles.add(id, CoordinatedBackingStoreTile(scale));
72     m_scale = scale;
73 }
74
75 void CoordinatedBackingStore::removeTile(uint32_t id)
76 {
77     ASSERT(m_tiles.contains(id));
78     m_tilesToRemove.add(id);
79 }
80
81 void CoordinatedBackingStore::removeAllTiles()
82 {
83     for (auto& key : m_tiles.keys())
84         m_tilesToRemove.add(key);
85 }
86
87 void CoordinatedBackingStore::updateTile(uint32_t id, const IntRect& sourceRect, const IntRect& tileRect, PassRefPtr<CoordinatedSurface> backBuffer, const IntPoint& offset)
88 {
89     CoordinatedBackingStoreTileMap::iterator it = m_tiles.find(id);
90     ASSERT(it != m_tiles.end());
91     it->value.setBackBuffer(tileRect, sourceRect, backBuffer, offset);
92 }
93
94 RefPtr<BitmapTexture> CoordinatedBackingStore::texture() const
95 {
96     for (auto& tile : m_tiles.values()) {
97         RefPtr<BitmapTexture> texture = tile.texture();
98         if (texture)
99             return texture;
100     }
101
102     return RefPtr<BitmapTexture>();
103 }
104
105 void CoordinatedBackingStore::setSize(const FloatSize& size)
106 {
107     m_pendingSize = size;
108 }
109
110 void CoordinatedBackingStore::paintTilesToTextureMapper(Vector<TextureMapperTile*>& tiles, TextureMapper* textureMapper, const TransformationMatrix& transform, float opacity, const FloatRect& rect)
111 {
112     for (auto& tile : tiles)
113         tile->paint(textureMapper, transform, opacity, calculateExposedTileEdges(rect, tile->rect()));
114 }
115
116 TransformationMatrix CoordinatedBackingStore::adjustedTransformForRect(const FloatRect& targetRect)
117 {
118     return TransformationMatrix::rectToRect(rect(), targetRect);
119 }
120
121 void CoordinatedBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)
122 {
123     if (m_tiles.isEmpty())
124         return;
125     ASSERT(!m_size.isZero());
126
127     Vector<TextureMapperTile*> tilesToPaint;
128     Vector<TextureMapperTile*> previousTilesToPaint;
129
130     // We have to do this every time we paint, in case the opacity has changed.
131     FloatRect coveredRect;
132     for (auto& tile : m_tiles.values()) {
133         if (!tile.texture())
134             continue;
135
136         if (tile.scale() == m_scale) {
137             tilesToPaint.append(&tile);
138             coveredRect.unite(tile.rect());
139             continue;
140         }
141
142         // Only show the previous tile if the opacity is high, otherwise effect looks like a bug.
143         // We show the previous-scale tile anyway if it doesn't intersect with any current-scale tile.
144         if (opacity < 0.95 && coveredRect.intersects(tile.rect()))
145             continue;
146
147         previousTilesToPaint.append(&tile);
148     }
149
150     // targetRect is on the contents coordinate system, so we must compare two rects on the contents coordinate system.
151     // See TiledBackingStore.
152     TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
153
154     paintTilesToTextureMapper(previousTilesToPaint, textureMapper, adjustedTransform, opacity, rect());
155     paintTilesToTextureMapper(tilesToPaint, textureMapper, adjustedTransform, opacity, rect());
156 }
157
158 void CoordinatedBackingStore::drawBorder(TextureMapper* textureMapper, const Color& borderColor, float borderWidth, const FloatRect& targetRect, const TransformationMatrix& transform)
159 {
160     TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
161     for (auto& tile : m_tiles.values())
162         textureMapper->drawBorder(borderColor, borderWidth, tile.rect(), adjustedTransform);
163 }
164
165 void CoordinatedBackingStore::drawRepaintCounter(TextureMapper* textureMapper, int repaintCount, const Color& borderColor, const FloatRect& targetRect, const TransformationMatrix& transform)
166 {
167     TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
168     for (auto& tile : m_tiles.values())
169         textureMapper->drawNumber(repaintCount, borderColor, tile.rect().location(), adjustedTransform);
170 }
171
172 void CoordinatedBackingStore::commitTileOperations(TextureMapper* textureMapper)
173 {
174     if (!m_pendingSize.isZero()) {
175         m_size = m_pendingSize;
176         m_pendingSize = FloatSize();
177     }
178
179     for (auto& tileToRemove : m_tilesToRemove)
180         m_tiles.remove(tileToRemove);
181     m_tilesToRemove.clear();
182
183     for (auto& tile : m_tiles.values())
184         tile.swapBuffers(textureMapper);
185 }
186
187 } // namespace WebCore
188 #endif // USE(COORDINATED_GRAPHICS)