1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
/*
Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef WebGraphicsLayer_h
#define WebGraphicsLayer_h
#include "FloatPoint3D.h"
#include "GraphicsLayer.h"
#include "GraphicsLayerTransform.h"
#include "Image.h"
#include "IntSize.h"
#include "ShareableBitmap.h"
#include "TiledBackingStore.h"
#include "TiledBackingStoreClient.h"
#include "TiledBackingStoreRemoteTile.h"
#include "TransformationMatrix.h"
#include "UpdateInfo.h"
#include "WebLayerTreeInfo.h"
#include "WebProcess.h"
#include <WebCore/RunLoop.h>
#include <wtf/text/StringHash.h>
#if USE(UI_SIDE_COMPOSITING)
namespace WebCore {
class WebGraphicsLayer;
}
namespace WebKit {
class WebGraphicsLayerClient {
public:
// TiledBackingStoreRemoteTileClient
virtual void createTile(WebLayerID, int tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
virtual void updateTile(WebLayerID, int tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
virtual void removeTile(WebLayerID, int tileID) = 0;
virtual WebCore::IntRect visibleContentsRect() const = 0;
virtual bool layerTreeTileUpdatesAllowed() const = 0;
virtual int64_t adoptImageBackingStore(WebCore::Image*) = 0;
virtual void releaseImageBackingStore(int64_t) = 0;
virtual void syncLayerState(WebLayerID, const WebLayerInfo&) = 0;
virtual void syncLayerChildren(WebLayerID, const Vector<WebLayerID>&) = 0;
#if ENABLE(CSS_FILTERS)
virtual void syncLayerFilters(WebLayerID, const WebCore::FilterOperations&) = 0;
#endif
#if PLATFORM(QT)
virtual void syncCanvas(WebLayerID, const WebCore::IntSize& canvasSize, uint32_t graphicsSurfaceToken) = 0;
#endif
virtual void attachLayer(WebCore::WebGraphicsLayer*) = 0;
virtual void detachLayer(WebCore::WebGraphicsLayer*) = 0;
virtual void syncFixedLayers() = 0;
virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableBitmap::Flags, ShareableSurface::Handle&, WebCore::IntPoint&) = 0;
};
}
namespace WebCore {
class WebGraphicsLayer : public WebCore::GraphicsLayer
, public TiledBackingStoreClient
, public WebKit::TiledBackingStoreRemoteTileClient {
public:
WebGraphicsLayer(GraphicsLayerClient*);
virtual ~WebGraphicsLayer();
// Reimplementations from GraphicsLayer.h.
bool setChildren(const Vector<GraphicsLayer*>&);
void addChild(GraphicsLayer*);
void addChildAtIndex(GraphicsLayer*, int);
void addChildAbove(GraphicsLayer*, GraphicsLayer*);
void addChildBelow(GraphicsLayer*, GraphicsLayer*);
bool replaceChild(GraphicsLayer*, GraphicsLayer*);
void removeFromParent();
void setPosition(const FloatPoint&);
void setAnchorPoint(const FloatPoint3D&);
void setSize(const FloatSize&);
void setTransform(const TransformationMatrix&);
void setChildrenTransform(const TransformationMatrix&);
void setPreserves3D(bool);
void setMasksToBounds(bool);
void setDrawsContent(bool);
void setContentsOpaque(bool);
void setBackfaceVisibility(bool);
void setOpacity(float);
void setContentsRect(const IntRect&);
void setContentsToImage(Image*);
void setContentsToCanvas(PlatformLayer*);
void setMaskLayer(GraphicsLayer*);
void setReplicatedByLayer(GraphicsLayer*);
void setNeedsDisplay();
void setNeedsDisplayInRect(const FloatRect&);
void setContentsNeedsDisplay();
void setContentsScale(float);
void setVisibleContentRectTrajectoryVector(const FloatPoint&);
virtual void syncCompositingState(const FloatRect&);
virtual void syncCompositingStateForThisLayerOnly();
#if ENABLE(CSS_FILTERS)
bool setFilters(const FilterOperations&);
#endif
void setRootLayer(bool);
WebKit::WebLayerID id() const;
static WebGraphicsLayer* layerByID(WebKit::WebLayerID);
void didSynchronize();
Image* image() { return m_image.get(); }
bool fixedToViewport() const { return m_fixedToViewport; }
void setFixedToViewport(bool isFixed) { m_fixedToViewport = isFixed; }
GraphicsLayer* maskTarget() const { return m_maskTarget; }
void setMaskTarget(GraphicsLayer* layer) { m_maskTarget = layer; }
static void initFactory();
// TiledBackingStoreClient
virtual void tiledBackingStorePaintBegin();
virtual void tiledBackingStorePaint(GraphicsContext*, const IntRect&);
virtual void tiledBackingStorePaintEnd(const Vector<IntRect>& paintedArea);
virtual bool tiledBackingStoreUpdatesAllowed() const;
virtual IntRect tiledBackingStoreContentsRect();
virtual IntRect tiledBackingStoreVisibleRect();
virtual Color tiledBackingStoreBackgroundColor() const;
// TiledBackingStoreRemoteTileClient
virtual void createTile(int tileID, const WebKit::SurfaceUpdateInfo&, const WebCore::IntRect&);
virtual void updateTile(int tileID, const WebKit::SurfaceUpdateInfo&, const WebCore::IntRect&);
virtual void removeTile(int tileID);
virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, WebKit::ShareableSurface::Handle&, WebCore::IntPoint&);
void setWebGraphicsLayerClient(WebKit::WebGraphicsLayerClient*);
void syncChildren();
void syncLayerState();
#if ENABLE(CSS_FILTERS)
void syncFilters();
#endif
void syncCanvas();
void ensureImageBackingStore();
void adjustVisibleRect();
bool isReadyForTileBufferSwap() const;
void updateContentBuffers();
void purgeBackingStores();
private:
virtual void willBeDestroyed();
WebKit::WebLayerID m_id;
WebKit::WebLayerInfo m_layerInfo;
RefPtr<Image> m_image;
GraphicsLayer* m_maskTarget;
FloatRect m_needsDisplayRect;
GraphicsLayerTransform m_layerTransform;
bool m_inUpdateMode : 1;
bool m_shouldUpdateVisibleRect: 1;
bool m_shouldSyncLayerState: 1;
bool m_shouldSyncChildren: 1;
bool m_shouldSyncFilters: 1;
bool m_fixedToViewport : 1;
bool m_canvasNeedsDisplay : 1;
void notifyChange();
void didChangeGeometry();
void didChangeLayerState();
void didChangeChildren();
#if ENABLE(CSS_FILTERS)
void didChangeFilters();
#endif
void createBackingStore();
bool selfOrAncestorHaveNonAffineTransforms();
bool shouldUseTiledBackingStore();
void adjustContentsScale();
void computeTransformedVisibleRect();
void syncLayerParameters();
void setShouldUpdateVisibleRect();
float effectiveContentsScale();
WebKit::WebGraphicsLayerClient* m_webGraphicsLayerClient;
OwnPtr<WebCore::TiledBackingStore> m_mainBackingStore;
OwnPtr<WebCore::TiledBackingStore> m_previousBackingStore;
float m_contentsScale;
PlatformLayer* m_canvasPlatformLayer;
};
WebGraphicsLayer* toWebGraphicsLayer(GraphicsLayer*);
}
#endif
#endif // WebGraphicsLayer_H
|
