[chromium] Remove alwaysReserveTextures code - it doesn't do anything
[WebKit-https.git] / Source / WebKit / chromium / src / WebLayer.cpp
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include <public/WebLayer.h>
28
29 #include "LayerChromium.h"
30 #include "SkMatrix44.h"
31 #include "WebAnimationImpl.h"
32 #include "WebLayerImpl.h"
33 #include <public/WebFilterOperations.h>
34 #include <public/WebFloatPoint.h>
35 #include <public/WebFloatRect.h>
36 #include <public/WebSize.h>
37 #include <public/WebTransformationMatrix.h>
38
39 using namespace WebCore;
40 using WebKit::WebTransformationMatrix;
41
42 namespace {
43
44 WebTransformationMatrix transformationMatrixFromSkMatrix44(const SkMatrix44& matrix)
45 {
46     double data[16];
47     matrix.asColMajord(data);
48     return WebTransformationMatrix(data[0], data[1], data[2], data[3],
49                                    data[4], data[5], data[6], data[7],
50                                    data[8], data[9], data[10], data[11],
51                                    data[12], data[13], data[14], data[15]);
52 }
53
54 SkMatrix44 skMatrix44FromTransformationMatrix(const WebTransformationMatrix& matrix)
55 {
56     SkMatrix44 skMatrix;
57     skMatrix.set(0, 0, SkDoubleToMScalar(matrix.m11()));
58     skMatrix.set(1, 0, SkDoubleToMScalar(matrix.m12()));
59     skMatrix.set(2, 0, SkDoubleToMScalar(matrix.m13()));
60     skMatrix.set(3, 0, SkDoubleToMScalar(matrix.m14()));
61     skMatrix.set(0, 1, SkDoubleToMScalar(matrix.m21()));
62     skMatrix.set(1, 1, SkDoubleToMScalar(matrix.m22()));
63     skMatrix.set(2, 1, SkDoubleToMScalar(matrix.m23()));
64     skMatrix.set(3, 1, SkDoubleToMScalar(matrix.m24()));
65     skMatrix.set(0, 2, SkDoubleToMScalar(matrix.m31()));
66     skMatrix.set(1, 2, SkDoubleToMScalar(matrix.m32()));
67     skMatrix.set(2, 2, SkDoubleToMScalar(matrix.m33()));
68     skMatrix.set(3, 2, SkDoubleToMScalar(matrix.m34()));
69     skMatrix.set(0, 3, SkDoubleToMScalar(matrix.m41()));
70     skMatrix.set(1, 3, SkDoubleToMScalar(matrix.m42()));
71     skMatrix.set(2, 3, SkDoubleToMScalar(matrix.m43()));
72     skMatrix.set(3, 3, SkDoubleToMScalar(matrix.m44()));
73     return skMatrix;
74 }
75
76 } // anonymous namespace
77
78 namespace WebKit {
79
80 WebLayer WebLayer::create()
81 {
82     return WebLayer(WebLayerImpl::create());
83 }
84
85 void WebLayer::reset()
86 {
87     m_private.reset();
88 }
89
90 void WebLayer::assign(const WebLayer& other)
91 {
92     m_private = other.m_private;
93 }
94
95 bool WebLayer::equals(const WebLayer& n) const
96 {
97     return (m_private.get() == n.m_private.get());
98 }
99
100 void WebLayer::invalidateRect(const WebFloatRect& dirtyRect)
101 {
102     m_private->setNeedsDisplayRect(dirtyRect);
103 }
104
105 void WebLayer::invalidate()
106 {
107     m_private->setNeedsDisplay();
108 }
109
110 WebLayer WebLayer::rootLayer() const
111 {
112     return WebLayer(const_cast<LayerChromium*>(m_private->rootLayer()));
113 }
114
115 WebLayer WebLayer::parent() const
116 {
117     return WebLayer(const_cast<LayerChromium*>(m_private->parent()));
118 }
119
120 size_t WebLayer::numberOfChildren() const
121 {
122     return m_private->children().size();
123 }
124
125 WebLayer WebLayer::childAt(size_t index) const
126 {
127     return WebLayer(m_private->children()[index]);
128 }
129
130 void WebLayer::addChild(const WebLayer& child)
131 {
132     m_private->addChild(child);
133 }
134
135 void WebLayer::insertChild(const WebLayer& child, size_t index)
136 {
137     m_private->insertChild(child, index);
138 }
139
140 void WebLayer::replaceChild(const WebLayer& reference, const WebLayer& newLayer)
141 {
142     WebLayer ref = reference;
143     m_private->replaceChild(ref.unwrap<LayerChromium>(), newLayer);
144 }
145
146 void WebLayer::setChildren(const WebVector<WebLayer>& webChildren)
147 {
148     Vector<RefPtr<LayerChromium> > children(webChildren.size());
149     for (size_t i = 0; i < webChildren.size(); ++i)
150         children[i] = webChildren[i].unwrap<LayerChromium>();
151     m_private->setChildren(children);
152 }
153
154 void WebLayer::removeFromParent()
155 {
156     m_private->removeFromParent();
157 }
158
159 void WebLayer::removeAllChildren()
160 {
161     m_private->removeAllChildren();
162 }
163
164 void WebLayer::setAnchorPoint(const WebFloatPoint& anchorPoint)
165 {
166     m_private->setAnchorPoint(anchorPoint);
167 }
168
169 WebFloatPoint WebLayer::anchorPoint() const
170 {
171     return WebFloatPoint(m_private->anchorPoint());
172 }
173
174 void WebLayer::setAnchorPointZ(float anchorPointZ)
175 {
176     m_private->setAnchorPointZ(anchorPointZ);
177 }
178
179 float WebLayer::anchorPointZ() const
180 {
181     return m_private->anchorPointZ();
182 }
183
184 void WebLayer::setBounds(const WebSize& size)
185 {
186     m_private->setBounds(size);
187 }
188
189 WebSize WebLayer::bounds() const
190 {
191     return WebSize(m_private->bounds());
192 }
193
194 void WebLayer::setMasksToBounds(bool masksToBounds)
195 {
196     m_private->setMasksToBounds(masksToBounds);
197 }
198
199 bool WebLayer::masksToBounds() const
200 {
201     return m_private->masksToBounds();
202 }
203
204 void WebLayer::setMaskLayer(const WebLayer& maskLayer)
205 {
206     WebLayer ref = maskLayer;
207     m_private->setMaskLayer(ref.unwrap<LayerChromium>());
208 }
209
210 WebLayer WebLayer::maskLayer() const
211 {
212     return WebLayer(m_private->maskLayer());
213 }
214
215 void WebLayer::setReplicaLayer(const WebLayer& replicaLayer)
216 {
217     WebLayer ref = replicaLayer;
218     m_private->setReplicaLayer(ref.unwrap<LayerChromium>());
219 }
220
221 void WebLayer::setOpacity(float opacity)
222 {
223     m_private->setOpacity(opacity);
224 }
225
226 float WebLayer::opacity() const
227 {
228     return m_private->opacity();
229 }
230
231 void WebLayer::setOpaque(bool opaque)
232 {
233     m_private->setOpaque(opaque);
234 }
235
236 bool WebLayer::opaque() const
237 {
238     return m_private->opaque();
239 }
240
241 void WebLayer::setPosition(const WebFloatPoint& position)
242 {
243     m_private->setPosition(position);
244 }
245
246 WebFloatPoint WebLayer::position() const
247 {
248     return WebFloatPoint(m_private->position());
249 }
250
251 void WebLayer::setSublayerTransform(const SkMatrix44& matrix)
252 {
253     m_private->setSublayerTransform(transformationMatrixFromSkMatrix44(matrix));
254 }
255
256 void WebLayer::setSublayerTransform(const WebTransformationMatrix& matrix)
257 {
258     m_private->setSublayerTransform(matrix);
259 }
260
261 SkMatrix44 WebLayer::sublayerTransform() const
262 {
263     return skMatrix44FromTransformationMatrix(m_private->sublayerTransform());
264 }
265
266 void WebLayer::setTransform(const SkMatrix44& matrix)
267 {
268     m_private->setTransform(transformationMatrixFromSkMatrix44(matrix));
269 }
270
271 void WebLayer::setTransform(const WebTransformationMatrix& matrix)
272 {
273     m_private->setTransform(matrix);
274 }
275
276 SkMatrix44 WebLayer::transform() const
277 {
278     return skMatrix44FromTransformationMatrix(m_private->transform());
279 }
280
281 void WebLayer::setDrawsContent(bool drawsContent)
282 {
283     m_private->setIsDrawable(drawsContent);
284 }
285
286 bool WebLayer::drawsContent() const
287 {
288     return m_private->drawsContent();
289 }
290
291 void WebLayer::setPreserves3D(bool preserve3D)
292 {
293     m_private->setPreserves3D(preserve3D);
294 }
295
296 void WebLayer::setUseParentBackfaceVisibility(bool useParentBackfaceVisibility)
297 {
298     m_private->setUseParentBackfaceVisibility(useParentBackfaceVisibility);
299 }
300
301 void WebLayer::setBackgroundColor(WebColor color)
302 {
303     m_private->setBackgroundColor(color);
304 }
305
306 void WebLayer::setFilters(const WebFilterOperations& filters)
307 {
308     m_private->setFilters(filters);
309 }
310
311 void WebLayer::setBackgroundFilters(const WebFilterOperations& filters)
312 {
313     m_private->setBackgroundFilters(filters);
314 }
315
316 void WebLayer::setDebugBorderColor(const WebColor& color)
317 {
318     m_private->setDebugBorderColor(color);
319 }
320
321 void WebLayer::setDebugBorderWidth(float width)
322 {
323     m_private->setDebugBorderWidth(width);
324 }
325
326 void WebLayer::setDebugName(WebString name)
327 {
328     m_private->setDebugName(name);
329 }
330
331 void WebLayer::setAnimationDelegate(WebAnimationDelegate* delegate)
332 {
333     m_private->setLayerAnimationDelegate(delegate);
334 }
335
336 bool WebLayer::addAnimation(WebAnimation* animation)
337 {
338     return m_private->addAnimation(static_cast<WebAnimationImpl*>(animation)->cloneToCCAnimation());
339 }
340
341 void WebLayer::removeAnimation(int animationId)
342 {
343     m_private->removeAnimation(animationId);
344 }
345
346 void WebLayer::removeAnimation(int animationId, WebAnimation::TargetProperty targetProperty)
347 {
348     m_private->layerAnimationController()->removeAnimation(animationId, static_cast<CCActiveAnimation::TargetProperty>(targetProperty));
349 }
350
351 void WebLayer::pauseAnimation(int animationId, double timeOffset)
352 {
353     m_private->pauseAnimation(animationId, timeOffset);
354 }
355
356 void WebLayer::suspendAnimations(double monotonicTime)
357 {
358     m_private->suspendAnimations(monotonicTime);
359 }
360
361 void WebLayer::resumeAnimations(double monotonicTime)
362 {
363     m_private->resumeAnimations(monotonicTime);
364 }
365
366 bool WebLayer::hasActiveAnimation()
367 {
368     return m_private->hasActiveAnimation();
369 }
370
371 void WebLayer::transferAnimationsTo(WebLayer* other)
372 {
373     ASSERT(other);
374     if (other)
375         other->m_private->setLayerAnimationController(m_private->releaseLayerAnimationController());
376 }
377
378 void WebLayer::setForceRenderSurface(bool forceRenderSurface)
379 {
380     m_private->setForceRenderSurface(forceRenderSurface);
381 }
382
383 void WebLayer::clearRenderSurface()
384 {
385     m_private->clearRenderSurface();
386 }
387
388 WebLayer::WebLayer(const PassRefPtr<LayerChromium>& node)
389     : m_private(node)
390 {
391 }
392
393 WebLayer& WebLayer::operator=(const PassRefPtr<LayerChromium>& node)
394 {
395     m_private = node;
396     return *this;
397 }
398
399 WebLayer::operator PassRefPtr<LayerChromium>() const
400 {
401     return m_private.get();
402 }
403
404 } // namespace WebKit