Purge PassRefPtr in JavaScriptCore - 2
[WebKit-https.git] / Source / WebCore / html / canvas / WebGL2RenderingContext.cpp
1 /*
2  * Copyright (C) 2015 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 #include "config.h"
27
28 #if ENABLE(WEBGL)
29 #include "WebGL2RenderingContext.h"
30
31 #include "CachedImage.h"
32 #include "EXTTextureFilterAnisotropic.h"
33 #include "Extensions3D.h"
34 #include "HTMLCanvasElement.h"
35 #include "HTMLImageElement.h"
36 #include "HTMLVideoElement.h"
37 #include "ImageData.h"
38 #include "OESTextureFloat.h"
39 #include "OESTextureFloatLinear.h"
40 #include "OESTextureHalfFloat.h"
41 #include "OESTextureHalfFloatLinear.h"
42 #include "RenderBox.h"
43 #include "WebGLActiveInfo.h"
44 #include "WebGLCompressedTextureATC.h"
45 #include "WebGLCompressedTexturePVRTC.h"
46 #include "WebGLCompressedTextureS3TC.h"
47 #include "WebGLContextAttributes.h"
48 #include "WebGLDebugRendererInfo.h"
49 #include "WebGLDebugShaders.h"
50 #include "WebGLDepthTexture.h"
51 #include "WebGLLoseContext.h"
52 #include "WebGLQuery.h"
53 #include "WebGLSampler.h"
54 #include "WebGLSync.h"
55 #include "WebGLTransformFeedback.h"
56 #include "WebGLVertexArrayObject.h"
57
58 namespace WebCore {
59
60 WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)
61     : WebGLRenderingContextBase(passedCanvas, attributes)
62 {
63 }
64
65 WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context,
66     GraphicsContext3D::Attributes attributes) : WebGLRenderingContextBase(passedCanvas, context, attributes)
67 {
68     initializeShaderExtensions();
69     initializeVertexArrayObjects();
70 }
71
72 void WebGL2RenderingContext::initializeVertexArrayObjects()
73 {
74     m_defaultVertexArrayObject = WebGLVertexArrayObject::create(this, WebGLVertexArrayObject::VAOTypeDefault);
75     addContextObject(m_defaultVertexArrayObject.get());
76     m_boundVertexArrayObject = m_defaultVertexArrayObject;
77     if (!isGLES2Compliant())
78         initVertexAttrib0();
79 }
80
81 void WebGL2RenderingContext::initializeShaderExtensions()
82 {
83     m_context->getExtensions()->ensureEnabled("GL_OES_standard_derivatives");
84     m_context->getExtensions()->ensureEnabled("GL_EXT_draw_buffers");
85     m_context->getExtensions()->ensureEnabled("GL_EXT_shader_texture_lod");
86     m_context->getExtensions()->ensureEnabled("GL_EXT_frag_depth");
87 }
88
89 void WebGL2RenderingContext::copyBufferSubData(GC3Denum readTarget, GC3Denum writeTarget, GC3Dint64 readOffset, GC3Dint64 writeOffset, GC3Dint64 size)
90 {
91     UNUSED_PARAM(readTarget);
92     UNUSED_PARAM(writeTarget);
93     UNUSED_PARAM(readOffset);
94     UNUSED_PARAM(writeOffset);
95     UNUSED_PARAM(size);
96 }
97
98 void WebGL2RenderingContext::getBufferSubData(GC3Denum target, GC3Dint64 offset, ArrayBufferView* returnedData)
99 {
100     UNUSED_PARAM(target);
101     UNUSED_PARAM(offset);
102     UNUSED_PARAM(returnedData);
103 }
104
105 void WebGL2RenderingContext::getBufferSubData(GC3Denum target, GC3Dint64 offset, ArrayBuffer* returnedData)
106 {
107     UNUSED_PARAM(target);
108     UNUSED_PARAM(offset);
109     UNUSED_PARAM(returnedData);
110 }
111
112 void WebGL2RenderingContext::blitFramebuffer(GC3Dint srcX0, GC3Dint srcY0, GC3Dint srcX1, GC3Dint srcY1, GC3Dint dstX0, GC3Dint dstY0, GC3Dint dstX1, GC3Dint dstY1, GC3Dbitfield mask, GC3Denum filter)
113 {
114     UNUSED_PARAM(srcX0);
115     UNUSED_PARAM(srcX1);
116     UNUSED_PARAM(srcY0);
117     UNUSED_PARAM(srcY1);
118     UNUSED_PARAM(dstX0);
119     UNUSED_PARAM(dstX1);
120     UNUSED_PARAM(dstY0);
121     UNUSED_PARAM(dstY1);
122     UNUSED_PARAM(mask);
123     UNUSED_PARAM(filter);
124 }
125
126 void WebGL2RenderingContext::framebufferTextureLayer(GC3Denum target, GC3Denum attachment, GC3Duint texture, GC3Dint level, GC3Dint layer)
127 {
128     UNUSED_PARAM(target);
129     UNUSED_PARAM(attachment);
130     UNUSED_PARAM(texture);
131     UNUSED_PARAM(level);
132     UNUSED_PARAM(layer);
133 }
134
135 WebGLGetInfo WebGL2RenderingContext::getInternalformatParameter(GC3Denum target, GC3Denum internalformat, GC3Denum pname)
136 {
137     UNUSED_PARAM(target);
138     UNUSED_PARAM(internalformat);
139     UNUSED_PARAM(pname);
140     return WebGLGetInfo();
141 }
142
143 void WebGL2RenderingContext::invalidateFramebuffer(GC3Denum target, Vector<GC3Denum> attachments)
144 {
145     UNUSED_PARAM(target);
146     UNUSED_PARAM(attachments);
147 }
148
149 void WebGL2RenderingContext::invalidateSubFramebuffer(GC3Denum target, Vector<GC3Denum> attachments, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
150 {
151     UNUSED_PARAM(target);
152     UNUSED_PARAM(attachments);
153     UNUSED_PARAM(x);
154     UNUSED_PARAM(y);
155     UNUSED_PARAM(width);
156     UNUSED_PARAM(height);
157 }
158
159 void WebGL2RenderingContext::readBuffer(GC3Denum src)
160 {
161     UNUSED_PARAM(src);
162 }
163
164 void WebGL2RenderingContext::renderbufferStorageMultisample(GC3Denum target, GC3Dsizei samples, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
165 {
166     UNUSED_PARAM(target);
167     UNUSED_PARAM(samples);
168     UNUSED_PARAM(internalformat);
169     UNUSED_PARAM(width);
170     UNUSED_PARAM(height);
171 }
172
173 void WebGL2RenderingContext::texStorage2D(GC3Denum target, GC3Dsizei levels, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
174 {
175     UNUSED_PARAM(target);
176     UNUSED_PARAM(levels);
177     UNUSED_PARAM(internalformat);
178     UNUSED_PARAM(width);
179     UNUSED_PARAM(height);
180 }
181
182 void WebGL2RenderingContext::texStorage3D(GC3Denum target, GC3Dsizei levels, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth)
183 {
184     UNUSED_PARAM(target);
185     UNUSED_PARAM(levels);
186     UNUSED_PARAM(internalformat);
187     UNUSED_PARAM(width);
188     UNUSED_PARAM(height);
189     UNUSED_PARAM(depth);
190 }
191
192 void WebGL2RenderingContext::texImage3D(GC3Denum target, GC3Dint level, GC3Dint internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Denum format, GC3Denum type, ArrayBufferView* pixels)
193 {
194     UNUSED_PARAM(target);
195     UNUSED_PARAM(level);
196     UNUSED_PARAM(internalformat);
197     UNUSED_PARAM(width);
198     UNUSED_PARAM(height);
199     UNUSED_PARAM(depth);
200     UNUSED_PARAM(border);
201     UNUSED_PARAM(format);
202     UNUSED_PARAM(type);
203     UNUSED_PARAM(pixels);
204 }
205
206 void WebGL2RenderingContext::texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, GC3Denum type, ArrayBufferView* pixels)
207 {
208     UNUSED_PARAM(target);
209     UNUSED_PARAM(level);
210     UNUSED_PARAM(xoffset);
211     UNUSED_PARAM(yoffset);
212     UNUSED_PARAM(zoffset);
213     UNUSED_PARAM(width);
214     UNUSED_PARAM(height);
215     UNUSED_PARAM(depth);
216     UNUSED_PARAM(format);
217     UNUSED_PARAM(type);
218     UNUSED_PARAM(pixels);
219 }
220
221 void WebGL2RenderingContext::texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, ImageData* source)
222 {
223     UNUSED_PARAM(target);
224     UNUSED_PARAM(level);
225     UNUSED_PARAM(xoffset);
226     UNUSED_PARAM(yoffset);
227     UNUSED_PARAM(zoffset);
228     UNUSED_PARAM(format);
229     UNUSED_PARAM(type);
230     UNUSED_PARAM(source);
231 }
232
233 void WebGL2RenderingContext::texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, HTMLImageElement* source)
234 {
235     UNUSED_PARAM(target);
236     UNUSED_PARAM(level);
237     UNUSED_PARAM(xoffset);
238     UNUSED_PARAM(yoffset);
239     UNUSED_PARAM(zoffset);
240     UNUSED_PARAM(format);
241     UNUSED_PARAM(type);
242     UNUSED_PARAM(source);
243 }
244
245 void WebGL2RenderingContext::texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, HTMLCanvasElement* source)
246 {
247     UNUSED_PARAM(target);
248     UNUSED_PARAM(level);
249     UNUSED_PARAM(xoffset);
250     UNUSED_PARAM(yoffset);
251     UNUSED_PARAM(zoffset);
252     UNUSED_PARAM(format);
253     UNUSED_PARAM(type);
254     UNUSED_PARAM(source);
255 }
256
257 void WebGL2RenderingContext::texSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Denum format, GC3Denum type, HTMLVideoElement* source)
258 {
259     UNUSED_PARAM(target);
260     UNUSED_PARAM(level);
261     UNUSED_PARAM(xoffset);
262     UNUSED_PARAM(yoffset);
263     UNUSED_PARAM(zoffset);
264     UNUSED_PARAM(format);
265     UNUSED_PARAM(type);
266     UNUSED_PARAM(source);
267 }
268
269 void WebGL2RenderingContext::copyTexSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
270 {
271     UNUSED_PARAM(target);
272     UNUSED_PARAM(level);
273     UNUSED_PARAM(xoffset);
274     UNUSED_PARAM(yoffset);
275     UNUSED_PARAM(zoffset);
276     UNUSED_PARAM(x);
277     UNUSED_PARAM(y);
278     UNUSED_PARAM(width);
279     UNUSED_PARAM(height);
280 }
281
282 void WebGL2RenderingContext::compressedTexImage3D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Dint border, GC3Dsizei imageSize, ArrayBufferView* data)
283 {
284     UNUSED_PARAM(target);
285     UNUSED_PARAM(level);
286     UNUSED_PARAM(internalformat);
287     UNUSED_PARAM(width);
288     UNUSED_PARAM(height);
289     UNUSED_PARAM(depth);
290     UNUSED_PARAM(border);
291     UNUSED_PARAM(imageSize);
292     UNUSED_PARAM(data);
293 }
294
295 void WebGL2RenderingContext::compressedTexSubImage3D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint zoffset, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth, GC3Denum format, GC3Dsizei imageSize, ArrayBufferView* data)
296 {
297     UNUSED_PARAM(target);
298     UNUSED_PARAM(level);
299     UNUSED_PARAM(xoffset);
300     UNUSED_PARAM(yoffset);
301     UNUSED_PARAM(zoffset);
302     UNUSED_PARAM(width);
303     UNUSED_PARAM(height);
304     UNUSED_PARAM(depth);
305     UNUSED_PARAM(format);
306     UNUSED_PARAM(imageSize);
307     UNUSED_PARAM(data);
308 }
309
310 GC3Dint WebGL2RenderingContext::getFragDataLocation(WebGLProgram* program, String name)
311 {
312     UNUSED_PARAM(program);
313     UNUSED_PARAM(name);
314     return 0;
315 }
316
317 void WebGL2RenderingContext::uniform1ui(WebGLUniformLocation* location, GC3Duint v0)
318 {
319     UNUSED_PARAM(location);
320     UNUSED_PARAM(v0);
321 }
322
323 void WebGL2RenderingContext::uniform2ui(WebGLUniformLocation* location, GC3Duint v0, GC3Duint v1)
324 {
325     UNUSED_PARAM(location);
326     UNUSED_PARAM(v0);
327     UNUSED_PARAM(v1);
328 }
329
330 void WebGL2RenderingContext::uniform3ui(WebGLUniformLocation* location, GC3Duint v0, GC3Duint v1, GC3Duint v2)
331 {
332     UNUSED_PARAM(location);
333     UNUSED_PARAM(v0);
334     UNUSED_PARAM(v1);
335     UNUSED_PARAM(v2);
336 }
337
338 void WebGL2RenderingContext::uniform4ui(WebGLUniformLocation* location, GC3Duint v0, GC3Duint v1, GC3Duint v2, GC3Duint v3)
339 {
340     UNUSED_PARAM(location);
341     UNUSED_PARAM(v0);
342     UNUSED_PARAM(v1);
343     UNUSED_PARAM(v2);
344     UNUSED_PARAM(v3);
345 }
346
347 void WebGL2RenderingContext::uniform1uiv(WebGLUniformLocation* location, Uint32Array* value)
348 {
349     UNUSED_PARAM(location);
350     UNUSED_PARAM(value);
351 }
352
353 void WebGL2RenderingContext::uniform2uiv(WebGLUniformLocation* location, Uint32Array* value)
354 {
355     UNUSED_PARAM(location);
356     UNUSED_PARAM(value);
357 }
358
359 void WebGL2RenderingContext::uniform3uiv(WebGLUniformLocation* location, Uint32Array* value)
360 {
361     UNUSED_PARAM(location);
362     UNUSED_PARAM(value);
363 }
364
365 void WebGL2RenderingContext::uniform4uiv(WebGLUniformLocation* location, Uint32Array* value)
366 {
367     UNUSED_PARAM(location);
368     UNUSED_PARAM(value);
369 }
370
371 void WebGL2RenderingContext::uniformMatrix2x3fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
372 {
373     UNUSED_PARAM(location);
374     UNUSED_PARAM(transpose);
375     UNUSED_PARAM(value);
376 }
377
378 void WebGL2RenderingContext::uniformMatrix3x2fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
379 {
380     UNUSED_PARAM(location);
381     UNUSED_PARAM(transpose);
382     UNUSED_PARAM(value);
383 }
384
385 void WebGL2RenderingContext::uniformMatrix2x4fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
386 {
387     UNUSED_PARAM(location);
388     UNUSED_PARAM(transpose);
389     UNUSED_PARAM(value);
390 }
391
392 void WebGL2RenderingContext::uniformMatrix4x2fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
393 {
394     UNUSED_PARAM(location);
395     UNUSED_PARAM(transpose);
396     UNUSED_PARAM(value);
397 }
398
399 void WebGL2RenderingContext::uniformMatrix3x4fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
400 {
401     UNUSED_PARAM(location);
402     UNUSED_PARAM(transpose);
403     UNUSED_PARAM(value);
404 }
405
406 void WebGL2RenderingContext::uniformMatrix4x3fv(WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value)
407 {
408     UNUSED_PARAM(location);
409     UNUSED_PARAM(transpose);
410     UNUSED_PARAM(value);
411 }
412
413 void WebGL2RenderingContext::vertexAttribI4i(GC3Duint index, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w)
414 {
415     UNUSED_PARAM(index);
416     UNUSED_PARAM(x);
417     UNUSED_PARAM(y);
418     UNUSED_PARAM(z);
419     UNUSED_PARAM(w);
420 }
421
422 void WebGL2RenderingContext::vertexAttribI4iv(GC3Duint index, Int32Array* v)
423 {
424     UNUSED_PARAM(index);
425     UNUSED_PARAM(v);
426 }
427
428 void WebGL2RenderingContext::vertexAttribI4ui(GC3Duint index, GC3Duint x, GC3Duint y, GC3Duint z, GC3Duint w)
429 {
430     UNUSED_PARAM(index);
431     UNUSED_PARAM(x);
432     UNUSED_PARAM(y);
433     UNUSED_PARAM(z);
434     UNUSED_PARAM(w);
435 }
436
437 void WebGL2RenderingContext::vertexAttribI4uiv(GC3Duint index, Uint32Array* v)
438 {
439     UNUSED_PARAM(index);
440     UNUSED_PARAM(v);
441 }
442
443 void WebGL2RenderingContext::vertexAttribIPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dsizei stride, GC3Dint64 offset)
444 {
445     UNUSED_PARAM(index);
446     UNUSED_PARAM(size);
447     UNUSED_PARAM(type);
448     UNUSED_PARAM(stride);
449     UNUSED_PARAM(offset);
450 }
451
452 void WebGL2RenderingContext::clear(GC3Dbitfield mask)
453 {
454     if (isContextLostOrPending())
455         return;
456     if (mask & ~(GraphicsContext3D::COLOR_BUFFER_BIT | GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {
457         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clear", "invalid mask");
458         return;
459     }
460     if (m_framebufferBinding && (mask & GraphicsContext3D::COLOR_BUFFER_BIT) && isIntegerFormat(m_framebufferBinding->getColorBufferFormat())) {
461         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "clear", "cannot clear an integer buffer");
462         return;
463     }
464     const char* reason = "framebuffer incomplete";
465     if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {
466         synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "clear", reason);
467         return;
468     }
469     if (!clearIfComposited(mask))
470         m_context->clear(mask);
471     markContextChanged();
472 }
473
474 void WebGL2RenderingContext::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)
475 {
476     if (isContextLostOrPending())
477         return;
478     
479     WebGLRenderingContextBase::vertexAttribDivisor(index, divisor);
480 }
481
482 void WebGL2RenderingContext::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei instanceCount)
483 {
484     if (isContextLostOrPending())
485         return;
486
487     WebGLRenderingContextBase::drawArraysInstanced(mode, first, count, instanceCount);
488 }
489
490 void WebGL2RenderingContext::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dint64 offset, GC3Dsizei instanceCount)
491 {
492     if (isContextLostOrPending())
493         return;
494
495     WebGLRenderingContextBase::drawElementsInstanced(mode, count, type, offset, instanceCount);
496 }
497
498 void WebGL2RenderingContext::drawRangeElements(GC3Denum mode, GC3Duint start, GC3Duint end, GC3Dsizei count, GC3Denum type, GC3Dint64 offset)
499 {
500     UNUSED_PARAM(mode);
501     UNUSED_PARAM(start);
502     UNUSED_PARAM(end);
503     UNUSED_PARAM(count);
504     UNUSED_PARAM(type);
505     UNUSED_PARAM(offset);
506 }
507
508 void WebGL2RenderingContext::drawBuffers(Vector<GC3Denum> buffers)
509 {
510     if (isContextLost())
511         return;
512     GC3Dsizei n = buffers.size();
513     const GC3Denum* bufs = buffers.data();
514     if (!m_framebufferBinding) {
515         if (n != 1) {
516             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "drawBuffers", "more than one buffer");
517             return;
518         }
519         if (bufs[0] != GraphicsContext3D::BACK && bufs[0] != GraphicsContext3D::NONE) {
520             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "drawBuffers", "BACK or NONE");
521             return;
522         }
523         // Because the backbuffer is simulated on all current WebKit ports, we need to change BACK to COLOR_ATTACHMENT0.
524         GC3Denum value = (bufs[0] == GraphicsContext3D::BACK) ? GraphicsContext3D::COLOR_ATTACHMENT0 : GraphicsContext3D::NONE;
525         graphicsContext3D()->getExtensions()->drawBuffersEXT(1, &value);
526         setBackDrawBuffer(bufs[0]);
527     } else {
528         if (n > getMaxDrawBuffers()) {
529             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "drawBuffers", "more than max draw buffers");
530             return;
531         }
532         for (GC3Dsizei i = 0; i < n; ++i) {
533             if (bufs[i] != GraphicsContext3D::NONE && bufs[i] != static_cast<GC3Denum>(GraphicsContext3D::COLOR_ATTACHMENT0 + i)) {
534                 synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "drawBuffers", "COLOR_ATTACHMENTi or NONE");
535                 return;
536             }
537         }
538         m_framebufferBinding->drawBuffers(buffers);
539     }
540 }
541
542 void WebGL2RenderingContext::clearBufferiv(GC3Denum buffer, GC3Dint drawbuffer, Int32Array* value)
543 {
544     UNUSED_PARAM(value);
545     switch (buffer) {
546     case GraphicsContext3D::COLOR:
547         if (drawbuffer < 0 || drawbuffer >= getMaxDrawBuffers()) {
548             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferiv", "buffer index out of range");
549             return;
550         }
551         // TODO: Call clearBufferiv, requires gl3.h and ES3/gl.h
552         break;
553     case GraphicsContext3D::STENCIL:
554         if (drawbuffer) {
555             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferiv", "buffer index must be 0");
556             return;
557         }
558         // TODO: Call clearBufferiv, requires gl3.h and ES3/gl.h
559         break;
560     case GraphicsContext3D::DEPTH:
561     case GraphicsContext3D::DEPTH_STENCIL:
562     default:
563         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "clearBufferiv", "buffer argument must be COLOR or STENCIL");
564         break;
565     }
566 }
567
568 void WebGL2RenderingContext::clearBufferuiv(GC3Denum buffer, GC3Dint drawbuffer, Uint32Array* value)
569 {
570     UNUSED_PARAM(value);
571     switch (buffer) {
572     case GraphicsContext3D::COLOR:
573         if (drawbuffer < 0 || drawbuffer >= getMaxDrawBuffers()) {
574             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferuiv", "buffer index out of range");
575             return;
576         }
577         // TODO: Call clearBufferuiv, requires gl3.h and ES3/gl.h
578         break;
579     case GraphicsContext3D::DEPTH:
580     case GraphicsContext3D::STENCIL:
581     case GraphicsContext3D::DEPTH_STENCIL:
582     default:
583         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "clearBufferuiv", "buffer argument must be COLOR");
584         break;
585     }
586 }
587
588 void WebGL2RenderingContext::clearBufferfv(GC3Denum buffer, GC3Dint drawbuffer, Float32Array* value)
589 {
590     UNUSED_PARAM(value);
591     switch (buffer) {
592     case GraphicsContext3D::COLOR:
593         if (drawbuffer < 0 || drawbuffer >= getMaxDrawBuffers()) {
594             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferfv", "buffer index out of range");
595             return;
596         }
597         // TODO: Call clearBufferfv, requires gl3.h and ES3/gl.h
598         break;
599     case GraphicsContext3D::DEPTH:
600         if (drawbuffer) {
601             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferfv", "buffer index must be 0");
602             return;
603         }
604         // TODO: Call clearBufferfv, requires gl3.h and ES3/gl.h
605         break;
606     case GraphicsContext3D::STENCIL:
607     case GraphicsContext3D::DEPTH_STENCIL:
608     default:
609         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "clearBufferfv", "buffer argument must be COLOR OR DEPTH");
610         break;
611     }
612 }
613
614 void WebGL2RenderingContext::clearBufferfi(GC3Denum buffer, GC3Dint drawbuffer, GC3Dfloat depth, GC3Dint stencil)
615 {
616     UNUSED_PARAM(depth);
617     UNUSED_PARAM(stencil);
618     switch (buffer) {
619     case GraphicsContext3D::DEPTH_STENCIL:
620         if (drawbuffer) {
621             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferfv", "buffer index must be 0");
622             return;
623         }
624         // TODO: Call clearBufferfi, requires gl3.h and ES3/gl.h
625         break;
626     case GraphicsContext3D::COLOR:
627     case GraphicsContext3D::DEPTH:
628     case GraphicsContext3D::STENCIL:
629     default:
630         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "clearBufferfv", "buffer argument must be DEPTH_STENCIL");
631         break;
632     }
633 }
634
635 PassRefPtr<WebGLQuery> WebGL2RenderingContext::createQuery()
636 {
637     return nullptr;
638 }
639
640 void WebGL2RenderingContext::deleteQuery(WebGLQuery* query)
641 {
642     UNUSED_PARAM(query);
643 }
644
645 GC3Dboolean WebGL2RenderingContext::isQuery(WebGLQuery* query)
646 {
647     UNUSED_PARAM(query);
648     return false;
649 }
650
651 void WebGL2RenderingContext::beginQuery(GC3Denum target, WebGLQuery* query)
652 {
653     UNUSED_PARAM(target);
654     UNUSED_PARAM(query);
655 }
656
657 void WebGL2RenderingContext::endQuery(GC3Denum target)
658 {
659     UNUSED_PARAM(target);
660 }
661
662 PassRefPtr<WebGLQuery> WebGL2RenderingContext::getQuery(GC3Denum target, GC3Denum pname)
663 {
664     UNUSED_PARAM(target);
665     UNUSED_PARAM(pname);
666     return nullptr;
667 }
668
669 WebGLGetInfo WebGL2RenderingContext::getQueryParameter(WebGLQuery* query, GC3Denum pname)
670 {
671     UNUSED_PARAM(query);
672     UNUSED_PARAM(pname);
673     return WebGLGetInfo();
674 }
675
676 PassRefPtr<WebGLSampler> WebGL2RenderingContext::createSampler()
677 {
678     return nullptr;
679 }
680
681 void WebGL2RenderingContext::deleteSampler(WebGLSampler* sampler)
682 {
683     UNUSED_PARAM(sampler);
684 }
685
686 GC3Dboolean WebGL2RenderingContext::isSampler(WebGLSampler* sampler)
687 {
688     UNUSED_PARAM(sampler);
689     return false;
690 }
691
692 void WebGL2RenderingContext::bindSampler(GC3Duint unit, WebGLSampler* sampler)
693 {
694     UNUSED_PARAM(unit);
695     UNUSED_PARAM(sampler);
696 }
697
698 void WebGL2RenderingContext::samplerParameteri(WebGLSampler* sampler, GC3Denum pname, GC3Dint param)
699 {
700     UNUSED_PARAM(sampler);
701     UNUSED_PARAM(pname);
702     UNUSED_PARAM(param);
703 }
704
705 void WebGL2RenderingContext::samplerParameterf(WebGLSampler* sampler, GC3Denum pname, GC3Dfloat param)
706 {
707     UNUSED_PARAM(sampler);
708     UNUSED_PARAM(pname);
709     UNUSED_PARAM(param);
710 }
711
712 WebGLGetInfo WebGL2RenderingContext::getSamplerParameter(WebGLSampler* sampler, GC3Denum pname)
713 {
714     UNUSED_PARAM(sampler);
715     UNUSED_PARAM(pname);
716     return WebGLGetInfo();
717 }
718
719 PassRefPtr<WebGLSync> WebGL2RenderingContext::fenceSync(GC3Denum condition, GC3Dbitfield flags)
720 {
721     UNUSED_PARAM(condition);
722     UNUSED_PARAM(flags);
723     return nullptr;
724 }
725
726 GC3Dboolean WebGL2RenderingContext::isSync(WebGLSync* sync)
727 {
728     UNUSED_PARAM(sync);
729     return false;
730 }
731
732 void WebGL2RenderingContext::deleteSync(WebGLSync* sync)
733 {
734     UNUSED_PARAM(sync);
735 }
736
737 GC3Denum WebGL2RenderingContext::clientWaitSync(WebGLSync* sync, GC3Dbitfield flags, GC3Duint64 timeout)
738 {
739     UNUSED_PARAM(sync);
740     UNUSED_PARAM(flags);
741     UNUSED_PARAM(timeout);
742     return 0;
743 }
744
745 void WebGL2RenderingContext::waitSync(WebGLSync* sync, GC3Dbitfield flags, GC3Duint64 timeout)
746 {
747     UNUSED_PARAM(sync);
748     UNUSED_PARAM(flags);
749     UNUSED_PARAM(timeout);
750 }
751
752 WebGLGetInfo WebGL2RenderingContext::getSyncParameter(WebGLSync* sync, GC3Denum pname)
753 {
754     UNUSED_PARAM(sync);
755     UNUSED_PARAM(pname);
756     return WebGLGetInfo();
757 }
758
759 PassRefPtr<WebGLTransformFeedback> WebGL2RenderingContext::createTransformFeedback()
760 {
761     return nullptr;
762 }
763
764 void WebGL2RenderingContext::deleteTransformFeedback(WebGLTransformFeedback* id)
765 {
766     UNUSED_PARAM(id);
767 }
768
769 GC3Dboolean WebGL2RenderingContext::isTransformFeedback(WebGLTransformFeedback* id)
770 {
771     UNUSED_PARAM(id);
772     return false;
773 }
774
775 void WebGL2RenderingContext::bindTransformFeedback(GC3Denum target, WebGLTransformFeedback* id)
776 {
777     UNUSED_PARAM(target);
778     UNUSED_PARAM(id);
779 }
780
781 void WebGL2RenderingContext::beginTransformFeedback(GC3Denum primitiveMode)
782 {
783     UNUSED_PARAM(primitiveMode);
784 }
785
786 void WebGL2RenderingContext::endTransformFeedback()
787 {
788 }
789
790 void WebGL2RenderingContext::transformFeedbackVaryings(WebGLProgram* program, Vector<String> varyings, GC3Denum bufferMode)
791 {
792     UNUSED_PARAM(program);
793     UNUSED_PARAM(varyings);
794     UNUSED_PARAM(bufferMode);
795 }
796
797 PassRefPtr<WebGLActiveInfo> WebGL2RenderingContext::getTransformFeedbackVarying(WebGLProgram* program, GC3Duint index)
798 {
799     UNUSED_PARAM(program);
800     UNUSED_PARAM(index);
801     return nullptr;
802 }
803
804 void WebGL2RenderingContext::pauseTransformFeedback()
805 {
806 }
807
808 void WebGL2RenderingContext::resumeTransformFeedback()
809 {
810 }
811
812 void WebGL2RenderingContext::bindBufferBase(GC3Denum target, GC3Duint index, WebGLBuffer* buffer)
813 {
814     UNUSED_PARAM(target);
815     UNUSED_PARAM(index);
816     UNUSED_PARAM(buffer);
817 }
818
819 void WebGL2RenderingContext::bindBufferRange(GC3Denum target, GC3Duint index, WebGLBuffer* buffer, GC3Dint64 offset, GC3Dint64 size)
820 {
821     UNUSED_PARAM(target);
822     UNUSED_PARAM(index);
823     UNUSED_PARAM(buffer);
824     UNUSED_PARAM(offset);
825     UNUSED_PARAM(size);
826 }
827
828 WebGLGetInfo WebGL2RenderingContext::getIndexedParameter(GC3Denum target, GC3Duint index)
829 {
830     UNUSED_PARAM(target);
831     UNUSED_PARAM(index);
832     switch (target) {
833     case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER_BINDING:
834     case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER_SIZE:
835     case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER_START:
836     case GraphicsContext3D::UNIFORM_BUFFER_BINDING:
837     case GraphicsContext3D::UNIFORM_BUFFER_SIZE:
838     case GraphicsContext3D::UNIFORM_BUFFER_START:
839         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getIndexedParameter", "parameter name not yet supported");
840         return WebGLGetInfo();
841     default:
842         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getIndexedParameter", "invalid parameter name");
843         return WebGLGetInfo();
844             
845     }
846     return WebGLGetInfo();
847 }
848
849 Uint32Array* WebGL2RenderingContext::getUniformIndices(WebGLProgram* program, Vector<String> uniformNames)
850 {
851     UNUSED_PARAM(program);
852     UNUSED_PARAM(uniformNames);
853     return nullptr;
854 }
855
856 Int32Array* WebGL2RenderingContext::getActiveUniforms(WebGLProgram* program, Uint32Array* uniformIndices, GC3Denum pname)
857 {
858     UNUSED_PARAM(program);
859     UNUSED_PARAM(uniformIndices);
860     UNUSED_PARAM(pname);
861     return nullptr;
862 }
863
864 GC3Duint WebGL2RenderingContext::getUniformBlockIndex(WebGLProgram* program, String uniformBlockName)
865 {
866     UNUSED_PARAM(program);
867     UNUSED_PARAM(uniformBlockName);
868     return 0;
869 }
870
871 WebGLGetInfo WebGL2RenderingContext::getActiveUniformBlockParameter(WebGLProgram* program, GC3Duint uniformBlockIndex, GC3Denum pname)
872 {
873     UNUSED_PARAM(program);
874     UNUSED_PARAM(uniformBlockIndex);
875     UNUSED_PARAM(pname);
876     return WebGLGetInfo();
877 }
878
879 WebGLGetInfo WebGL2RenderingContext::getActiveUniformBlockName(WebGLProgram* program, GC3Duint uniformBlockIndex)
880 {
881     UNUSED_PARAM(program);
882     UNUSED_PARAM(uniformBlockIndex);
883     return WebGLGetInfo();
884 }
885
886 void WebGL2RenderingContext::uniformBlockBinding(WebGLProgram* program, GC3Duint uniformBlockIndex, GC3Duint uniformBlockBinding)
887 {
888     UNUSED_PARAM(program);
889     UNUSED_PARAM(uniformBlockIndex);
890     UNUSED_PARAM(uniformBlockBinding);
891 }
892
893 PassRefPtr<WebGLVertexArrayObject> WebGL2RenderingContext::createVertexArray()
894 {
895     if (isContextLost())
896         return 0;
897     
898     RefPtr<WebGLVertexArrayObject> o = WebGLVertexArrayObject::create(this, WebGLVertexArrayObject::VAOTypeUser);
899     addContextObject(o.get());
900     return o.release();
901 }
902
903 void WebGL2RenderingContext::deleteVertexArray(WebGLVertexArrayObject* arrayObject)
904 {
905     if (!arrayObject || isContextLost())
906         return;
907     
908     if (arrayObject->isDeleted())
909         return;
910     
911     if (!arrayObject->isDefaultObject() && arrayObject == m_boundVertexArrayObject)
912         setBoundVertexArrayObject(0);
913     
914     arrayObject->deleteObject(graphicsContext3D());
915 }
916
917 GC3Dboolean WebGL2RenderingContext::isVertexArray(WebGLVertexArrayObject* arrayObject)
918 {
919     if (!arrayObject || isContextLost())
920         return 0;
921     
922     if (!arrayObject->hasEverBeenBound() || !arrayObject->validate(0, this))
923         return 0;
924     
925     return m_context->isVertexArray(arrayObject->object());
926 }
927
928 void WebGL2RenderingContext::bindVertexArray(WebGLVertexArrayObject* arrayObject)
929 {
930     if (isContextLost())
931         return;
932     
933     if (arrayObject && (arrayObject->isDeleted() || !arrayObject->validate(0, this) || !m_contextObjects.contains(arrayObject))) {
934         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
935         return;
936     }
937     if (arrayObject && !arrayObject->isDefaultObject() && arrayObject->object()) {
938         m_context->bindVertexArray(arrayObject->object());
939         
940         arrayObject->setHasEverBeenBound();
941         setBoundVertexArrayObject(arrayObject);
942     } else {
943         m_context->bindVertexArray(m_defaultVertexArrayObject->object());
944         setBoundVertexArrayObject(m_defaultVertexArrayObject);
945     }
946 }
947
948 WebGLExtension* WebGL2RenderingContext::getExtension(const String& name)
949 {
950     if (isContextLostOrPending())
951         return nullptr;
952
953     if (equalIgnoringCase(name, "WEBKIT_EXT_texture_filter_anisotropic")
954         && m_context->getExtensions()->supports("GL_EXT_texture_filter_anisotropic")) {
955         if (!m_extTextureFilterAnisotropic) {
956             m_context->getExtensions()->ensureEnabled("GL_EXT_texture_filter_anisotropic");
957             m_extTextureFilterAnisotropic = std::make_unique<EXTTextureFilterAnisotropic>(this);
958         }
959         return m_extTextureFilterAnisotropic.get();
960     }
961     if (equalIgnoringCase(name, "OES_texture_float")
962         && m_context->getExtensions()->supports("GL_OES_texture_float")) {
963         if (!m_oesTextureFloat) {
964             m_context->getExtensions()->ensureEnabled("GL_OES_texture_float");
965             m_oesTextureFloat = std::make_unique<OESTextureFloat>(this);
966         }
967         return m_oesTextureFloat.get();
968     }
969     if (equalIgnoringCase(name, "OES_texture_float_linear")
970         && m_context->getExtensions()->supports("GL_OES_texture_float_linear")) {
971         if (!m_oesTextureFloatLinear) {
972             m_context->getExtensions()->ensureEnabled("GL_OES_texture_float_linear");
973             m_oesTextureFloatLinear = std::make_unique<OESTextureFloatLinear>(this);
974         }
975         return m_oesTextureFloatLinear.get();
976     }
977     if (equalIgnoringCase(name, "OES_texture_half_float")
978         && m_context->getExtensions()->supports("GL_OES_texture_half_float")) {
979         if (!m_oesTextureHalfFloat) {
980             m_context->getExtensions()->ensureEnabled("GL_OES_texture_half_float");
981             m_oesTextureHalfFloat = std::make_unique<OESTextureHalfFloat>(this);
982         }
983         return m_oesTextureHalfFloat.get();
984     }
985     if (equalIgnoringCase(name, "OES_texture_half_float_linear")
986         && m_context->getExtensions()->supports("GL_OES_texture_half_float_linear")) {
987         if (!m_oesTextureHalfFloatLinear) {
988             m_context->getExtensions()->ensureEnabled("GL_OES_texture_half_float_linear");
989             m_oesTextureHalfFloatLinear = std::make_unique<OESTextureHalfFloatLinear>(this);
990         }
991         return m_oesTextureHalfFloatLinear.get();
992     }
993     if (equalIgnoringCase(name, "WEBGL_lose_context")) {
994         if (!m_webglLoseContext)
995             m_webglLoseContext = std::make_unique<WebGLLoseContext>(this);
996         return m_webglLoseContext.get();
997     }
998     if ((equalIgnoringCase(name, "WEBKIT_WEBGL_compressed_texture_atc"))
999         && WebGLCompressedTextureATC::supported(this)) {
1000         if (!m_webglCompressedTextureATC)
1001             m_webglCompressedTextureATC = std::make_unique<WebGLCompressedTextureATC>(this);
1002         return m_webglCompressedTextureATC.get();
1003     }
1004     if ((equalIgnoringCase(name, "WEBKIT_WEBGL_compressed_texture_pvrtc"))
1005         && WebGLCompressedTexturePVRTC::supported(this)) {
1006         if (!m_webglCompressedTexturePVRTC)
1007             m_webglCompressedTexturePVRTC = std::make_unique<WebGLCompressedTexturePVRTC>(this);
1008         return m_webglCompressedTexturePVRTC.get();
1009     }
1010     if (equalIgnoringCase(name, "WEBGL_compressed_texture_s3tc")
1011         && WebGLCompressedTextureS3TC::supported(this)) {
1012         if (!m_webglCompressedTextureS3TC)
1013             m_webglCompressedTextureS3TC = std::make_unique<WebGLCompressedTextureS3TC>(this);
1014         return m_webglCompressedTextureS3TC.get();
1015     }
1016     if (equalIgnoringCase(name, "WEBGL_depth_texture")
1017         && WebGLDepthTexture::supported(graphicsContext3D())) {
1018         if (!m_webglDepthTexture) {
1019             m_context->getExtensions()->ensureEnabled("GL_CHROMIUM_depth_texture");
1020             m_webglDepthTexture = std::make_unique<WebGLDepthTexture>(this);
1021         }
1022         return m_webglDepthTexture.get();
1023     }
1024     if (allowPrivilegedExtensions()) {
1025         if (equalIgnoringCase(name, "WEBGL_debug_renderer_info")) {
1026             if (!m_webglDebugRendererInfo)
1027                 m_webglDebugRendererInfo = std::make_unique<WebGLDebugRendererInfo>(this);
1028             return m_webglDebugRendererInfo.get();
1029         }
1030         if (equalIgnoringCase(name, "WEBGL_debug_shaders")
1031             && m_context->getExtensions()->supports("GL_ANGLE_translated_shader_source")) {
1032             if (!m_webglDebugShaders)
1033                 m_webglDebugShaders = std::make_unique<WebGLDebugShaders>(this);
1034             return m_webglDebugShaders.get();
1035         }
1036     }
1037     
1038     return nullptr;
1039 }
1040
1041 Vector<String> WebGL2RenderingContext::getSupportedExtensions()
1042 {
1043     Vector<String> result;
1044     
1045     if (m_isPendingPolicyResolution)
1046         return result;
1047
1048     if (m_context->getExtensions()->supports("GL_OES_texture_float"))
1049         result.append("OES_texture_float");
1050     if (m_context->getExtensions()->supports("GL_OES_texture_float_linear"))
1051         result.append("OES_texture_float_linear");
1052     if (m_context->getExtensions()->supports("GL_OES_texture_half_float"))
1053         result.append("OES_texture_half_float");
1054     if (m_context->getExtensions()->supports("GL_OES_texture_half_float_linear"))
1055         result.append("OES_texture_half_float_linear");
1056     if (m_context->getExtensions()->supports("GL_EXT_texture_filter_anisotropic"))
1057         result.append("WEBKIT_EXT_texture_filter_anisotropic");
1058     if (WebGLCompressedTextureATC::supported(this))
1059         result.append("WEBKIT_WEBGL_compressed_texture_atc");
1060     if (WebGLCompressedTexturePVRTC::supported(this))
1061         result.append("WEBKIT_WEBGL_compressed_texture_pvrtc");
1062     if (WebGLCompressedTextureS3TC::supported(this))
1063         result.append("WEBGL_compressed_texture_s3tc");
1064     if (WebGLDepthTexture::supported(graphicsContext3D()))
1065         result.append("WEBGL_depth_texture");
1066     result.append("WEBGL_lose_context");
1067     if (allowPrivilegedExtensions()) {
1068         if (m_context->getExtensions()->supports("GL_ANGLE_translated_shader_source"))
1069             result.append("WEBGL_debug_shaders");
1070         result.append("WEBGL_debug_renderer_info");
1071     }
1072     
1073     return result;
1074 }
1075
1076 WebGLGetInfo WebGL2RenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode& ec)
1077 {
1078     UNUSED_PARAM(ec);
1079     if (isContextLostOrPending() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))
1080         return WebGLGetInfo();
1081     
1082     if (!m_framebufferBinding || !m_framebufferBinding->object()) {
1083         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getFramebufferAttachmentParameter", "no framebuffer bound");
1084         return WebGLGetInfo();
1085     }
1086     
1087     WebGLSharedObject* object = m_framebufferBinding->getAttachmentObject(attachment);
1088     if (!object) {
1089         if (pname == GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)
1090             return WebGLGetInfo(GraphicsContext3D::NONE);
1091         // OpenGL ES 2.0 specifies INVALID_ENUM in this case, while desktop GL
1092         // specifies INVALID_OPERATION.
1093         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name");
1094         return WebGLGetInfo();
1095     }
1096     
1097     ASSERT(object->isTexture() || object->isRenderbuffer());
1098     if (object->isTexture()) {
1099         switch (pname) {
1100         case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
1101             return WebGLGetInfo(GraphicsContext3D::TEXTURE);
1102         case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
1103             return WebGLGetInfo(PassRefPtr<WebGLTexture>(reinterpret_cast<WebGLTexture*>(object)));
1104         case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
1105         case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
1106         case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: {
1107             GC3Dint value = 0;
1108             m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
1109             return WebGLGetInfo(value);
1110         }
1111         default:
1112             synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for texture attachment");
1113             return WebGLGetInfo();
1114         }
1115     } else {
1116         switch (pname) {
1117         case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
1118             return WebGLGetInfo(GraphicsContext3D::RENDERBUFFER);
1119         case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
1120             return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(reinterpret_cast<WebGLRenderbuffer*>(object)));
1121         case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING : {
1122             WebGLRenderbuffer* renderBuffer = reinterpret_cast<WebGLRenderbuffer*>(object);
1123             GC3Denum renderBufferFormat = renderBuffer->getInternalFormat();
1124             if (renderBufferFormat == GraphicsContext3D::SRGB8_ALPHA8
1125                 || renderBufferFormat == GraphicsContext3D::COMPRESSED_SRGB8_ETC2
1126                 || renderBufferFormat == GraphicsContext3D::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
1127                 || renderBufferFormat == GraphicsContext3D::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2) {
1128                 return WebGLGetInfo(GraphicsContext3D::SRGB);
1129             }
1130             return WebGLGetInfo(GraphicsContext3D::LINEAR);
1131         }
1132         default:
1133             synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for renderbuffer attachment");
1134             return WebGLGetInfo();
1135         }
1136     }
1137 }
1138
1139 bool WebGL2RenderingContext::validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment)
1140 {
1141     if (target != GraphicsContext3D::FRAMEBUFFER) {
1142         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");
1143         return false;
1144     }
1145     switch (attachment) {
1146     case GraphicsContext3D::COLOR_ATTACHMENT0:
1147     case GraphicsContext3D::DEPTH_ATTACHMENT:
1148     case GraphicsContext3D::STENCIL_ATTACHMENT:
1149     case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:
1150         break;
1151     default:
1152         if (attachment > GraphicsContext3D::COLOR_ATTACHMENT0
1153             && attachment < static_cast<GC3Denum>(GraphicsContext3D::COLOR_ATTACHMENT0 + getMaxColorAttachments()))
1154             break;
1155         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid attachment");
1156         return false;
1157     }
1158     return true;
1159 }
1160
1161 GC3Dint WebGL2RenderingContext::getMaxDrawBuffers()
1162 {
1163     if (!m_maxDrawBuffers)
1164         m_context->getIntegerv(GraphicsContext3D::MAX_DRAW_BUFFERS, &m_maxDrawBuffers);
1165     return m_maxDrawBuffers;
1166 }
1167
1168 GC3Dint WebGL2RenderingContext::getMaxColorAttachments()
1169 {
1170     // DrawBuffers requires MAX_COLOR_ATTACHMENTS == MAX_DRAW_BUFFERS
1171     if (!m_maxColorAttachments)
1172         m_context->getIntegerv(GraphicsContext3D::MAX_DRAW_BUFFERS, &m_maxColorAttachments);
1173     return m_maxColorAttachments;
1174 }
1175
1176 void WebGL2RenderingContext::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
1177 {
1178     if (isContextLostOrPending())
1179         return;
1180     if (target != GraphicsContext3D::RENDERBUFFER) {
1181         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid target");
1182         return;
1183     }
1184     if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {
1185         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "renderbufferStorage", "no bound renderbuffer");
1186         return;
1187     }
1188     if (!validateSize("renderbufferStorage", width, height))
1189         return;
1190     switch (internalformat) {
1191     case GraphicsContext3D::DEPTH_COMPONENT16:
1192     case GraphicsContext3D::DEPTH_COMPONENT32F:
1193     case GraphicsContext3D::DEPTH_COMPONENT24:
1194     case GraphicsContext3D::RGBA32I:
1195     case GraphicsContext3D::RGBA32UI:
1196     case GraphicsContext3D::RGBA16I:
1197     case GraphicsContext3D::RGBA16UI:
1198     case GraphicsContext3D::RGBA8:
1199     case GraphicsContext3D::RGBA8I:
1200     case GraphicsContext3D::RGBA8UI:
1201     case GraphicsContext3D::RGB10_A2:
1202     case GraphicsContext3D::RGB10_A2UI:
1203     case GraphicsContext3D::RGBA4:
1204     case GraphicsContext3D::RG32I:
1205     case GraphicsContext3D::RG32UI:
1206     case GraphicsContext3D::RG16I:
1207     case GraphicsContext3D::RG16UI:
1208     case GraphicsContext3D::RG8:
1209     case GraphicsContext3D::RG8I:
1210     case GraphicsContext3D::RG8UI:
1211     case GraphicsContext3D::R32I:
1212     case GraphicsContext3D::R32UI:
1213     case GraphicsContext3D::R16I:
1214     case GraphicsContext3D::R16UI:
1215     case GraphicsContext3D::R8:
1216     case GraphicsContext3D::R8I:
1217     case GraphicsContext3D::R8UI:
1218     case GraphicsContext3D::RGB5_A1:
1219     case GraphicsContext3D::RGB565:
1220     case GraphicsContext3D::STENCIL_INDEX8:
1221     case GraphicsContext3D::SRGB8_ALPHA8:
1222         m_context->renderbufferStorage(target, internalformat, width, height);
1223         m_renderbufferBinding->setInternalFormat(internalformat);
1224         m_renderbufferBinding->setIsValid(true);
1225         m_renderbufferBinding->setSize(width, height);
1226         break;
1227     case GraphicsContext3D::DEPTH32F_STENCIL8:
1228     case GraphicsContext3D::DEPTH24_STENCIL8:
1229         if (!isDepthStencilSupported()) {
1230             synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid internalformat");
1231             return;
1232         }
1233         m_context->renderbufferStorage(target, internalformat, width, height);
1234         m_renderbufferBinding->setSize(width, height);
1235         m_renderbufferBinding->setIsValid(isDepthStencilSupported());
1236         m_renderbufferBinding->setInternalFormat(internalformat);
1237         break;
1238     default:
1239         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid internalformat");
1240         return;
1241     }
1242     applyStencilTest();
1243 }
1244
1245 void WebGL2RenderingContext::hint(GC3Denum target, GC3Denum mode)
1246 {
1247     if (isContextLostOrPending())
1248         return;
1249     bool isValid = false;
1250     switch (target) {
1251     case GraphicsContext3D::GENERATE_MIPMAP_HINT:
1252     case GraphicsContext3D::FRAGMENT_SHADER_DERIVATIVE_HINT:
1253         isValid = true;
1254         break;
1255     }
1256     if (!isValid) {
1257         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "hint", "invalid target");
1258         return;
1259     }
1260     m_context->hint(target, mode);
1261 }
1262
1263 void WebGL2RenderingContext::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border)
1264 {
1265     if (isContextLostOrPending())
1266         return;
1267     RefPtr<WebGLContextAttributes> attributes = getContextAttributes();
1268     GC3Denum bufferFormat = attributes->alpha() ? GraphicsContext3D::RGBA : GraphicsContext3D::RGB;
1269     if (!validateTexFuncParameters("copyTexImage2D", CopyTexImage, target, level, internalformat, width, height, border, bufferFormat, GraphicsContext3D::UNSIGNED_BYTE))
1270         return;
1271     if (!validateSettableTexFormat("copyTexImage2D", internalformat))
1272         return;
1273     WebGLTexture* tex = validateTextureBinding("copyTexImage2D", target, true);
1274     if (!tex)
1275         return;
1276     if (!isTexInternalFormatColorBufferCombinationValid(internalformat, getBoundFramebufferColorFormat())) {
1277         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyTexImage2D", "framebuffer is incompatible format");
1278         return;
1279     }
1280     if (!isGLES2NPOTStrict() && level && WebGLTexture::isNPOT(width, height)) {
1281         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexImage2D", "level > 0 not power of 2");
1282         return;
1283     }
1284     const char* reason = "framebuffer incomplete";
1285     if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {
1286         synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "copyTexImage2D", reason);
1287         return;
1288     }
1289     clearIfComposited();
1290     if (isResourceSafe())
1291         m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);
1292     else {
1293         GC3Dint clippedX, clippedY;
1294         GC3Dsizei clippedWidth, clippedHeight;
1295         if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {
1296             m_context->texImage2DResourceSafe(target, level, internalformat, width, height, border,
1297                 internalformat, GraphicsContext3D::UNSIGNED_BYTE, m_unpackAlignment);
1298             if (clippedWidth > 0 && clippedHeight > 0) {
1299                 m_context->copyTexSubImage2D(target, level, clippedX - x, clippedY - y,
1300                     clippedX, clippedY, clippedWidth, clippedHeight);
1301             }
1302         } else
1303             m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);
1304     }
1305     // FIXME: if the framebuffer is not complete, none of the below should be executed.
1306     tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
1307 }
1308
1309 void WebGL2RenderingContext::texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)
1310 {
1311     ec = 0;
1312     ASSERT(!isContextLost());
1313     if (!validateTexFuncParameters("texSubImage2D", TexSubImage, target, level, internalformat, width, height, 0, format, type))
1314         return;
1315     ASSERT(validateSize("texSubImage2D", xoffset, yoffset));
1316     ASSERT(validateSettableTexFormat("texSubImage2D", format));
1317     WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);
1318     if (!tex) {
1319         ASSERT_NOT_REACHED();
1320         return;
1321     }
1322     ASSERT((xoffset + width) >= 0);
1323     ASSERT((yoffset + height) >= 0);
1324     ASSERT(tex->getWidth(target, level) >= (xoffset + width));
1325     ASSERT(tex->getHeight(target, level) >= (yoffset + height));
1326     ASSERT(tex->getInternalFormat(target, level) == format);
1327     ASSERT(tex->getType(target, level) == type);
1328     m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
1329 }
1330
1331 void WebGL2RenderingContext::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)
1332 {
1333     ec = 0;
1334     Vector<uint8_t> data;
1335     GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);
1336     if (!imageExtractor.extractSucceeded()) {
1337         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "bad image");
1338         return;
1339     }
1340     GraphicsContext3D::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();
1341     GraphicsContext3D::AlphaOp alphaOp = imageExtractor.imageAlphaOp();
1342     const void* imagePixelData = imageExtractor.imagePixelData();
1343     
1344     bool needConversion = true;
1345     if (type == GraphicsContext3D::UNSIGNED_BYTE && sourceDataFormat == GraphicsContext3D::DataFormatRGBA8 && format == GraphicsContext3D::RGBA && alphaOp == GraphicsContext3D::AlphaDoNothing && !flipY)
1346         needConversion = false;
1347     else {
1348         if (!m_context->packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {
1349             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");
1350             return;
1351         }
1352     }
1353     
1354     if (m_unpackAlignment != 1)
1355         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
1356     
1357     WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);
1358     GC3Denum internalformat = tex->getInternalFormat(target, level);
1359     texSubImage2DBase(target, level, xoffset, yoffset, image->width(), image->height(), internalformat, format, type,  needConversion ? data.data() : imagePixelData, ec);
1360     if (m_unpackAlignment != 1)
1361         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
1362 }
1363
1364 void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode& ec)
1365 {
1366     if (isContextLostOrPending() || !validateTexFuncData("texSubImage2D", level, width, height, GraphicsContext3D::NONE, format, type, pixels, NullNotAllowed) || !validateTexFunc("texSubImage2D", TexSubImage, SourceArrayBufferView, target, level, GraphicsContext3D::NONE, width, height, 0, format, type, xoffset, yoffset))
1367         return;
1368     
1369     void* data = pixels->baseAddress();
1370     Vector<uint8_t> tempData;
1371     bool changeUnpackAlignment = false;
1372     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
1373         if (!m_context->extractTextureData(width, height, format, type,
1374             m_unpackAlignment,
1375             m_unpackFlipY, m_unpackPremultiplyAlpha,
1376             data,
1377             tempData))
1378             return;
1379         data = tempData.data();
1380         changeUnpackAlignment = true;
1381     }
1382     if (changeUnpackAlignment)
1383         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
1384     WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);
1385     GC3Denum internalformat = tex->getInternalFormat(target, level);
1386     texSubImage2DBase(target, level, xoffset, yoffset, width, height, internalformat, format, type, data, ec);
1387     if (changeUnpackAlignment)
1388         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
1389 }
1390
1391 void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)
1392 {
1393     ec = 0;
1394     if (isContextLostOrPending() || !pixels || !validateTexFunc("texSubImage2D", TexSubImage, SourceImageData, target, level, GraphicsContext3D::NONE,  pixels->width(), pixels->height(), 0, format, type, xoffset, yoffset))
1395         return;
1396     
1397     Vector<uint8_t> data;
1398     bool needConversion = true;
1399     // The data from ImageData is always of format RGBA8.
1400     // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.
1401     if (format == GraphicsContext3D::RGBA && type == GraphicsContext3D::UNSIGNED_BYTE && !m_unpackFlipY && !m_unpackPremultiplyAlpha)
1402         needConversion = false;
1403     else {
1404         if (!m_context->extractImageData(pixels, format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
1405             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "bad image data");
1406             return;
1407         }
1408     }
1409     if (m_unpackAlignment != 1)
1410         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
1411     
1412     WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);
1413     GC3Denum internalformat = tex->getInternalFormat(target, level);
1414     texSubImage2DBase(target, level, xoffset, yoffset, pixels->width(), pixels->height(), internalformat, format, type, needConversion ? data.data() : pixels->data()->data(), ec);
1415     if (m_unpackAlignment != 1)
1416         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
1417 }
1418
1419 void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)
1420 {
1421     ec = 0;
1422     if (isContextLostOrPending() || !validateHTMLImageElement("texSubImage2D", image, ec))
1423         return;
1424     
1425     RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());
1426     if (imageForRender->isSVGImage())
1427         imageForRender = drawImageIntoBuffer(imageForRender.get(), image->width(), image->height(), 1);
1428     
1429     if (!imageForRender || !validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLImageElement, target, level, GraphicsContext3D::NONE, imageForRender->width(), imageForRender->height(), 0, format, type, xoffset, yoffset))
1430         return;
1431     
1432     texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
1433 }
1434
1435 void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
1436     GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)
1437 {
1438     ec = 0;
1439     if (isContextLostOrPending() || !validateHTMLCanvasElement("texSubImage2D", canvas, ec)
1440         || !validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLCanvasElement, target, level, GraphicsContext3D::NONE, canvas->width(), canvas->height(), 0, format, type, xoffset, yoffset))
1441         return;
1442     
1443     RefPtr<ImageData> imageData = canvas->getImageData();
1444     if (imageData)
1445         texSubImage2D(target, level, xoffset, yoffset, format, type, imageData.get(), ec);
1446     else
1447         texSubImage2DImpl(target, level, xoffset, yoffset, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
1448 }
1449
1450 #if ENABLE(VIDEO)
1451 void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)
1452 {
1453     ec = 0;
1454     if (isContextLostOrPending() || !validateHTMLVideoElement("texSubImage2D", video, ec)
1455         || !validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLVideoElement, target, level, GraphicsContext3D::NONE, video->videoWidth(), video->videoHeight(), 0, format, type, xoffset, yoffset))
1456         return;
1457     
1458     RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode(), ec);
1459     if (!image)
1460         return;
1461     texSubImage2DImpl(target, level, xoffset, yoffset, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
1462 }
1463 #endif
1464
1465 bool WebGL2RenderingContext::validateTexFuncParameters(const char* functionName, TexFuncValidationFunctionType functionType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type)
1466 {
1467     if (functionType == CopyTexImage) {
1468         GC3Denum framebufferInternalFormat = 0;
1469         WebGLSharedObject* object = m_framebufferBinding->getAttachmentObject(GraphicsContext3D::COLOR_ATTACHMENT0);
1470         if (object->isTexture()) {
1471             WebGLTexture* texture = reinterpret_cast<WebGLTexture*>(object);
1472             framebufferInternalFormat = baseInternalFormatFromInternalFormat(texture->getInternalFormat(GraphicsContext3D::TEXTURE_2D, 0));
1473         } else if (object->isRenderbuffer()) {
1474             WebGLRenderbuffer* renderBuffer = reinterpret_cast<WebGLRenderbuffer*>(object);
1475             framebufferInternalFormat = baseInternalFormatFromInternalFormat(renderBuffer->getInternalFormat());
1476         }
1477         
1478         GC3Denum baseTextureInternalFormat = baseInternalFormatFromInternalFormat(internalformat);
1479         bool validFormatCombination = true;
1480         switch (framebufferInternalFormat) {
1481         case GraphicsContext3D::RED:
1482             if (baseTextureInternalFormat != GraphicsContext3D::LUMINANCE && baseTextureInternalFormat != GraphicsContext3D::RED)
1483                 validFormatCombination = false;
1484             break;
1485         case GraphicsContext3D::RG:
1486             if (baseTextureInternalFormat != GraphicsContext3D::LUMINANCE && baseTextureInternalFormat != GraphicsContext3D::RED && baseTextureInternalFormat != GraphicsContext3D::RG)
1487                 validFormatCombination = false;
1488             break;
1489         case GraphicsContext3D::RGB:
1490             if (baseTextureInternalFormat != GraphicsContext3D::LUMINANCE && baseTextureInternalFormat != GraphicsContext3D::RED && baseTextureInternalFormat != GraphicsContext3D::RG && baseTextureInternalFormat != GraphicsContext3D::RGB)
1491                 validFormatCombination = false;
1492             break;
1493         case GraphicsContext3D::RGBA:
1494             if (baseTextureInternalFormat != GraphicsContext3D::ALPHA && baseTextureInternalFormat != GraphicsContext3D::LUMINANCE && baseTextureInternalFormat != GraphicsContext3D::LUMINANCE_ALPHA && baseTextureInternalFormat != GraphicsContext3D::RED && baseTextureInternalFormat != GraphicsContext3D::RG && baseTextureInternalFormat != GraphicsContext3D::RGB && baseTextureInternalFormat != GraphicsContext3D::RGBA)
1495                 validFormatCombination = false;
1496             break;
1497         case GraphicsContext3D::DEPTH_COMPONENT:
1498             validFormatCombination = false;
1499             break;
1500         case GraphicsContext3D::DEPTH_STENCIL:
1501             validFormatCombination = false;
1502             break;
1503         }
1504         
1505         if (!validFormatCombination) {
1506             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "copyTexImage: invalid combination of framebuffer and texture formats");
1507             return false;
1508         }
1509
1510         ExceptionCode ec;
1511         bool isSRGB = (getFramebufferAttachmentParameter(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, ec).getInt() == GraphicsContext3D::SRGB);
1512         if (isSRGB != (framebufferInternalFormat == GraphicsContext3D::SRGB8 || framebufferInternalFormat == GraphicsContext3D::SRGB8_ALPHA8)) {
1513             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "framebuffer attachment color encoding and internal format do not match");
1514         return false;
1515         }
1516     }
1517     
1518     // We absolutely have to validate the format and type combination.
1519     // The texImage2D entry points taking HTMLImage, etc. will produce
1520     // temporary data based on this combination, so it must be legal.
1521     if (!validateTexFuncFormatAndType(functionName, internalformat, format, type, level) || !validateTexFuncLevel(functionName, target, level))
1522         return false;
1523     
1524     if (width < 0 || height < 0) {
1525         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height < 0");
1526         return false;
1527     }
1528     
1529     GC3Dint maxTextureSizeForLevel = pow(2.0, m_maxTextureLevel - 1 - level);
1530     switch (target) {
1531     case GraphicsContext3D::TEXTURE_2D:
1532         if (width > maxTextureSizeForLevel || height > maxTextureSizeForLevel) {
1533             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height out of range");
1534             return false;
1535         }
1536         break;
1537     case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:
1538     case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:
1539     case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:
1540     case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:
1541     case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:
1542     case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:
1543         if (functionType != TexSubImage && width != height) {
1544             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width != height for cube map");
1545             return false;
1546         }
1547         // No need to check height here. For texImage width == height.
1548         // For texSubImage that will be checked when checking yoffset + height is in range.
1549         if (width > maxTextureSizeForLevel) {
1550             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height out of range for cube map");
1551             return false;
1552         }
1553         break;
1554     default:
1555         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");
1556         return false;
1557     }
1558     
1559     if (border) {
1560         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "border != 0");
1561         return false;
1562     }
1563     
1564     return true;
1565 }
1566     
1567 bool WebGL2RenderingContext::validateTexFuncFormatAndType(const char* functionName, GC3Denum internalformat, GC3Denum format, GC3Denum type, GC3Dint level)
1568 {
1569     // Verify that a valid format has been provided.
1570     switch (format) {
1571     case GraphicsContext3D::ALPHA:
1572     case GraphicsContext3D::LUMINANCE:
1573     case GraphicsContext3D::LUMINANCE_ALPHA:
1574     case GraphicsContext3D::RGB:
1575     case GraphicsContext3D::RGBA:
1576     case GraphicsContext3D::RGBA_INTEGER:
1577     case GraphicsContext3D::RG:
1578     case GraphicsContext3D::RG_INTEGER:
1579     case GraphicsContext3D::RED_INTEGER:
1580         break;
1581     case GraphicsContext3D::DEPTH_STENCIL:
1582     case GraphicsContext3D::DEPTH_COMPONENT:
1583         if (m_webglDepthTexture)
1584             break;
1585         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "depth texture formats not enabled");
1586         return false;
1587     default:
1588         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture format");
1589         return false;
1590     }
1591     
1592     // Verify that a valid type has been provided.
1593     switch (type) {
1594     case GraphicsContext3D::UNSIGNED_BYTE:
1595     case GraphicsContext3D::BYTE:
1596     case GraphicsContext3D::UNSIGNED_SHORT:
1597     case GraphicsContext3D::SHORT:
1598     case GraphicsContext3D::UNSIGNED_INT:
1599     case GraphicsContext3D::INT:
1600     case GraphicsContext3D::UNSIGNED_INT_2_10_10_10_REV:
1601     case GraphicsContext3D::UNSIGNED_INT_10F_11F_11F_REV:
1602     case GraphicsContext3D::UNSIGNED_INT_5_9_9_9_REV:
1603     case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:
1604     case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:
1605     case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:
1606         break;
1607     case GraphicsContext3D::FLOAT:
1608         if (m_oesTextureFloat)
1609             break;
1610         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");
1611         return false;
1612     case GraphicsContext3D::HALF_FLOAT:
1613     case GraphicsContext3D::HALF_FLOAT_OES:
1614         if (m_oesTextureHalfFloat)
1615             break;
1616         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");
1617         return false;
1618     case GraphicsContext3D::UNSIGNED_INT_24_8:
1619     case GraphicsContext3D::FLOAT_32_UNSIGNED_INT_24_8_REV:
1620         if (isDepthStencilSupported())
1621             break;
1622         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");
1623         return false;
1624     default:
1625         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");
1626         return false;
1627     }
1628     
1629     // Veryify that a valid internal format has been provided.
1630     switch (internalformat) {
1631     case GraphicsContext3D::RGBA:
1632     case GraphicsContext3D::RGB:
1633     case GraphicsContext3D::LUMINANCE_ALPHA:
1634     case GraphicsContext3D::LUMINANCE:
1635     case GraphicsContext3D::ALPHA:
1636     case GraphicsContext3D::RGBA32I:
1637     case GraphicsContext3D::RGBA32UI:
1638     case GraphicsContext3D::RGBA16I:
1639     case GraphicsContext3D::RGBA16UI:
1640     case GraphicsContext3D::RGBA8:
1641     case GraphicsContext3D::RGBA8I:
1642     case GraphicsContext3D::RGBA8UI:
1643     case GraphicsContext3D::RGB10_A2:
1644     case GraphicsContext3D::RGB10_A2UI:
1645     case GraphicsContext3D::RGBA4:
1646     case GraphicsContext3D::RG32I:
1647     case GraphicsContext3D::RG32UI:
1648     case GraphicsContext3D::RG16I:
1649     case GraphicsContext3D::RG16UI:
1650     case GraphicsContext3D::RG8:
1651     case GraphicsContext3D::RG8I:
1652     case GraphicsContext3D::RG8UI:
1653     case GraphicsContext3D::R32I:
1654     case GraphicsContext3D::R32UI:
1655     case GraphicsContext3D::R16I:
1656     case GraphicsContext3D::R16UI:
1657     case GraphicsContext3D::R8:
1658     case GraphicsContext3D::R8I:
1659     case GraphicsContext3D::R8UI:
1660     case GraphicsContext3D::RGB5_A1:
1661     case GraphicsContext3D::RGB8:
1662     case GraphicsContext3D::RGB565:
1663     case GraphicsContext3D::RGBA32F:
1664     case GraphicsContext3D::RGBA16F:
1665     case GraphicsContext3D::RGBA8_SNORM:
1666     case GraphicsContext3D::RGB32F:
1667     case GraphicsContext3D::RGB32I:
1668     case GraphicsContext3D::RGB32UI:
1669     case GraphicsContext3D::RGB16F:
1670     case GraphicsContext3D::RGB16I:
1671     case GraphicsContext3D::RGB16UI:
1672     case GraphicsContext3D::RGB8_SNORM:
1673     case GraphicsContext3D::RGB8I:
1674     case GraphicsContext3D::RGB8UI:
1675     case GraphicsContext3D::SRGB8:
1676     case GraphicsContext3D::SRGB8_ALPHA8:
1677     case GraphicsContext3D::R11F_G11F_B10F:
1678     case GraphicsContext3D::RGB9_E5:
1679     case GraphicsContext3D::RG32F:
1680     case GraphicsContext3D::RG16F:
1681     case GraphicsContext3D::RG8_SNORM:
1682     case GraphicsContext3D::R32F:
1683     case GraphicsContext3D::R16F:
1684     case GraphicsContext3D::R8_SNORM:
1685     case GraphicsContext3D::STENCIL_INDEX8:
1686         break;
1687     case GraphicsContext3D::DEPTH_COMPONENT16:
1688     case GraphicsContext3D::DEPTH_COMPONENT32F:
1689     case GraphicsContext3D::DEPTH_COMPONENT24:
1690         if (m_webglDepthTexture)
1691             break;
1692         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "depth texture formats not enabled");
1693         return false;
1694     case GraphicsContext3D::DEPTH32F_STENCIL8:
1695     case GraphicsContext3D::DEPTH24_STENCIL8:
1696         if (isDepthStencilSupported())
1697             break;
1698         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture internal format");
1699         return false;
1700     case GraphicsContext3D::NONE:
1701         // When calling validateTexFuncFormatAndType with internalformat == GraphicsContext3D::NONE, the intent is
1702         // only to check for whether or not the format and type are valid types, which we have already done at this point.
1703         return true;
1704         break;
1705     default:
1706         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture internal format");
1707         return false;
1708     }
1709
1710     // Verify that the combination of format, internalformat and type is supported.
1711     switch (format) {
1712     case GraphicsContext3D::RGBA:
1713         if (type == GraphicsContext3D::UNSIGNED_BYTE
1714             && (internalformat == GraphicsContext3D::RGBA || internalformat == GraphicsContext3D::RGBA8 || internalformat == GraphicsContext3D::RGB5_A1 || internalformat == GraphicsContext3D::RGBA4 || internalformat == GraphicsContext3D::SRGB8_ALPHA8))
1715             break;
1716         if (type == GraphicsContext3D::BYTE && internalformat == GraphicsContext3D::RGBA8_SNORM)
1717             break;
1718         if (type == GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4
1719             && (internalformat == GraphicsContext3D::RGBA || internalformat == GraphicsContext3D::RGBA4))
1720             break;
1721         if (type == GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1
1722             && (internalformat == GraphicsContext3D::RGBA || internalformat == GraphicsContext3D::RGB5_A1))
1723             break;
1724         if (type == GraphicsContext3D::UNSIGNED_INT_2_10_10_10_REV
1725             && (internalformat == GraphicsContext3D::RGB10_A2 || internalformat == GraphicsContext3D::RGB5_A1))
1726             break;
1727         if ((type == GraphicsContext3D::HALF_FLOAT || type == GraphicsContext3D::HALF_FLOAT_OES) && internalformat == GraphicsContext3D::RGBA16F)
1728             break;
1729         if (type == GraphicsContext3D::FLOAT
1730             && (internalformat == GraphicsContext3D::RGBA32F || internalformat == GraphicsContext3D::RGBA16F))
1731             break;
1732         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1733         return false;
1734     case GraphicsContext3D::RGBA_INTEGER:
1735         if (type == GraphicsContext3D::UNSIGNED_BYTE && internalformat == GraphicsContext3D::RGBA8UI)
1736         break;
1737         if (type == GraphicsContext3D::BYTE && internalformat == GraphicsContext3D::RGBA8I)
1738         break;
1739         if (type == GraphicsContext3D::UNSIGNED_SHORT && internalformat == GraphicsContext3D::RGBA16UI)
1740         break;
1741         if (type == GraphicsContext3D::SHORT && internalformat == GraphicsContext3D::RGBA16I)
1742         break;
1743         if (type == GraphicsContext3D::UNSIGNED_INT && internalformat == GraphicsContext3D::RGBA32UI)
1744         break;
1745         if (type == GraphicsContext3D::INT && internalformat == GraphicsContext3D::RGBA32I)
1746         break;
1747         if (type == GraphicsContext3D::UNSIGNED_INT_2_10_10_10_REV && internalformat == GraphicsContext3D::RGB10_A2UI)
1748             break;
1749         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1750         return false;
1751     case GraphicsContext3D::RGB:
1752         if (type == GraphicsContext3D::UNSIGNED_BYTE
1753             && (internalformat == GraphicsContext3D::RGB || internalformat == GraphicsContext3D::RGB8 || internalformat == GraphicsContext3D::RGB565
1754             || internalformat == GraphicsContext3D::SRGB8))
1755             break;
1756         if (type == GraphicsContext3D::BYTE && internalformat == GraphicsContext3D::RGB8_SNORM)
1757             break;
1758         if (type == GraphicsContext3D::UNSIGNED_SHORT_5_6_5
1759             && (internalformat == GraphicsContext3D::RGB || internalformat == GraphicsContext3D::RGB565))
1760             break;
1761         if (type == GraphicsContext3D::UNSIGNED_INT_10F_11F_11F_REV && internalformat == GraphicsContext3D::R11F_G11F_B10F)
1762             break;
1763         if (type == GraphicsContext3D::UNSIGNED_INT_5_9_9_9_REV && internalformat == GraphicsContext3D::RGB9_E5)
1764             break;
1765         if ((type == GraphicsContext3D::HALF_FLOAT || type == GraphicsContext3D::HALF_FLOAT_OES)
1766             && (internalformat == GraphicsContext3D::RGB16F || internalformat == GraphicsContext3D::R11F_G11F_B10F || internalformat == GraphicsContext3D::RGB9_E5))
1767             break;
1768         if (type == GraphicsContext3D::FLOAT
1769             && (internalformat == GraphicsContext3D::RGB32F || internalformat == GraphicsContext3D::RGB16F || internalformat == GraphicsContext3D::R11F_G11F_B10F || internalformat == GraphicsContext3D::RGB9_E5))
1770             break;
1771         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1772         return false;
1773     case GraphicsContext3D::RGB_INTEGER:
1774         if (type == GraphicsContext3D::UNSIGNED_BYTE && internalformat == GraphicsContext3D::RGB8UI)
1775             break;
1776         if (type == GraphicsContext3D::BYTE && internalformat == GraphicsContext3D::RGB8I)
1777             break;
1778         if (type == GraphicsContext3D::UNSIGNED_SHORT && internalformat == GraphicsContext3D::RGB16UI)
1779             break;
1780         if (type == GraphicsContext3D::SHORT && internalformat == GraphicsContext3D::RGB16I)
1781             break;
1782         if (type == GraphicsContext3D::UNSIGNED_INT && internalformat == GraphicsContext3D::RGB32UI)
1783             break;
1784         if (type == GraphicsContext3D::INT && internalformat == GraphicsContext3D::RGB32I)
1785             break;
1786         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1787         return false;
1788     case GraphicsContext3D::RG:
1789         if (type == GraphicsContext3D::UNSIGNED_BYTE && internalformat == GraphicsContext3D::RG8)
1790             break;
1791         if (type == GraphicsContext3D::BYTE && internalformat == GraphicsContext3D::RG8_SNORM)
1792             break;
1793         if ((type == GraphicsContext3D::HALF_FLOAT || type == GraphicsContext3D::HALF_FLOAT_OES) && internalformat == GraphicsContext3D::RG16F)
1794             break;
1795         if (type == GraphicsContext3D::FLOAT
1796             && (internalformat == GraphicsContext3D::RG32F || internalformat == GraphicsContext3D::RG16F))
1797             break;
1798         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1799         return false;
1800     case GraphicsContext3D::RG_INTEGER:
1801         if (type == GraphicsContext3D::UNSIGNED_BYTE && internalformat == GraphicsContext3D::RG8UI)
1802             break;
1803         if (type == GraphicsContext3D::BYTE && internalformat == GraphicsContext3D::RG8I)
1804             break;
1805         if (type == GraphicsContext3D::UNSIGNED_SHORT && internalformat == GraphicsContext3D::RG16UI)
1806             break;
1807         if (type == GraphicsContext3D::SHORT && internalformat == GraphicsContext3D::RG16I)
1808             break;
1809         if (type == GraphicsContext3D::UNSIGNED_INT && internalformat == GraphicsContext3D::RG32UI)
1810             break;
1811         if (type == GraphicsContext3D::INT && internalformat == GraphicsContext3D::RG32I)
1812             break;
1813         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1814         return false;
1815     case GraphicsContext3D::RED:
1816         if (type == GraphicsContext3D::UNSIGNED_BYTE && internalformat == GraphicsContext3D::R8)
1817             break;
1818         if (type == GraphicsContext3D::BYTE && internalformat == GraphicsContext3D::R8_SNORM)
1819             break;
1820         if ((type == GraphicsContext3D::HALF_FLOAT || type == GraphicsContext3D::HALF_FLOAT_OES) && internalformat == GraphicsContext3D::R16F)
1821             break;
1822         if (type == GraphicsContext3D::FLOAT
1823             && (internalformat == GraphicsContext3D::R32F || internalformat == GraphicsContext3D::R16F))
1824             break;
1825         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1826         return false;
1827     case GraphicsContext3D::RED_INTEGER:
1828         if (type == GraphicsContext3D::UNSIGNED_BYTE && internalformat == GraphicsContext3D::R8UI)
1829             break;
1830         if (type == GraphicsContext3D::BYTE && internalformat == GraphicsContext3D::R8I)
1831             break;
1832         if (type == GraphicsContext3D::UNSIGNED_SHORT && internalformat == GraphicsContext3D::R16UI)
1833             break;
1834         if (type == GraphicsContext3D::SHORT && internalformat == GraphicsContext3D::R16I)
1835             break;
1836         if (type == GraphicsContext3D::UNSIGNED_INT && internalformat == GraphicsContext3D::R32UI)
1837             break;
1838         if (type == GraphicsContext3D::INT && internalformat == GraphicsContext3D::R32I)
1839             break;
1840         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1841         return false;
1842     case GraphicsContext3D::DEPTH_COMPONENT:
1843         if (!m_webglDepthTexture) {
1844             synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format. DEPTH_COMPONENT not enabled");
1845             return false;
1846         }
1847         if (type == GraphicsContext3D::UNSIGNED_SHORT && internalformat == GraphicsContext3D::DEPTH_COMPONENT16)
1848             break;
1849         if (type == GraphicsContext3D::UNSIGNED_INT
1850             && (internalformat == GraphicsContext3D::DEPTH_COMPONENT24 || internalformat == GraphicsContext3D::DEPTH_COMPONENT16))
1851             break;
1852         if (type == GraphicsContext3D::FLOAT && internalformat == GraphicsContext3D::DEPTH_COMPONENT32F)
1853             break;
1854         if (level > 0) {
1855             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "level must be 0 for DEPTH_COMPONENT format");
1856             return false;
1857         }
1858         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1859         return false;
1860     case GraphicsContext3D::DEPTH_STENCIL:
1861         if (!m_webglDepthTexture || !isDepthStencilSupported()) {
1862             synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format. DEPTH_STENCIL not enabled");
1863             return false;
1864         }
1865         if (type == GraphicsContext3D::UNSIGNED_INT_24_8 && internalformat == GraphicsContext3D::DEPTH24_STENCIL8)
1866             break;
1867         if (type == GraphicsContext3D::FLOAT_32_UNSIGNED_INT_24_8_REV && internalformat == GraphicsContext3D::DEPTH32F_STENCIL8)
1868             break;
1869         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1870         return false;
1871     case GraphicsContext3D::ALPHA:
1872     case GraphicsContext3D::LUMINANCE:
1873     case GraphicsContext3D::LUMINANCE_ALPHA:
1874         if ((type == GraphicsContext3D::UNSIGNED_BYTE || type == GraphicsContext3D::HALF_FLOAT_OES || type == GraphicsContext3D::HALF_FLOAT || type == GraphicsContext3D::FLOAT) && internalformat == format)
1875             break;
1876         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid format, internalformat, and type combination");
1877         return false;
1878     default:
1879         ASSERT_NOT_REACHED();
1880     }
1881
1882     return true;
1883 }
1884
1885 bool WebGL2RenderingContext::validateTexFuncData(const char* functionName, GC3Dint level,
1886     GC3Dsizei width, GC3Dsizei height,
1887     GC3Denum internalformat, GC3Denum format, GC3Denum type,
1888     ArrayBufferView* pixels,
1889     NullDisposition disposition)
1890 {
1891     if (!pixels) {
1892         if (disposition == NullAllowed)
1893             return true;
1894         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no pixels");
1895         return false;
1896     }
1897
1898     if (!validateTexFuncFormatAndType(functionName, internalformat, format, type, level))
1899         return false;
1900     if (!validateSettableTexFormat(functionName, format))
1901         return false;
1902     
1903     switch (type) {
1904     case GraphicsContext3D::BYTE:
1905         if (pixels->getType() != JSC::TypeInt8) {
1906             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type BYTE but ArrayBufferView not Int8Array");
1907             return false;
1908         }
1909         break;
1910     case GraphicsContext3D::UNSIGNED_BYTE:
1911         if (pixels->getType() != JSC::TypeUint8) {
1912             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_BYTE but ArrayBufferView not Uint8Array");
1913             return false;
1914         }
1915         break;
1916     case GraphicsContext3D::SHORT:
1917         if (pixels->getType() != JSC::TypeInt16) {
1918             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type SHORT but ArrayBufferView not Int16Array");
1919             return false;
1920         }
1921         break;
1922     case GraphicsContext3D::UNSIGNED_SHORT:
1923     case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:
1924     case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:
1925     case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:
1926         if (pixels->getType() != JSC::TypeUint16) {
1927             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_SHORT but ArrayBufferView not Uint16Array");
1928             return false;
1929         }
1930         break;
1931     case GraphicsContext3D::INT:
1932         if (pixels->getType() != JSC::TypeInt32) {
1933             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type INT but ArrayBufferView not Int32Array");
1934             return false;
1935         }
1936         break;
1937     case GraphicsContext3D::UNSIGNED_INT:
1938     case GraphicsContext3D::UNSIGNED_INT_2_10_10_10_REV:
1939     case GraphicsContext3D::UNSIGNED_INT_10F_11F_11F_REV:
1940         if (pixels->getType() != JSC::TypeUint32) {
1941             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_INT but ArrayBufferView not Uint32Array");
1942             return false;
1943         }
1944         break;
1945     case GraphicsContext3D::HALF_FLOAT:
1946     case GraphicsContext3D::FLOAT:
1947         if (pixels->getType() != JSC::TypeFloat32) {
1948             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type FLOAT but ArrayBufferView not Float32Array");
1949             return false;
1950         }
1951         break;
1952     case GraphicsContext3D::HALF_FLOAT_OES: // OES_texture_half_float
1953         // As per the specification, ArrayBufferView should be null when
1954         // OES_texture_half_float is enabled.
1955         if (pixels) {
1956             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type HALF_FLOAT_OES but ArrayBufferView is not NULL");
1957             return false;
1958         }
1959         break;
1960     default:
1961         ASSERT_NOT_REACHED();
1962     }
1963     
1964     unsigned totalBytesRequired;
1965     GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &totalBytesRequired, 0);
1966     if (error != GraphicsContext3D::NO_ERROR) {
1967         synthesizeGLError(error, functionName, "invalid texture dimensions");
1968         return false;
1969     }
1970     if (pixels->byteLength() < totalBytesRequired) {
1971         if (m_unpackAlignment != 1) {
1972             error = m_context->computeImageSizeInBytes(format, type, width, height, 1, &totalBytesRequired, 0);
1973             if (pixels->byteLength() == totalBytesRequired) {
1974                 synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request with UNPACK_ALIGNMENT > 1");
1975                 return false;
1976             }
1977         }
1978         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request");
1979         return false;
1980     }
1981     return true;
1982 }
1983
1984 GC3Denum WebGL2RenderingContext::baseInternalFormatFromInternalFormat(GC3Denum internalformat)
1985 {
1986     // Handles sized, unsized, and compressed internal formats.
1987     switch (internalformat) {
1988     case GraphicsContext3D::R8:
1989     case GraphicsContext3D::R8_SNORM:
1990     case GraphicsContext3D::R16F:
1991     case GraphicsContext3D::R32F:
1992     case GraphicsContext3D::R8I:
1993     case GraphicsContext3D::R8UI:
1994     case GraphicsContext3D::R16I:
1995     case GraphicsContext3D::R16UI:
1996     case GraphicsContext3D::R32I:
1997     case GraphicsContext3D::R32UI:
1998     case GraphicsContext3D::COMPRESSED_R11_EAC:
1999     case GraphicsContext3D::COMPRESSED_SIGNED_R11_EAC:
2000         return GraphicsContext3D::RED;
2001     case GraphicsContext3D::RG8:
2002     case GraphicsContext3D::RG8_SNORM:
2003     case GraphicsContext3D::RG16F:
2004     case GraphicsContext3D::RG32F:
2005     case GraphicsContext3D::RG8I:
2006     case GraphicsContext3D::RG8UI:
2007     case GraphicsContext3D::RG16I:
2008     case GraphicsContext3D::RG16UI:
2009     case GraphicsContext3D::RG32I:
2010     case GraphicsContext3D::RG32UI:
2011     case GraphicsContext3D::COMPRESSED_RG11_EAC:
2012     case GraphicsContext3D::COMPRESSED_SIGNED_RG11_EAC:
2013         return GraphicsContext3D::RG;
2014     case GraphicsContext3D::RGB8:
2015     case GraphicsContext3D::RGB8_SNORM:
2016     case GraphicsContext3D::RGB565:
2017     case GraphicsContext3D::SRGB8:
2018     case GraphicsContext3D::RGB16F:
2019     case GraphicsContext3D::RGB32F:
2020     case GraphicsContext3D::RGB8I:
2021     case GraphicsContext3D::RGB8UI:
2022     case GraphicsContext3D::RGB16I:
2023     case GraphicsContext3D::RGB16UI:
2024     case GraphicsContext3D::RGB32I:
2025     case GraphicsContext3D::RGB32UI:
2026     case GraphicsContext3D::RGB:
2027     case GraphicsContext3D::COMPRESSED_RGB8_ETC2:
2028     case GraphicsContext3D::COMPRESSED_SRGB8_ETC2:
2029         return GraphicsContext3D::RGB;
2030     case GraphicsContext3D::RGBA4:
2031     case GraphicsContext3D::RGB5_A1:
2032     case GraphicsContext3D::RGBA8:
2033     case GraphicsContext3D::RGBA8_SNORM:
2034     case GraphicsContext3D::RGB10_A2:
2035     case GraphicsContext3D::RGB10_A2UI:
2036     case GraphicsContext3D::SRGB8_ALPHA8:
2037     case GraphicsContext3D::RGBA16F:
2038     case GraphicsContext3D::RGBA32F:
2039     case GraphicsContext3D::RGBA8I:
2040     case GraphicsContext3D::RGBA8UI:
2041     case GraphicsContext3D::RGBA16I:
2042     case GraphicsContext3D::RGBA16UI:
2043     case GraphicsContext3D::RGBA32I:
2044     case GraphicsContext3D::RGBA32UI:
2045     case GraphicsContext3D::RGBA:
2046     case GraphicsContext3D::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
2047     case GraphicsContext3D::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
2048     case GraphicsContext3D::COMPRESSED_RGBA8_ETC2_EAC:
2049     case GraphicsContext3D::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
2050         return GraphicsContext3D::RGBA;
2051     case GraphicsContext3D::DEPTH_COMPONENT16:
2052     case GraphicsContext3D::DEPTH_COMPONENT24:
2053     case GraphicsContext3D::DEPTH_COMPONENT32F:
2054         return GraphicsContext3D::DEPTH_COMPONENT;
2055     case GraphicsContext3D::DEPTH24_STENCIL8:
2056     case GraphicsContext3D::DEPTH32F_STENCIL8:
2057         return GraphicsContext3D::DEPTH_STENCIL;
2058     case GraphicsContext3D::LUMINANCE:
2059     case GraphicsContext3D::LUMINANCE_ALPHA:
2060     case GraphicsContext3D::ALPHA:
2061         return internalformat;
2062     default:
2063         ASSERT_NOT_REACHED();
2064         return GraphicsContext3D::NONE;
2065     }
2066 }
2067
2068 bool WebGL2RenderingContext::isIntegerFormat(GC3Denum internalformat)
2069 {
2070     switch (baseInternalFormatFromInternalFormat(internalformat)) {
2071     case GraphicsContext3D::RED_INTEGER:
2072     case GraphicsContext3D::RG_INTEGER:
2073     case GraphicsContext3D::RGB_INTEGER:
2074     case GraphicsContext3D::RGBA_INTEGER:
2075         return true;
2076     }
2077     return false;
2078 }
2079
2080 WebGLGetInfo WebGL2RenderingContext::getParameter(GC3Denum pname, ExceptionCode& ec)
2081 {
2082     UNUSED_PARAM(ec);
2083     if (isContextLostOrPending())
2084         return WebGLGetInfo();
2085     const int intZero = 0;
2086     switch (pname) {
2087     case GraphicsContext3D::ACTIVE_TEXTURE:
2088         return getUnsignedIntParameter(pname);
2089     case GraphicsContext3D::ALIASED_LINE_WIDTH_RANGE:
2090         return getWebGLFloatArrayParameter(pname);
2091     case GraphicsContext3D::ALIASED_POINT_SIZE_RANGE:
2092         return getWebGLFloatArrayParameter(pname);
2093     case GraphicsContext3D::ALPHA_BITS:
2094         return getIntParameter(pname);
2095     case GraphicsContext3D::ARRAY_BUFFER_BINDING:
2096         return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundArrayBuffer));
2097     case GraphicsContext3D::BLEND:
2098         return getBooleanParameter(pname);
2099     case GraphicsContext3D::BLEND_COLOR:
2100         return getWebGLFloatArrayParameter(pname);
2101     case GraphicsContext3D::BLEND_DST_ALPHA:
2102         return getUnsignedIntParameter(pname);
2103     case GraphicsContext3D::BLEND_DST_RGB:
2104         return getUnsignedIntParameter(pname);
2105     case GraphicsContext3D::BLEND_EQUATION_ALPHA:
2106         return getUnsignedIntParameter(pname);
2107     case GraphicsContext3D::BLEND_EQUATION_RGB:
2108         return getUnsignedIntParameter(pname);
2109     case GraphicsContext3D::BLEND_SRC_ALPHA:
2110         return getUnsignedIntParameter(pname);
2111     case GraphicsContext3D::BLEND_SRC_RGB:
2112         return getUnsignedIntParameter(pname);
2113     case GraphicsContext3D::BLUE_BITS:
2114         return getIntParameter(pname);
2115     case GraphicsContext3D::COLOR_CLEAR_VALUE:
2116         return getWebGLFloatArrayParameter(pname);
2117     case GraphicsContext3D::COLOR_WRITEMASK:
2118         return getBooleanArrayParameter(pname);
2119     case GraphicsContext3D::COMPRESSED_TEXTURE_FORMATS:
2120         return WebGLGetInfo(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()).release());
2121     case GraphicsContext3D::CULL_FACE:
2122         return getBooleanParameter(pname);
2123     case GraphicsContext3D::CULL_FACE_MODE:
2124         return getUnsignedIntParameter(pname);
2125     case GraphicsContext3D::CURRENT_PROGRAM:
2126         return WebGLGetInfo(PassRefPtr<WebGLProgram>(m_currentProgram));
2127     case GraphicsContext3D::DEPTH_BITS:
2128         if (!m_framebufferBinding && !m_attributes.depth)
2129             return WebGLGetInfo(intZero);
2130         return getIntParameter(pname);
2131     case GraphicsContext3D::DEPTH_CLEAR_VALUE:
2132         return getFloatParameter(pname);
2133     case GraphicsContext3D::DEPTH_FUNC:
2134         return getUnsignedIntParameter(pname);
2135     case GraphicsContext3D::DEPTH_RANGE:
2136         return getWebGLFloatArrayParameter(pname);
2137     case GraphicsContext3D::DEPTH_TEST:
2138         return getBooleanParameter(pname);
2139     case GraphicsContext3D::DEPTH_WRITEMASK:
2140         return getBooleanParameter(pname);
2141     case GraphicsContext3D::DITHER:
2142         return getBooleanParameter(pname);
2143     case GraphicsContext3D::ELEMENT_ARRAY_BUFFER_BINDING:
2144         return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundVertexArrayObject->getElementArrayBuffer()));
2145     case GraphicsContext3D::FRAMEBUFFER_BINDING:
2146         return WebGLGetInfo(PassRefPtr<WebGLFramebuffer>(m_framebufferBinding));
2147     case GraphicsContext3D::FRONT_FACE:
2148         return getUnsignedIntParameter(pname);
2149     case GraphicsContext3D::GENERATE_MIPMAP_HINT:
2150         return getUnsignedIntParameter(pname);
2151     case GraphicsContext3D::GREEN_BITS:
2152         return getIntParameter(pname);
2153     case GraphicsContext3D::IMPLEMENTATION_COLOR_READ_FORMAT:
2154         return getIntParameter(pname);
2155     case GraphicsContext3D::IMPLEMENTATION_COLOR_READ_TYPE:
2156         return getIntParameter(pname);
2157     case GraphicsContext3D::LINE_WIDTH:
2158         return getFloatParameter(pname);
2159     case GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS:
2160         return getIntParameter(pname);
2161     case GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE:
2162         return getIntParameter(pname);
2163     case GraphicsContext3D::MAX_FRAGMENT_UNIFORM_VECTORS:
2164         return getIntParameter(pname);
2165     case GraphicsContext3D::MAX_RENDERBUFFER_SIZE:
2166         return getIntParameter(pname);
2167     case GraphicsContext3D::MAX_TEXTURE_IMAGE_UNITS:
2168         return getIntParameter(pname);
2169     case GraphicsContext3D::MAX_TEXTURE_SIZE:
2170         return getIntParameter(pname);
2171     case GraphicsContext3D::MAX_VARYING_VECTORS:
2172         return getIntParameter(pname);
2173     case GraphicsContext3D::MAX_VERTEX_ATTRIBS:
2174         return getIntParameter(pname);
2175     case GraphicsContext3D::MAX_VERTEX_TEXTURE_IMAGE_UNITS:
2176         return getIntParameter(pname);
2177     case GraphicsContext3D::MAX_VERTEX_UNIFORM_VECTORS:
2178         return getIntParameter(pname);
2179     case GraphicsContext3D::MAX_VIEWPORT_DIMS:
2180         return getWebGLIntArrayParameter(pname);
2181     case GraphicsContext3D::NUM_SHADER_BINARY_FORMATS:
2182         return getIntParameter(pname);
2183     case GraphicsContext3D::PACK_ALIGNMENT:
2184         return getIntParameter(pname);
2185     case GraphicsContext3D::POLYGON_OFFSET_FACTOR:
2186         return getFloatParameter(pname);
2187     case GraphicsContext3D::POLYGON_OFFSET_FILL:
2188         return getBooleanParameter(pname);
2189     case GraphicsContext3D::POLYGON_OFFSET_UNITS:
2190         return getFloatParameter(pname);
2191     case GraphicsContext3D::RED_BITS:
2192         return getIntParameter(pname);
2193     case GraphicsContext3D::RENDERBUFFER_BINDING:
2194         return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(m_renderbufferBinding));
2195     case GraphicsContext3D::RENDERER:
2196         return WebGLGetInfo(String("WebKit WebGL"));
2197     case GraphicsContext3D::SAMPLE_BUFFERS:
2198         return getIntParameter(pname);
2199     case GraphicsContext3D::SAMPLE_COVERAGE_INVERT:
2200         return getBooleanParameter(pname);
2201     case GraphicsContext3D::SAMPLE_COVERAGE_VALUE:
2202         return getFloatParameter(pname);
2203     case GraphicsContext3D::SAMPLES:
2204         return getIntParameter(pname);
2205     case GraphicsContext3D::SCISSOR_BOX:
2206         return getWebGLIntArrayParameter(pname);
2207     case GraphicsContext3D::SCISSOR_TEST:
2208         return getBooleanParameter(pname);
2209     case GraphicsContext3D::SHADING_LANGUAGE_VERSION:
2210         return WebGLGetInfo("WebGL GLSL ES 1.0 (" + m_context->getString(GraphicsContext3D::SHADING_LANGUAGE_VERSION) + ")");
2211     case GraphicsContext3D::STENCIL_BACK_FAIL:
2212         return getUnsignedIntParameter(pname);
2213     case GraphicsContext3D::STENCIL_BACK_FUNC:
2214         return getUnsignedIntParameter(pname);
2215     case GraphicsContext3D::STENCIL_BACK_PASS_DEPTH_FAIL:
2216         return getUnsignedIntParameter(pname);
2217     case GraphicsContext3D::STENCIL_BACK_PASS_DEPTH_PASS:
2218         return getUnsignedIntParameter(pname);
2219     case GraphicsContext3D::STENCIL_BACK_REF:
2220         return getIntParameter(pname);
2221     case GraphicsContext3D::STENCIL_BACK_VALUE_MASK:
2222         return getUnsignedIntParameter(pname);
2223     case GraphicsContext3D::STENCIL_BACK_WRITEMASK:
2224         return getUnsignedIntParameter(pname);
2225     case GraphicsContext3D::STENCIL_BITS:
2226         if (!m_framebufferBinding && !m_attributes.stencil)
2227             return WebGLGetInfo(intZero);
2228         return getIntParameter(pname);
2229     case GraphicsContext3D::STENCIL_CLEAR_VALUE:
2230         return getIntParameter(pname);
2231     case GraphicsContext3D::STENCIL_FAIL:
2232         return getUnsignedIntParameter(pname);
2233     case GraphicsContext3D::STENCIL_FUNC:
2234         return getUnsignedIntParameter(pname);
2235     case GraphicsContext3D::STENCIL_PASS_DEPTH_FAIL:
2236         return getUnsignedIntParameter(pname);
2237     case GraphicsContext3D::STENCIL_PASS_DEPTH_PASS:
2238         return getUnsignedIntParameter(pname);
2239     case GraphicsContext3D::STENCIL_REF:
2240         return getIntParameter(pname);
2241     case GraphicsContext3D::STENCIL_TEST:
2242         return getBooleanParameter(pname);
2243     case GraphicsContext3D::STENCIL_VALUE_MASK:
2244         return getUnsignedIntParameter(pname);
2245     case GraphicsContext3D::STENCIL_WRITEMASK:
2246         return getUnsignedIntParameter(pname);
2247     case GraphicsContext3D::SUBPIXEL_BITS:
2248         return getIntParameter(pname);
2249     case GraphicsContext3D::TEXTURE_BINDING_2D:
2250         return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].texture2DBinding));
2251     case GraphicsContext3D::TEXTURE_BINDING_CUBE_MAP:
2252         return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].textureCubeMapBinding));
2253     case GraphicsContext3D::UNPACK_ALIGNMENT:
2254         return getIntParameter(pname);
2255     case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:
2256         return WebGLGetInfo(m_unpackFlipY);
2257     case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:
2258         return WebGLGetInfo(m_unpackPremultiplyAlpha);
2259     case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:
2260         return WebGLGetInfo(m_unpackColorspaceConversion);
2261     case GraphicsContext3D::VENDOR:
2262         return WebGLGetInfo(String("WebKit"));
2263     case GraphicsContext3D::VERSION:
2264         return WebGLGetInfo("WebGL 2.0 (" + m_context->getString(GraphicsContext3D::VERSION) + ")");
2265     case GraphicsContext3D::VIEWPORT:
2266         return getWebGLIntArrayParameter(pname);
2267     case WebGLDebugRendererInfo::UNMASKED_RENDERER_WEBGL:
2268         if (m_webglDebugRendererInfo)
2269             return WebGLGetInfo(m_context->getString(GraphicsContext3D::RENDERER));
2270         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");
2271         return WebGLGetInfo();
2272     case WebGLDebugRendererInfo::UNMASKED_VENDOR_WEBGL:
2273         if (m_webglDebugRendererInfo)
2274             return WebGLGetInfo(m_context->getString(GraphicsContext3D::VENDOR));
2275         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");
2276         return WebGLGetInfo();
2277     case Extensions3D::MAX_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic
2278         if (m_extTextureFilterAnisotropic)
2279             return getUnsignedIntParameter(Extensions3D::MAX_TEXTURE_MAX_ANISOTROPY_EXT);
2280         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");
2281         return WebGLGetInfo();
2282     case GraphicsContext3D::FRAGMENT_SHADER_DERIVATIVE_HINT:
2283         return getIntParameter(pname);
2284     case GraphicsContext3D::MAX_3D_TEXTURE_SIZE:
2285         return getIntParameter(pname);
2286     case GraphicsContext3D::MAX_ARRAY_TEXTURE_LAYERS:
2287         return getIntParameter(pname);
2288     case GraphicsContext3D::MAX_COLOR_ATTACHMENTS:
2289         return getIntParameter(pname);
2290     case GraphicsContext3D::MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
2291         return getInt64Parameter(pname);
2292     case GraphicsContext3D::MAX_COMBINED_UNIFORM_BLOCKS:
2293         return getIntParameter(pname);
2294     case GraphicsContext3D::MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
2295         return getInt64Parameter(pname);
2296     case GraphicsContext3D::MAX_DRAW_BUFFERS:
2297         return getIntParameter(pname);
2298     case GraphicsContext3D::MAX_ELEMENT_INDEX:
2299         return getInt64Parameter(pname);
2300     case GraphicsContext3D::MAX_ELEMENTS_INDICES:
2301         return getIntParameter(pname);
2302     case GraphicsContext3D::MAX_ELEMENTS_VERTICES:
2303         return getIntParameter(pname);
2304     case GraphicsContext3D::MAX_FRAGMENT_UNIFORM_COMPONENTS:
2305         return getIntParameter(pname);
2306     case GraphicsContext3D::MAX_FRAGMENT_UNIFORM_BLOCKS:
2307         return getIntParameter(pname);
2308     case GraphicsContext3D::MAX_PROGRAM_TEXEL_OFFSET:
2309         return getIntParameter(pname);
2310     case GraphicsContext3D::MAX_SAMPLES:
2311         return getIntParameter(pname);
2312     case GraphicsContext3D::MAX_SERVER_WAIT_TIMEOUT:
2313         return getInt64Parameter(pname);
2314     case GraphicsContext3D::MAX_TEXTURE_LOD_BIAS:
2315         return getIntParameter(pname);
2316     case GraphicsContext3D::MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
2317         return getIntParameter(pname);
2318     case GraphicsContext3D::MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
2319         return getIntParameter(pname);
2320     case GraphicsContext3D::MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
2321         return getIntParameter(pname);
2322     case GraphicsContext3D::MAX_UNIFORM_BLOCK_SIZE:
2323         return getInt64Parameter(pname);
2324     case GraphicsContext3D::MAX_UNIFORM_BUFFER_BINDINGS:
2325         return getIntParameter(pname);
2326     case GraphicsContext3D::MAX_VARYING_COMPONENTS:
2327         return getIntParameter(pname);
2328     case GraphicsContext3D::MAX_VERTEX_OUTPUT_COMPONENTS:
2329         return getIntParameter(pname);
2330     case GraphicsContext3D::MAX_VERTEX_UNIFORM_BLOCKS:
2331         return getIntParameter(pname);
2332     case GraphicsContext3D::MAX_VERTEX_UNIFORM_COMPONENTS: 
2333         return getIntParameter(pname);                            
2334     case GraphicsContext3D::MIN_PROGRAM_TEXEL_OFFSET:
2335         return getIntParameter(pname);
2336     case GraphicsContext3D::PACK_ROW_LENGTH:
2337         return getIntParameter(pname);
2338     case GraphicsContext3D::PACK_SKIP_PIXELS:
2339         return getIntParameter(pname);
2340     case GraphicsContext3D::PACK_SKIP_ROWS:
2341         return getIntParameter(pname);
2342     case GraphicsContext3D::UNPACK_IMAGE_HEIGHT:
2343         return getIntParameter(pname);
2344     case GraphicsContext3D::UNPACK_ROW_LENGTH:
2345         return getIntParameter(pname);
2346     case GraphicsContext3D::UNPACK_SKIP_IMAGES:
2347         return getIntParameter(pname);
2348     case GraphicsContext3D::UNPACK_SKIP_PIXELS:
2349         return getIntParameter(pname);
2350     case GraphicsContext3D::UNPACK_SKIP_ROWS:
2351         return getIntParameter(pname);
2352     case GraphicsContext3D::RASTERIZER_DISCARD:
2353         return getBooleanParameter(pname);
2354     case GraphicsContext3D::SAMPLE_ALPHA_TO_COVERAGE:
2355         return getBooleanParameter(pname);
2356     case GraphicsContext3D::SAMPLE_COVERAGE:
2357         return getBooleanParameter(pname);
2358     case GraphicsContext3D::TRANSFORM_FEEDBACK_ACTIVE:
2359         return getBooleanParameter(pname);
2360     case GraphicsContext3D::TRANSFORM_FEEDBACK_PAUSED:
2361         return getBooleanParameter(pname);
2362     case GraphicsContext3D::UNIFORM_BUFFER_OFFSET_ALIGNMENT:
2363         return getIntParameter(pname);
2364     case GraphicsContext3D::VERTEX_ARRAY_BINDING: {
2365         if (!m_boundVertexArrayObject->isDefaultObject())
2366             return WebGLGetInfo(PassRefPtr<WebGLVertexArrayObject>(static_cast<WebGLVertexArrayObject*>(m_boundVertexArrayObject.get())));
2367         return WebGLGetInfo();
2368         }
2369         break;
2370     case GraphicsContext3D::DRAW_BUFFER0:
2371     case GraphicsContext3D::DRAW_BUFFER1:
2372     case GraphicsContext3D::DRAW_BUFFER2:
2373     case GraphicsContext3D::DRAW_BUFFER3:
2374     case GraphicsContext3D::DRAW_BUFFER4:
2375     case GraphicsContext3D::DRAW_BUFFER5:
2376     case GraphicsContext3D::DRAW_BUFFER6:
2377     case GraphicsContext3D::DRAW_BUFFER7:
2378     case GraphicsContext3D::DRAW_BUFFER8:
2379     case GraphicsContext3D::DRAW_BUFFER9:
2380     case GraphicsContext3D::DRAW_BUFFER10:
2381     case GraphicsContext3D::DRAW_BUFFER11:
2382     case GraphicsContext3D::DRAW_BUFFER12:
2383     case GraphicsContext3D::DRAW_BUFFER13:
2384     case GraphicsContext3D::DRAW_BUFFER14:
2385     case GraphicsContext3D::DRAW_BUFFER15: {
2386         GC3Dint value = GraphicsContext3D::NONE;
2387         if (m_framebufferBinding)
2388             value = m_framebufferBinding->getDrawBuffer(pname);
2389         else // emulated backbuffer
2390             value = m_backDrawBuffer;
2391         return WebGLGetInfo(value);
2392         }
2393     case GraphicsContext3D::COPY_READ_BUFFER:
2394     case GraphicsContext3D::COPY_WRITE_BUFFER:
2395     case GraphicsContext3D::PIXEL_PACK_BUFFER_BINDING:   
2396     case GraphicsContext3D::PIXEL_UNPACK_BUFFER_BINDING:
2397     case GraphicsContext3D::READ_BUFFER:
2398     case GraphicsContext3D::SAMPLER_BINDING:
2399     case GraphicsContext3D::TEXTURE_BINDING_2D_ARRAY:
2400     case GraphicsContext3D::TEXTURE_BINDING_3D:
2401     case GraphicsContext3D::READ_FRAMEBUFFER_BINDING:
2402     case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER_BINDING:
2403     case GraphicsContext3D::UNIFORM_BUFFER_BINDING:
2404         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "parameter name not yet supported");
2405         return WebGLGetInfo();
2406     default:
2407         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name");
2408         return WebGLGetInfo();
2409     }
2410 }
2411
2412 bool WebGL2RenderingContext::validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired)
2413 {
2414     // Performs conservative validation by caching a maximum index of
2415     // the given type per element array buffer. If all of the bound
2416     // array buffers have enough elements to satisfy that maximum
2417     // index, skips the expensive per-draw-call iteration in
2418     // validateIndexArrayPrecise.
2419     
2420     RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();
2421     
2422     if (!elementArrayBuffer)
2423         return false;
2424     
2425     GC3Dsizeiptr numElements = elementArrayBuffer->byteLength();
2426     // The case count==0 is already dealt with in drawElements before validateIndexArrayConservative.
2427     if (!numElements)
2428         return false;
2429     const ArrayBuffer* buffer = elementArrayBuffer->elementArrayBuffer();
2430     ASSERT(buffer);
2431     
2432     int maxIndex = elementArrayBuffer->getCachedMaxIndex(type);
2433     if (maxIndex < 0) {
2434         // Compute the maximum index in the entire buffer for the given type of index.
2435         switch (type) {
2436         case GraphicsContext3D::UNSIGNED_BYTE: {
2437             const GC3Dubyte* p = static_cast<const GC3Dubyte*>(buffer->data());
2438             for (GC3Dsizeiptr i = 0; i < numElements; i++)
2439                 maxIndex = std::max(maxIndex, static_cast<int>(p[i]));
2440             break;
2441         }
2442         case GraphicsContext3D::UNSIGNED_SHORT: {
2443             numElements /= sizeof(GC3Dushort);
2444             const GC3Dushort* p = static_cast<const GC3Dushort*>(buffer->data());
2445             for (GC3Dsizeiptr i = 0; i < numElements; i++)
2446                 maxIndex = std::max(maxIndex, static_cast<int>(p[i]));
2447             break;
2448         }
2449         case GraphicsContext3D::UNSIGNED_INT: {
2450             numElements /= sizeof(GC3Duint);
2451             const GC3Duint* p = static_cast<const GC3Duint*>(buffer->data());
2452             for (GC3Dsizeiptr i = 0; i < numElements; i++)
2453                 maxIndex = std::max(maxIndex, static_cast<int>(p[i]));
2454             break;
2455         }
2456         default:
2457             return false;
2458         }
2459         elementArrayBuffer->setCachedMaxIndex(type, maxIndex);
2460     }
2461     
2462     if (maxIndex >= 0) {
2463         // The number of required elements is one more than the maximum
2464         // index that will be accessed.
2465         numElementsRequired = maxIndex + 1;
2466         return true;
2467     }
2468     
2469     return false;
2470 }
2471
2472 bool WebGL2RenderingContext::validateBlendEquation(const char* functionName, GC3Denum mode)
2473 {
2474     switch (mode) {
2475     case GraphicsContext3D::FUNC_ADD:
2476     case GraphicsContext3D::FUNC_SUBTRACT:
2477     case GraphicsContext3D::FUNC_REVERSE_SUBTRACT:
2478     case GraphicsContext3D::MIN:
2479     case GraphicsContext3D::MAX:
2480         return true;
2481         break;
2482     default:
2483         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid mode");
2484         return false;
2485     }
2486 }
2487
2488 bool WebGL2RenderingContext::validateCapability(const char* functionName, GC3Denum cap)
2489 {
2490     switch (cap) {
2491     case GraphicsContext3D::BLEND:
2492     case GraphicsContext3D::CULL_FACE:
2493     case GraphicsContext3D::DEPTH_TEST:
2494     case GraphicsContext3D::DITHER:
2495     case GraphicsContext3D::POLYGON_OFFSET_FILL:
2496     case GraphicsContext3D::SAMPLE_ALPHA_TO_COVERAGE:
2497     case GraphicsContext3D::SAMPLE_COVERAGE:
2498     case GraphicsContext3D::SCISSOR_TEST:
2499     case GraphicsContext3D::STENCIL_TEST:
2500     case GraphicsContext3D::RASTERIZER_DISCARD:
2501         return true;
2502     default:
2503         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid capability");
2504         return false;
2505     }
2506 }
2507
2508 } // namespace WebCore
2509
2510 #endif // ENABLE(WEBGL)