[chromium] Use TextureLayerChromium for WebGL content instead of a dedicated layer...
[WebKit.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 "platform/WebLayer.h"
28
29 #include "Color.h"
30 #include "LayerChromium.h"
31 #include "SkMatrix44.h"
32 #include "TransformationMatrix.h"
33 #include "WebLayerImpl.h"
34 #include <public/WebFilterOperations.h>
35 #include <public/WebFloatPoint.h>
36 #include <public/WebFloatRect.h>
37 #include <public/WebSize.h>
38
39 using namespace WebCore;
40
41 namespace {
42
43 TransformationMatrix transformationMatrixFromSkMatrix44(const SkMatrix44& matrix)
44 {
45     double data[16];
46     matrix.asColMajord(data);
47     return TransformationMatrix(data[0], data[1], data[2], data[3],
48                                 data[4], data[5], data[6], data[7],
49                                 data[8], data[9], data[10], data[11],
50                                 data[12], data[13], data[14], data[15]);
51 }
52
53 SkMatrix44 skMatrix44FromTransformationMatrix(const TransformationMatrix& matrix)
54 {
55     SkMatrix44 skMatrix;
56     skMatrix.set(0, 0, SkDoubleToMScalar(matrix.m11()));
57     skMatrix.set(1, 0, SkDoubleToMScalar(matrix.m12()));
58     skMatrix.set(2, 0, SkDoubleToMScalar(matrix.m13()));
59     skMatrix.set(3, 0, SkDoubleToMScalar(matrix.m14()));
60     skMatrix.set(0, 1, SkDoubleToMScalar(matrix.m21()));
61     skMatrix.set(1, 1, SkDoubleToMScalar(matrix.m22()));
62     skMatrix.set(2, 1, SkDoubleToMScalar(matrix.m23()));
63     skMatrix.set(3, 1, SkDoubleToMScalar(matrix.m24()));
64     skMatrix.set(0, 2, SkDoubleToMScalar(matrix.m31()));
65     skMatrix.set(1, 2, SkDoubleToMScalar(matrix.m32()));
66     skMatrix.set(2, 2, SkDoubleToMScalar(matrix.m33()));
67     skMatrix.set(3, 2, SkDoubleToMScalar(matrix.m34()));
68     skMatrix.set(0, 3, SkDoubleToMScalar(matrix.m41()));
69     skMatrix.set(1, 3, SkDoubleToMScalar(matrix.m42()));
70     skMatrix.set(2, 3, SkDoubleToMScalar(matrix.m43()));
71     skMatrix.set(3, 3, SkDoubleToMScalar(matrix.m44()));
72     return skMatrix;
73 }
74
75 } // anonymous namespace
76
77 namespace WebKit {
78
79 WebLayer WebLayer::create()
80 {
81     return WebLayer(WebLayerImpl::create());
82 }
83
84 void WebLayer::reset()
85 {
86     m_private.reset();
87 }
88
89 void WebLayer::assign(const WebLayer& other)
90 {
91     m_private = other.m_private;
92 }
93
94 bool WebLayer::equals(const WebLayer& n) const
95 {
96     return (m_private.get() == n.m_private.get());
97 }
98
99 void WebLayer::invalidateRect(const WebFloatRect& dirtyRect)
100 {
101     m_private->setNeedsDisplayRect(dirtyRect);
102 }
103
104 void WebLayer::invalidate()
105 {
106     m_private->setNeedsDisplay();
107 }
108
109 WebLayer WebLayer::rootLayer() const
110 {
111     return WebLayer(const_cast<LayerChromium*>(m_private->rootLayer()));
112 }
113
114 WebLayer WebLayer::parent() const
115 {
116     return WebLayer(const_cast<LayerChromium*>(m_private->parent()));
117 }
118
119 void WebLayer::addChild(const WebLayer& child)
120 {
121     m_private->addChild(child);
122 }
123
124 void WebLayer::insertChild(const WebLayer& child, size_t index)
125 {
126     m_private->insertChild(child, index);
127 }
128
129 void WebLayer::replaceChild(const WebLayer& reference, const WebLayer& newLayer)
130 {
131     WebLayer ref = reference;
132     m_private->replaceChild(ref.unwrap<LayerChromium>(), newLayer);
133 }
134
135 void WebLayer::removeFromParent()
136 {
137     m_private->removeFromParent();
138 }
139
140 void WebLayer::removeAllChildren()
141 {
142     m_private->removeAllChildren();
143 }
144
145 void WebLayer::setAnchorPoint(const WebFloatPoint& anchorPoint)
146 {
147     m_private->setAnchorPoint(anchorPoint);
148 }
149
150 WebFloatPoint WebLayer::anchorPoint() const
151 {
152     return WebFloatPoint(m_private->anchorPoint());
153 }
154
155 void WebLayer::setAnchorPointZ(float anchorPointZ)
156 {
157     m_private->setAnchorPointZ(anchorPointZ);
158 }
159
160 float WebLayer::anchorPointZ() const
161 {
162     return m_private->anchorPointZ();
163 }
164
165 void WebLayer::setBounds(const WebSize& size)
166 {
167     m_private->setBounds(size);
168 }
169
170 WebSize WebLayer::bounds() const
171 {
172     return WebSize(m_private->bounds());
173 }
174
175 void WebLayer::setMasksToBounds(bool masksToBounds)
176 {
177     m_private->setMasksToBounds(masksToBounds);
178 }
179
180 bool WebLayer::masksToBounds() const
181 {
182     return m_private->masksToBounds();
183 }
184
185 void WebLayer::setMaskLayer(const WebLayer& maskLayer)
186 {
187     WebLayer ref = maskLayer;
188     return m_private->setMaskLayer(ref.unwrap<LayerChromium>());
189 }
190
191 WebLayer WebLayer::maskLayer() const
192 {
193     return WebLayer(m_private->maskLayer());
194 }
195
196 void WebLayer::setOpacity(float opacity)
197 {
198     m_private->setOpacity(opacity);
199 }
200
201 float WebLayer::opacity() const
202 {
203     return m_private->opacity();
204 }
205
206 void WebLayer::setOpaque(bool opaque)
207 {
208     m_private->setOpaque(opaque);
209 }
210
211 bool WebLayer::opaque() const
212 {
213     return m_private->opaque();
214 }
215
216 void WebLayer::setPosition(const WebFloatPoint& position)
217 {
218     m_private->setPosition(position);
219 }
220
221 WebFloatPoint WebLayer::position() const
222 {
223     return WebFloatPoint(m_private->position());
224 }
225
226 void WebLayer::setSublayerTransform(const SkMatrix44& matrix)
227 {
228     m_private->setSublayerTransform(transformationMatrixFromSkMatrix44(matrix));
229 }
230
231 SkMatrix44 WebLayer::sublayerTransform() const
232 {
233     return skMatrix44FromTransformationMatrix(m_private->sublayerTransform());
234 }
235
236 void WebLayer::setTransform(const SkMatrix44& matrix)
237 {
238     m_private->setTransform(transformationMatrixFromSkMatrix44(matrix));
239 }
240
241 SkMatrix44 WebLayer::transform() const
242 {
243     return skMatrix44FromTransformationMatrix(m_private->transform());
244 }
245
246 void WebLayer::setDebugBorderColor(const WebColor& color)
247 {
248     m_private->setDebugBorderColor(color);
249 }
250
251 void WebLayer::setDebugBorderWidth(float width)
252 {
253     m_private->setDebugBorderWidth(width);
254 }
255
256 void WebLayer::setFilters(const WebFilterOperations& filters)
257 {
258     m_private->setFilters(filters.toFilterOperations());
259 }
260
261 void WebLayer::setBackgroundFilters(const WebFilterOperations& filters)
262 {
263     m_private->setBackgroundFilters(filters.toFilterOperations());
264 }
265
266 WebLayer::WebLayer(const PassRefPtr<LayerChromium>& node)
267     : m_private(node)
268 {
269 }
270
271 WebLayer& WebLayer::operator=(const PassRefPtr<LayerChromium>& node)
272 {
273     m_private = node;
274     return *this;
275 }
276
277 WebLayer::operator PassRefPtr<LayerChromium>() const
278 {
279     return m_private.get();
280 }
281
282 } // namespace WebKit