8bcf6eb5da8827b540f1d17d4d367190e5a853bd
[WebKit-https.git] / Source / WebCore / html / canvas / WebGLRenderingContextBase.h
1 /*
2  * Copyright (C) 2015-2016 Apple 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  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef WebGLRenderingContextBase_h
27 #define WebGLRenderingContextBase_h
28
29 #include "ActiveDOMObject.h"
30 #include "CanvasRenderingContext.h"
31 #include "GraphicsContext3D.h"
32 #include "ImageBuffer.h"
33 #include "Timer.h"
34 #include "WebGLGetInfo.h"
35 #include "WebGLObject.h"
36 #include "WebGLTexture.h"
37 #include <memory>
38 #include <runtime/Float32Array.h>
39 #include <runtime/Int32Array.h>
40 #include <wtf/text/WTFString.h>
41
42 namespace WebCore {
43
44 class ANGLEInstancedArrays;
45 class EXTBlendMinMax;
46 class EXTTextureFilterAnisotropic;
47 class EXTShaderTextureLOD;
48 class EXTsRGB;
49 class EXTFragDepth;
50 class HTMLImageElement;
51 class HTMLVideoElement;
52 class ImageBuffer;
53 class ImageData;
54 class IntSize;
55 class OESStandardDerivatives;
56 class OESTextureFloat;
57 class OESTextureFloatLinear;
58 class OESTextureHalfFloat;
59 class OESTextureHalfFloatLinear;
60 class OESVertexArrayObject;
61 class OESElementIndexUint;
62 class WebGLActiveInfo;
63 class WebGLBuffer;
64 class WebGLContextGroup;
65 class WebGLContextObject;
66 class WebGLCompressedTextureATC;
67 class WebGLCompressedTexturePVRTC;
68 class WebGLCompressedTextureS3TC;
69 class WebGLContextAttributes;
70 class WebGLDebugRendererInfo;
71 class WebGLDebugShaders;
72 class WebGLDepthTexture;
73 class WebGLDrawBuffers;
74 class WebGLExtension;
75 class WebGLFramebuffer;
76 class WebGLLoseContext;
77 class WebGLObject;
78 class WebGLProgram;
79 class WebGLRenderbuffer;
80 class WebGLShader;
81 class WebGLSharedObject;
82 class WebGLShaderPrecisionFormat;
83 class WebGLUniformLocation;
84 class WebGLVertexArrayObjectOES;
85
86 typedef int ExceptionCode;
87
88 inline void clip1D(GC3Dint start, GC3Dsizei range, GC3Dsizei sourceRange, GC3Dint* clippedStart, GC3Dsizei* clippedRange)
89 {
90     ASSERT(clippedStart && clippedRange);
91     if (start < 0) {
92         range += start;
93         start = 0;
94     }
95     GC3Dint end = start + range;
96     if (end > sourceRange)
97         range -= end - sourceRange;
98     *clippedStart = start;
99     *clippedRange = range;
100 }
101
102 // Returns false if no clipping is necessary, i.e., x, y, width, height stay the same.
103 inline bool clip2D(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height,
104     GC3Dsizei sourceWidth, GC3Dsizei sourceHeight,
105     GC3Dint* clippedX, GC3Dint* clippedY, GC3Dsizei* clippedWidth, GC3Dsizei*clippedHeight)
106 {
107     ASSERT(clippedX && clippedY && clippedWidth && clippedHeight);
108     clip1D(x, width, sourceWidth, clippedX, clippedWidth);
109     clip1D(y, height, sourceHeight, clippedY, clippedHeight);
110     return (*clippedX != x || *clippedY != y || *clippedWidth != width || *clippedHeight != height);
111 }
112
113 class WebGLRenderingContextBase : public CanvasRenderingContext, public ActiveDOMObject {
114 public:
115     static std::unique_ptr<WebGLRenderingContextBase> create(HTMLCanvasElement*, WebGLContextAttributes*, const String&);
116     virtual ~WebGLRenderingContextBase();
117
118 #if PLATFORM(WIN)
119     // FIXME: Implement accelerated 3d canvas on Windows.
120     bool isAccelerated() const override { return false; }
121 #else
122     bool isAccelerated() const override { return true; }
123 #endif
124
125     int drawingBufferWidth() const;
126     int drawingBufferHeight() const;
127
128     void activeTexture(GC3Denum texture, ExceptionCode&);
129     void attachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);
130     void bindAttribLocation(WebGLProgram*, GC3Duint index, const String& name, ExceptionCode&);
131     void bindBuffer(GC3Denum target, WebGLBuffer*, ExceptionCode&);
132     void bindFramebuffer(GC3Denum target, WebGLFramebuffer*, ExceptionCode&);
133     void bindRenderbuffer(GC3Denum target, WebGLRenderbuffer*, ExceptionCode&);
134     void bindTexture(GC3Denum target, WebGLTexture*, ExceptionCode&);
135     void blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);
136     void blendEquation(GC3Denum mode);
137     void blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha);
138     void blendFunc(GC3Denum sfactor, GC3Denum dfactor);
139     void blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha);
140
141     void bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode&);
142     void bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode&);
143     void bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode&);
144     void bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode&);
145     void bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode&);
146
147     GC3Denum checkFramebufferStatus(GC3Denum target);
148     virtual void clear(GC3Dbitfield mask) = 0;
149     void clearColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);
150     void clearDepth(GC3Dfloat);
151     void clearStencil(GC3Dint);
152     void colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha);
153     void compileShader(WebGLShader*, ExceptionCode&);
154
155     void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,
156                               GC3Dsizei height, GC3Dint border, ArrayBufferView* data);
157     void compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
158                                  GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data);
159
160     virtual void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border) = 0;
161     void copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
162
163     PassRefPtr<WebGLBuffer> createBuffer();
164     PassRefPtr<WebGLFramebuffer> createFramebuffer();
165     PassRefPtr<WebGLProgram> createProgram();
166     PassRefPtr<WebGLRenderbuffer> createRenderbuffer();
167     PassRefPtr<WebGLShader> createShader(GC3Denum type, ExceptionCode&);
168     PassRefPtr<WebGLTexture> createTexture();
169
170     void cullFace(GC3Denum mode);
171
172     void deleteBuffer(WebGLBuffer*);
173     void deleteFramebuffer(WebGLFramebuffer*);
174     void deleteProgram(WebGLProgram*);
175     void deleteRenderbuffer(WebGLRenderbuffer*);
176     void deleteShader(WebGLShader*);
177     void deleteTexture(WebGLTexture*);
178
179     void depthFunc(GC3Denum);
180     void depthMask(GC3Dboolean);
181     void depthRange(GC3Dfloat zNear, GC3Dfloat zFar);
182     void detachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);
183     void disable(GC3Denum cap);
184     void disableVertexAttribArray(GC3Duint index, ExceptionCode&);
185     void drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode&);
186     void drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode&);
187
188     void enable(GC3Denum cap);
189     void enableVertexAttribArray(GC3Duint index, ExceptionCode&);
190     void finish();
191     void flush();
192     void framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer*, ExceptionCode&);
193     void framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture*, GC3Dint level, ExceptionCode&);
194     void frontFace(GC3Denum mode);
195     void generateMipmap(GC3Denum target);
196
197     PassRefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GC3Duint index, ExceptionCode&);
198     PassRefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GC3Duint index, ExceptionCode&);
199     bool getAttachedShaders(WebGLProgram*, Vector<RefPtr<WebGLShader>>&, ExceptionCode&);
200     GC3Dint getAttribLocation(WebGLProgram*, const String& name);
201     WebGLGetInfo getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
202     PassRefPtr<WebGLContextAttributes> getContextAttributes();
203     GC3Denum getError();
204     virtual WebGLExtension* getExtension(const String& name) = 0;
205     virtual WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&) = 0;
206     virtual WebGLGetInfo getParameter(GC3Denum pname, ExceptionCode&) = 0;
207     WebGLGetInfo getProgramParameter(WebGLProgram*, GC3Denum pname, ExceptionCode&);
208     String getProgramInfoLog(WebGLProgram*, ExceptionCode&);
209     WebGLGetInfo getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
210     WebGLGetInfo getShaderParameter(WebGLShader*, GC3Denum pname, ExceptionCode&);
211     String getShaderInfoLog(WebGLShader*, ExceptionCode&);
212     PassRefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode&);
213     String getShaderSource(WebGLShader*, ExceptionCode&);
214     virtual Vector<String> getSupportedExtensions() = 0;
215     WebGLGetInfo getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
216     WebGLGetInfo getUniform(WebGLProgram*, const WebGLUniformLocation*, ExceptionCode&);
217     PassRefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&, ExceptionCode&);
218     WebGLGetInfo getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode&);
219     long long getVertexAttribOffset(GC3Duint index, GC3Denum pname);
220
221     virtual void hint(GC3Denum target, GC3Denum mode) = 0;
222     GC3Dboolean isBuffer(WebGLBuffer*);
223     bool isContextLost() const;
224     GC3Dboolean isEnabled(GC3Denum cap);
225     GC3Dboolean isFramebuffer(WebGLFramebuffer*);
226     GC3Dboolean isProgram(WebGLProgram*);
227     GC3Dboolean isRenderbuffer(WebGLRenderbuffer*);
228     GC3Dboolean isShader(WebGLShader*);
229     GC3Dboolean isTexture(WebGLTexture*);
230
231     void lineWidth(GC3Dfloat);
232     void linkProgram(WebGLProgram*, ExceptionCode&);
233     void pixelStorei(GC3Denum pname, GC3Dint param);
234     void polygonOffset(GC3Dfloat factor, GC3Dfloat units);
235     void readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode&);
236     void releaseShaderCompiler();
237     virtual void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) = 0;
238     void sampleCoverage(GC3Dfloat value, GC3Dboolean invert);
239     void scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
240     void shaderSource(WebGLShader*, const String&, ExceptionCode&);
241     void stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask);
242     void stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask);
243     void stencilMask(GC3Duint);
244     void stencilMaskSeparate(GC3Denum face, GC3Duint mask);
245     void stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
246     void stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
247
248     void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
249                     GC3Dsizei width, GC3Dsizei height, GC3Dint border,
250                     GC3Denum format, GC3Denum type, ArrayBufferView*, ExceptionCode&);
251     void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
252                     GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);
253     void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
254                     GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);
255     void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
256                     GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);
257 #if ENABLE(VIDEO)
258     void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
259                     GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);
260 #endif
261
262     void texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param);
263     void texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param);
264
265     virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
266         GC3Dsizei width, GC3Dsizei height,
267         GC3Denum format, GC3Denum type, ArrayBufferView*, ExceptionCode&) = 0;
268     virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
269         GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&) = 0;
270     virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
271         GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&) = 0;
272     virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
273         GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&) = 0;
274 #if ENABLE(VIDEO)
275     virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
276         GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&) = 0;
277 #endif
278
279     void uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode&);
280     void uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
281     void uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
282     void uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode&);
283     void uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
284     void uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
285     void uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode&);
286     void uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
287     void uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
288     void uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode&);
289     void uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
290     void uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
291     void uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode&);
292     void uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
293     void uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
294     void uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode&);
295     void uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
296     void uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
297     void uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode&);
298     void uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
299     void uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
300     void uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode&);
301     void uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
302     void uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
303     void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);
304     void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);
305     void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);
306     void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);
307     void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);
308     void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);
309
310     void useProgram(WebGLProgram*, ExceptionCode&);
311     void validateProgram(WebGLProgram*, ExceptionCode&);
312
313     void vertexAttrib1f(GC3Duint index, GC3Dfloat x);
314     void vertexAttrib1fv(GC3Duint index, Float32Array* values);
315     void vertexAttrib1fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
316     void vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y);
317     void vertexAttrib2fv(GC3Duint index, Float32Array* values);
318     void vertexAttrib2fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
319     void vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);
320     void vertexAttrib3fv(GC3Duint index, Float32Array* values);
321     void vertexAttrib3fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
322     void vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
323     void vertexAttrib4fv(GC3Duint index, Float32Array* values);
324     void vertexAttrib4fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
325     void vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized,
326                              GC3Dsizei stride, long long offset, ExceptionCode&);
327
328     void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
329
330     // WEBKIT_lose_context support
331     enum LostContextMode {
332         // Lost context occurred at the graphics system level.
333         RealLostContext,
334
335         // Lost context provoked by WEBKIT_lose_context.
336         SyntheticLostContext
337     };
338     void forceLostContext(LostContextMode);
339     void recycleContext();
340     void forceRestoreContext();
341     void loseContextImpl(LostContextMode);
342
343     GraphicsContext3D* graphicsContext3D() const { return m_context.get(); }
344     WebGLContextGroup* contextGroup() const { return m_contextGroup.get(); }
345     PlatformLayer* platformLayer() const override;
346
347     void reshape(int width, int height);
348
349     void markLayerComposited();
350     void paintRenderingResultsToCanvas() override;
351     PassRefPtr<ImageData> paintRenderingResultsToImageData();
352
353     void removeSharedObject(WebGLSharedObject*);
354     void removeContextObject(WebGLContextObject*);
355     
356     unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }
357
358     // Instanced Array helper functions.
359     void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);
360     void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount);
361     void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);
362
363 protected:
364     WebGLRenderingContextBase(HTMLCanvasElement*, GraphicsContext3D::Attributes);
365     WebGLRenderingContextBase(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);
366
367     friend class WebGLDrawBuffers;
368     friend class WebGLFramebuffer;
369     friend class WebGLObject;
370     friend class OESVertexArrayObject;
371     friend class WebGLDebugShaders;
372     friend class WebGLCompressedTextureATC;
373     friend class WebGLCompressedTexturePVRTC;
374     friend class WebGLCompressedTextureS3TC;
375     friend class WebGLRenderingContextErrorMessageCallback;
376     friend class WebGLVertexArrayObjectOES;
377     friend class WebGLVertexArrayObject;
378     friend class WebGLVertexArrayObjectBase;
379
380     virtual void initializeNewContext();
381     virtual void initializeVertexArrayObjects() = 0;
382     void setupFlags();
383
384     // ActiveDOMObject
385     bool hasPendingActivity() const override;
386     void stop() override;
387     const char* activeDOMObjectName() const override;
388     bool canSuspendForDocumentSuspension() const override;
389
390     void addSharedObject(WebGLSharedObject*);
391     void addContextObject(WebGLContextObject*);
392     void detachAndRemoveAllObjects();
393
394     void destroyGraphicsContext3D();
395     void markContextChanged();
396
397     // Query whether it is built on top of compliant GLES2 implementation.
398     bool isGLES2Compliant() { return m_isGLES2Compliant; }
399     // Query if the GL implementation is NPOT strict.
400     bool isGLES2NPOTStrict() { return m_isGLES2NPOTStrict; }
401     // Query if the GL implementation generates errors on out-of-bounds buffer accesses.
402     bool isErrorGeneratedOnOutOfBoundsAccesses() { return m_isErrorGeneratedOnOutOfBoundsAccesses; }
403     // Query if the GL implementation initializes textures/renderbuffers to 0.
404     bool isResourceSafe() { return m_isResourceSafe; }
405     // Query if depth_stencil buffer is supported.
406     bool isDepthStencilSupported() { return m_isDepthStencilSupported; }
407
408     // Helper to return the size in bytes of OpenGL data types
409     // like GL_FLOAT, GL_INT, etc.
410     unsigned int sizeInBytes(GC3Denum type);
411
412     // Basic validation of count and offset against number of elements in element array buffer
413     bool validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset);
414
415     // Conservative but quick index validation
416     virtual bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired) = 0;
417
418     // Precise but slow index validation -- only done if conservative checks fail
419     bool validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired);
420     bool validateVertexAttributes(unsigned elementCount, unsigned primitiveCount = 0);
421
422     bool validateWebGLObject(const char*, WebGLObject*);
423
424     bool validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);
425     bool validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements, GC3Dsizei primcount);
426     bool validateNPOTTextureLevel(GC3Dsizei width, GC3Dsizei height, GC3Dint level, const char* functionName);
427
428     // Adds a compressed texture format.
429     void addCompressedTextureFormat(GC3Denum);
430
431     PassRefPtr<Image> drawImageIntoBuffer(Image&, int width, int height, int deviceScaleFactor);
432
433 #if ENABLE(VIDEO)
434     PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*, BackingStoreCopy, ExceptionCode&);
435 #endif
436
437     WebGLTexture::TextureExtensionFlag textureExtensionFlags() const;
438
439     RefPtr<GraphicsContext3D> m_context;
440     RefPtr<WebGLContextGroup> m_contextGroup;
441
442     // Dispatches a context lost event once it is determined that one is needed.
443     // This is used both for synthetic and real context losses. For real ones, it's
444     // likely that there's no JavaScript on the stack, but that might be dependent
445     // on how exactly the platform discovers that the context was lost. For better
446     // portability we always defer the dispatch of the event.
447     Timer m_dispatchContextLostEventTimer;
448     bool m_restoreAllowed;
449     Timer m_restoreTimer;
450
451     bool m_needsUpdate;
452     bool m_markedCanvasDirty;
453     HashSet<WebGLContextObject*> m_contextObjects;
454
455     // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
456     RefPtr<WebGLBuffer> m_boundArrayBuffer;
457
458     RefPtr<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
459     RefPtr<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
460     void setBoundVertexArrayObject(PassRefPtr<WebGLVertexArrayObjectBase> arrayObject)
461     {
462         if (arrayObject)
463             m_boundVertexArrayObject = arrayObject;
464         else
465             m_boundVertexArrayObject = m_defaultVertexArrayObject;
466     }
467     
468     class VertexAttribValue {
469     public:
470         VertexAttribValue()
471         {
472             initValue();
473         }
474         
475         void initValue()
476         {
477             value[0] = 0.0f;
478             value[1] = 0.0f;
479             value[2] = 0.0f;
480             value[3] = 1.0f;
481         }
482         
483         GC3Dfloat value[4];
484     };
485     Vector<VertexAttribValue> m_vertexAttribValue;
486     unsigned m_maxVertexAttribs;
487     RefPtr<WebGLBuffer> m_vertexAttrib0Buffer;
488     long m_vertexAttrib0BufferSize;
489     GC3Dfloat m_vertexAttrib0BufferValue[4];
490     bool m_forceAttrib0BufferRefill;
491     bool m_vertexAttrib0UsedBefore;
492
493     RefPtr<WebGLProgram> m_currentProgram;
494     RefPtr<WebGLFramebuffer> m_framebufferBinding;
495     RefPtr<WebGLRenderbuffer> m_renderbufferBinding;
496     struct TextureUnitState {
497         RefPtr<WebGLTexture> texture2DBinding;
498         RefPtr<WebGLTexture> textureCubeMapBinding;
499     };
500     Vector<TextureUnitState> m_textureUnits;
501     HashSet<unsigned, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> m_unrenderableTextureUnits;
502
503     unsigned long m_activeTextureUnit;
504
505     RefPtr<WebGLTexture> m_blackTexture2D;
506     RefPtr<WebGLTexture> m_blackTextureCubeMap;
507
508     Vector<GC3Denum> m_compressedTextureFormats;
509
510     // Fixed-size cache of reusable image buffers for video texImage2D calls.
511     class LRUImageBufferCache {
512     public:
513         LRUImageBufferCache(int capacity);
514         // The pointer returned is owned by the image buffer map.
515         ImageBuffer* imageBuffer(const IntSize& size);
516     private:
517         void bubbleToFront(int idx);
518         std::unique_ptr<std::unique_ptr<ImageBuffer>[]> m_buffers;
519         int m_capacity;
520     };
521     LRUImageBufferCache m_generatedImageCache;
522
523     GC3Dint m_maxTextureSize;
524     GC3Dint m_maxCubeMapTextureSize;
525     GC3Dint m_maxRenderbufferSize;
526     GC3Dint m_maxViewportDims[2];
527     GC3Dint m_maxTextureLevel;
528     GC3Dint m_maxCubeMapTextureLevel;
529
530     GC3Dint m_maxDrawBuffers;
531     GC3Dint m_maxColorAttachments;
532     GC3Denum m_backDrawBuffer;
533     bool m_drawBuffersWebGLRequirementsChecked;
534     bool m_drawBuffersSupported;
535
536     GC3Dint m_packAlignment;
537     GC3Dint m_unpackAlignment;
538     bool m_unpackFlipY;
539     bool m_unpackPremultiplyAlpha;
540     GC3Denum m_unpackColorspaceConversion;
541     bool m_contextLost;
542     LostContextMode m_contextLostMode;
543     GraphicsContext3D::Attributes m_attributes;
544
545     bool m_layerCleared;
546     GC3Dfloat m_clearColor[4];
547     bool m_scissorEnabled;
548     GC3Dfloat m_clearDepth;
549     GC3Dint m_clearStencil;
550     GC3Dboolean m_colorMask[4];
551     GC3Dboolean m_depthMask;
552
553     bool m_stencilEnabled;
554     GC3Duint m_stencilMask, m_stencilMaskBack;
555     GC3Dint m_stencilFuncRef, m_stencilFuncRefBack; // Note that these are the user specified values, not the internal clamped value.
556     GC3Duint m_stencilFuncMask, m_stencilFuncMaskBack;
557
558     bool m_isGLES2Compliant;
559     bool m_isGLES2NPOTStrict;
560     bool m_isErrorGeneratedOnOutOfBoundsAccesses;
561     bool m_isResourceSafe;
562     bool m_isDepthStencilSupported;
563     bool m_isRobustnessEXTSupported;
564
565     bool m_synthesizedErrorsToConsole;
566     int m_numGLErrorsToConsoleAllowed;
567
568     // A WebGLRenderingContext can be created in a state where it appears as
569     // a valid and active context, but will not execute any important operations
570     // until its load policy is completely resolved.
571     bool m_isPendingPolicyResolution;
572     bool m_hasRequestedPolicyResolution;
573     bool isContextLostOrPending();
574
575     // Enabled extension objects. FIXME: Move these to WebGL1RenderingContext, not needed for WebGL2
576     std::unique_ptr<EXTFragDepth> m_extFragDepth;
577     std::unique_ptr<EXTBlendMinMax> m_extBlendMinMax;
578     std::unique_ptr<EXTsRGB> m_extsRGB;
579     std::unique_ptr<EXTTextureFilterAnisotropic> m_extTextureFilterAnisotropic;
580     std::unique_ptr<EXTShaderTextureLOD> m_extShaderTextureLOD;
581     std::unique_ptr<OESTextureFloat> m_oesTextureFloat;
582     std::unique_ptr<OESTextureFloatLinear> m_oesTextureFloatLinear;
583     std::unique_ptr<OESTextureHalfFloat> m_oesTextureHalfFloat;
584     std::unique_ptr<OESTextureHalfFloatLinear> m_oesTextureHalfFloatLinear;
585     std::unique_ptr<OESStandardDerivatives> m_oesStandardDerivatives;
586     std::unique_ptr<OESVertexArrayObject> m_oesVertexArrayObject;
587     std::unique_ptr<OESElementIndexUint> m_oesElementIndexUint;
588     std::unique_ptr<WebGLLoseContext> m_webglLoseContext;
589     std::unique_ptr<WebGLDebugRendererInfo> m_webglDebugRendererInfo;
590     std::unique_ptr<WebGLDebugShaders> m_webglDebugShaders;
591     std::unique_ptr<WebGLCompressedTextureATC> m_webglCompressedTextureATC;
592     std::unique_ptr<WebGLCompressedTexturePVRTC> m_webglCompressedTexturePVRTC;
593     std::unique_ptr<WebGLCompressedTextureS3TC> m_webglCompressedTextureS3TC;
594     std::unique_ptr<WebGLDepthTexture> m_webglDepthTexture;
595     std::unique_ptr<WebGLDrawBuffers> m_webglDrawBuffers;
596     std::unique_ptr<ANGLEInstancedArrays> m_angleInstancedArrays;
597
598     // Helpers for getParameter and others
599     WebGLGetInfo getBooleanParameter(GC3Denum);
600     WebGLGetInfo getBooleanArrayParameter(GC3Denum);
601     WebGLGetInfo getFloatParameter(GC3Denum);
602     WebGLGetInfo getIntParameter(GC3Denum);
603     WebGLGetInfo getUnsignedIntParameter(GC3Denum);
604     WebGLGetInfo getInt64Parameter(GC3Denum);
605     WebGLGetInfo getWebGLFloatArrayParameter(GC3Denum);
606     WebGLGetInfo getWebGLIntArrayParameter(GC3Denum);
607
608     // Clear the backbuffer if it was composited since the last operation.
609     // clearMask is set to the bitfield of any clear that would happen anyway at this time
610     // and the function returns true if that clear is now unnecessary.
611     bool clearIfComposited(GC3Dbitfield clearMask = 0);
612
613     // Helper to restore state that clearing the framebuffer may destroy.
614     void restoreStateAfterClear();
615
616     void texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);
617     void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);
618     virtual void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&) = 0;
619     virtual void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&) = 0;
620
621     bool checkTextureCompleteness(const char*, bool);
622
623     void createFallbackBlackTextures1x1();
624
625     // Helper function for copyTex{Sub}Image, check whether the internalformat
626     // and the color buffer format of the current bound framebuffer combination
627     // is valid.
628     bool isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,
629                                                         GC3Denum colorBufferFormat);
630
631     // Helper function to get the bound framebuffer's color buffer format.
632     GC3Denum getBoundFramebufferColorFormat();
633
634     // Helper function to get the bound framebuffer's width.
635     int getBoundFramebufferWidth();
636
637     // Helper function to get the bound framebuffer's height.
638     int getBoundFramebufferHeight();
639
640     // Helper function to verify limits on the length of uniform and attribute locations.
641     bool validateLocationLength(const char* functionName, const String&);
642
643     // Helper function to check if size is non-negative.
644     // Generate GL error and return false for negative inputs; otherwise, return true.
645     bool validateSize(const char* functionName, GC3Dint x, GC3Dint y);
646
647     // Helper function to check if all characters in the string belong to the
648     // ASCII subset as defined in GLSL ES 1.0 spec section 3.1.
649     bool validateString(const char* functionName, const String&);
650
651     // Helper function to check target and texture bound to the target.
652     // Generate GL errors and return 0 if target is invalid or texture bound is
653     // null.  Otherwise, return the texture bound to the target.
654     WebGLTexture* validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap);
655
656     // Helper function to check input format/type for functions {copy}Tex{Sub}Image.
657     // Generates GL error and returns false if parameters are invalid.
658     virtual bool validateTexFuncFormatAndType(const char* functionName, GC3Denum internalformat, GC3Denum format, GC3Denum type, GC3Dint level) = 0;
659
660     // Helper function to check input level for functions {copy}Tex{Sub}Image.
661     // Generates GL error and returns false if level is invalid.
662     bool validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level);
663
664     enum TexFuncValidationFunctionType {
665         TexImage,
666         TexSubImage,
667         CopyTexImage
668     };
669
670     enum TexFuncValidationSourceType {
671         SourceArrayBufferView,
672         SourceImageData,
673         SourceHTMLImageElement,
674         SourceHTMLCanvasElement,
675         SourceHTMLVideoElement,
676     };
677
678     // Helper function for tex{Sub}Image2D to check if the input format/type/level/target/width/height/border/xoffset/yoffset are valid.
679     // Otherwise, it would return quickly without doing other work.
680     bool validateTexFunc(const char* functionName, TexFuncValidationFunctionType, TexFuncValidationSourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,
681         GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset);
682
683     // Helper function to check input parameters for functions {copy}Tex{Sub}Image.
684     // Generates GL error and returns false if parameters are invalid.
685     virtual bool validateTexFuncParameters(const char* functionName,
686         TexFuncValidationFunctionType,
687         GC3Denum target, GC3Dint level,
688         GC3Denum internalformat,
689         GC3Dsizei width, GC3Dsizei height, GC3Dint border,
690         GC3Denum format, GC3Denum type) = 0;
691
692     enum NullDisposition {
693         NullAllowed,
694         NullNotAllowed
695     };
696
697     // Helper function to validate that the given ArrayBufferView
698     // is of the correct type and contains enough data for the texImage call.
699     // Generates GL error and returns false if parameters are invalid.
700     virtual bool validateTexFuncData(const char* functionName, GC3Dint level,
701         GC3Dsizei width, GC3Dsizei height,
702         GC3Denum internalformat, GC3Denum format, GC3Denum type,
703         ArrayBufferView* pixels,
704         NullDisposition) = 0;
705
706     // Helper function to validate a given texture format is settable as in
707     // you can supply data to texImage2D, or call texImage2D, copyTexImage2D and
708     // copyTexSubImage2D.
709     // Generates GL error and returns false if the format is not settable.
710     bool validateSettableTexFormat(const char* functionName, GC3Denum format);
711
712     // Helper function to validate compressed texture data is correct size
713     // for the given format and dimensions.
714     bool validateCompressedTexFuncData(const char* functionName,
715                                        GC3Dsizei width, GC3Dsizei height,
716                                        GC3Denum format, ArrayBufferView* pixels);
717
718     // Helper function for validating compressed texture formats.
719     bool validateCompressedTexFormat(GC3Denum format);
720
721     // Helper function to validate compressed texture dimensions are valid for
722     // the given format.
723     bool validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format);
724
725     // Helper function to validate compressed texture dimensions are valid for
726     // the given format.
727     bool validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
728                                             GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture*);
729
730     // Helper function to validate mode for draw{Arrays/Elements}.
731     bool validateDrawMode(const char* functionName, GC3Denum);
732
733     // Helper function to validate if front/back stencilMask and stencilFunc settings are the same.
734     bool validateStencilSettings(const char* functionName);
735
736     // Helper function to validate stencil func.
737     bool validateStencilFunc(const char* functionName, GC3Denum);
738
739     // Helper function for texParameterf and texParameteri.
740     void texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat parami, GC3Dint paramf, bool isFloat);
741
742     // Helper function to print GL errors to console.
743     void printGLErrorToConsole(const String&);
744     void printGLWarningToConsole(const char* function, const char* reason);
745
746     // Helper function to print warnings to console. Currently
747     // used only to warn about use of obsolete functions.
748     void printWarningToConsole(const String&);
749
750     // Helper function to validate input parameters for framebuffer functions.
751     // Generate GL error if parameters are illegal.
752     virtual bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment) = 0;
753
754     // Helper function to validate blend equation mode.
755     virtual bool validateBlendEquation(const char* functionName, GC3Denum) = 0;
756
757     // Helper function to validate blend func factors.
758     bool validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst);
759
760     // Helper function to validate a GL capability.
761     virtual bool validateCapability(const char* functionName, GC3Denum) = 0;
762
763     // Helper function to validate input parameters for uniform functions.
764     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Float32Array*, GC3Dsizei mod);
765     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Int32Array*, GC3Dsizei mod);
766     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, void*, GC3Dsizei, GC3Dsizei mod);
767     bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array*, GC3Dsizei mod);
768     bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, void*, GC3Dsizei, GC3Dsizei mod);
769
770     // Helper function to validate parameters for bufferData.
771     // Return the current bound buffer to target, or 0 if parameters are invalid.
772     WebGLBuffer* validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage);
773
774     // Helper function for tex{Sub}Image2D to make sure image is ready and wouldn't taint Origin.
775     bool validateHTMLImageElement(const char* functionName, HTMLImageElement*, ExceptionCode&);
776
777     // Helper function for tex{Sub}Image2D to make sure canvas is ready and wouldn't taint Origin.
778     bool validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement*, ExceptionCode&);
779
780 #if ENABLE(VIDEO)
781     // Helper function for tex{Sub}Image2D to make sure video is ready wouldn't taint Origin.
782     bool validateHTMLVideoElement(const char* functionName, HTMLVideoElement*, ExceptionCode&);
783 #endif
784
785     // Helper functions for vertexAttribNf{v}.
786     void vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat, GC3Dfloat, GC3Dfloat, GC3Dfloat);
787     void vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array*, GC3Dsizei expectedSize);
788     void vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat*, GC3Dsizei, GC3Dsizei expectedSize);
789
790     // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.
791     // Return false if caller should return without further processing.
792     bool deleteObject(WebGLObject*);
793
794     // Helper function for bind* (bindBuffer, bindTexture, etc) and useProgram.
795     // If the object has already been deleted, set deleted to true upon return.
796     // Return false if caller should return without further processing.
797     bool checkObjectToBeBound(const char* functionName, WebGLObject*, bool& deleted);
798
799     // Helpers for simulating vertexAttrib0.
800     void initVertexAttrib0();
801     bool simulateVertexAttrib0(GC3Dsizei numVertex);
802     bool validateSimulatedVertexAttrib0(GC3Dsizei numVertex);
803     void restoreStatesAfterVertexAttrib0Simulation();
804
805     void dispatchContextLostEvent();
806     // Helper for restoration after context lost.
807     void maybeRestoreContext();
808
809     enum ConsoleDisplayPreference {
810         DisplayInConsole,
811         DontDisplayInConsole
812     };
813
814     // Wrapper for GraphicsContext3D::synthesizeGLError that sends a message
815     // to the JavaScript console.
816     void synthesizeGLError(GC3Denum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);
817
818     String ensureNotNull(const String&) const;
819
820     // Enable or disable stencil test based on user setting and
821     // whether the current FBO has a stencil buffer.
822     void applyStencilTest();
823
824     // Helper for enabling or disabling a capability.
825     void enableOrDisable(GC3Denum capability, bool enable);
826
827     // Clamp the width and height to GL_MAX_VIEWPORT_DIMS.
828     IntSize clampedCanvasSize();
829
830     virtual GC3Dint getMaxDrawBuffers() = 0;
831     virtual GC3Dint getMaxColorAttachments() = 0;
832
833     void setBackDrawBuffer(GC3Denum);
834
835     void restoreCurrentFramebuffer();
836     void restoreCurrentTexture2D();
837
838     // Check if EXT_draw_buffers extension is supported and if it satisfies the WebGL requirements.
839     bool supportsDrawBuffers();
840 };
841
842 } // namespace WebCore
843
844 #endif