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