882cd60e1278899356d90c2592a9714d980e784f
[WebKit-https.git] / Source / WebCore / html / canvas / WebGLRenderingContextBase.cpp
1 /*
2  * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27
28 #if ENABLE(WEBGL)
29 #include "WebGLRenderingContextBase.h"
30
31 #include "ANGLEInstancedArrays.h"
32 #include "CachedImage.h"
33 #include "DOMWindow.h"
34 #include "Document.h"
35 #include "EXTBlendMinMax.h"
36 #include "EXTFragDepth.h"
37 #include "EXTShaderTextureLOD.h"
38 #include "EXTTextureFilterAnisotropic.h"
39 #include "EXTsRGB.h"
40 #include "ExceptionCode.h"
41 #include "Extensions3D.h"
42 #include "Frame.h"
43 #include "FrameLoader.h"
44 #include "FrameLoaderClient.h"
45 #include "FrameView.h"
46 #include "GraphicsContext.h"
47 #include "HTMLCanvasElement.h"
48 #include "HTMLImageElement.h"
49 #include "HTMLVideoElement.h"
50 #include "ImageBuffer.h"
51 #include "ImageData.h"
52 #include "IntSize.h"
53 #include "Logging.h"
54 #include "MainFrame.h"
55 #include "NotImplemented.h"
56 #include "OESElementIndexUint.h"
57 #include "OESStandardDerivatives.h"
58 #include "OESTextureFloat.h"
59 #include "OESTextureFloatLinear.h"
60 #include "OESTextureHalfFloat.h"
61 #include "OESTextureHalfFloatLinear.h"
62 #include "OESVertexArrayObject.h"
63 #include "Page.h"
64 #include "RenderBox.h"
65 #include "Settings.h"
66 #include "WebGL2RenderingContext.h"
67 #include "WebGLActiveInfo.h"
68 #include "WebGLBuffer.h"
69 #include "WebGLCompressedTextureATC.h"
70 #include "WebGLCompressedTexturePVRTC.h"
71 #include "WebGLCompressedTextureS3TC.h"
72 #include "WebGLContextAttributes.h"
73 #include "WebGLContextEvent.h"
74 #include "WebGLContextGroup.h"
75 #include "WebGLDebugRendererInfo.h"
76 #include "WebGLDebugShaders.h"
77 #include "WebGLDepthTexture.h"
78 #include "WebGLDrawBuffers.h"
79 #include "WebGLFramebuffer.h"
80 #include "WebGLLoseContext.h"
81 #include "WebGLProgram.h"
82 #include "WebGLRenderbuffer.h"
83 #include "WebGLRenderingContext.h"
84 #include "WebGLShader.h"
85 #include "WebGLShaderPrecisionFormat.h"
86 #include "WebGLTexture.h"
87 #include "WebGLUniformLocation.h"
88
89 #include <runtime/JSCInlines.h>
90 #include <runtime/TypedArrayInlines.h>
91 #include <runtime/Uint32Array.h>
92 #include <wtf/CheckedArithmetic.h>
93 #include <wtf/StdLibExtras.h>
94 #include <wtf/text/CString.h>
95 #include <wtf/text/StringBuilder.h>
96
97 namespace WebCore {
98
99 const double secondsBetweenRestoreAttempts = 1.0;
100 const int maxGLErrorsAllowedToConsole = 256;
101
102 namespace {
103     
104     Platform3DObject objectOrZero(WebGLObject* object)
105     {
106         return object ? object->object() : 0;
107     }
108
109     GC3Dint clamp(GC3Dint value, GC3Dint min, GC3Dint max)
110     {
111         if (value < min)
112             value = min;
113         if (value > max)
114             value = max;
115         return value;
116     }
117
118     // Return true if a character belongs to the ASCII subset as defined in
119     // GLSL ES 1.0 spec section 3.1.
120     bool validateCharacter(unsigned char c)
121     {
122         // Printing characters are valid except " $ ` @ \ ' DEL.
123         if (c >= 32 && c <= 126
124             && c != '"' && c != '$' && c != '`' && c != '@' && c != '\\' && c != '\'')
125             return true;
126         // Horizontal tab, line feed, vertical tab, form feed, carriage return
127         // are also valid.
128         if (c >= 9 && c <= 13)
129             return true;
130         return false;
131     }
132
133     bool isPrefixReserved(const String& name)
134     {
135         if (name.startsWith("gl_") || name.startsWith("webgl_") || name.startsWith("_webgl_"))
136             return true;
137         return false;
138     }
139
140     // Strips comments from shader text. This allows non-ASCII characters
141     // to be used in comments without potentially breaking OpenGL
142     // implementations not expecting characters outside the GLSL ES set.
143     class StripComments {
144     public:
145         StripComments(const String& str)
146             : m_parseState(BeginningOfLine)
147             , m_sourceString(str)
148             , m_length(str.length())
149             , m_position(0)
150         {
151             parse();
152         }
153
154         String result()
155         {
156             return m_builder.toString();
157         }
158
159     private:
160         bool hasMoreCharacters() const
161         {
162             return (m_position < m_length);
163         }
164
165         void parse()
166         {
167             while (hasMoreCharacters()) {
168                 process(current());
169                 // process() might advance the position.
170                 if (hasMoreCharacters())
171                     advance();
172             }
173         }
174
175         void process(UChar);
176
177         bool peek(UChar& character) const
178         {
179             if (m_position + 1 >= m_length)
180                 return false;
181             character = m_sourceString[m_position + 1];
182             return true;
183         }
184
185         UChar current() const
186         {
187             ASSERT_WITH_SECURITY_IMPLICATION(m_position < m_length);
188             return m_sourceString[m_position];
189         }
190
191         void advance()
192         {
193             ++m_position;
194         }
195
196         bool isNewline(UChar character) const
197         {
198             // Don't attempt to canonicalize newline related characters.
199             return (character == '\n' || character == '\r');
200         }
201
202         void emit(UChar character)
203         {
204             m_builder.append(character);
205         }
206
207         enum ParseState {
208             // Have not seen an ASCII non-whitespace character yet on
209             // this line. Possible that we might see a preprocessor
210             // directive.
211             BeginningOfLine,
212
213             // Have seen at least one ASCII non-whitespace character
214             // on this line.
215             MiddleOfLine,
216
217             // Handling a preprocessor directive. Passes through all
218             // characters up to the end of the line. Disables comment
219             // processing.
220             InPreprocessorDirective,
221
222             // Handling a single-line comment. The comment text is
223             // replaced with a single space.
224             InSingleLineComment,
225
226             // Handling a multi-line comment. Newlines are passed
227             // through to preserve line numbers.
228             InMultiLineComment
229         };
230
231         ParseState m_parseState;
232         String m_sourceString;
233         unsigned m_length;
234         unsigned m_position;
235         StringBuilder m_builder;
236     };
237
238     void StripComments::process(UChar c)
239     {
240         if (isNewline(c)) {
241             // No matter what state we are in, pass through newlines
242             // so we preserve line numbers.
243             emit(c);
244
245             if (m_parseState != InMultiLineComment)
246                 m_parseState = BeginningOfLine;
247
248             return;
249         }
250
251         UChar temp = 0;
252         switch (m_parseState) {
253         case BeginningOfLine:
254             if (WTF::isASCIISpace(c)) {
255                 emit(c);
256                 break;
257             }
258
259             if (c == '#') {
260                 m_parseState = InPreprocessorDirective;
261                 emit(c);
262                 break;
263             }
264
265             // Transition to normal state and re-handle character.
266             m_parseState = MiddleOfLine;
267             process(c);
268             break;
269
270         case MiddleOfLine:
271             if (c == '/' && peek(temp)) {
272                 if (temp == '/') {
273                     m_parseState = InSingleLineComment;
274                     emit(' ');
275                     advance();
276                     break;
277                 }
278
279                 if (temp == '*') {
280                     m_parseState = InMultiLineComment;
281                     // Emit the comment start in case the user has
282                     // an unclosed comment and we want to later
283                     // signal an error.
284                     emit('/');
285                     emit('*');
286                     advance();
287                     break;
288                 }
289             }
290
291             emit(c);
292             break;
293
294         case InPreprocessorDirective:
295             // No matter what the character is, just pass it
296             // through. Do not parse comments in this state. This
297             // might not be the right thing to do long term, but it
298             // should handle the #error preprocessor directive.
299             emit(c);
300             break;
301
302         case InSingleLineComment:
303             // The newline code at the top of this function takes care
304             // of resetting our state when we get out of the
305             // single-line comment. Swallow all other characters.
306             break;
307
308         case InMultiLineComment:
309             if (c == '*' && peek(temp) && temp == '/') {
310                 emit('*');
311                 emit('/');
312                 m_parseState = MiddleOfLine;
313                 advance();
314                 break;
315             }
316
317             // Swallow all other characters. Unclear whether we may
318             // want or need to just emit a space per character to try
319             // to preserve column numbers for debugging purposes.
320             break;
321         }
322     }
323 } // namespace anonymous
324
325 class WebGLRenderingContextLostCallback : public GraphicsContext3D::ContextLostCallback {
326     WTF_MAKE_FAST_ALLOCATED;
327 public:
328     explicit WebGLRenderingContextLostCallback(WebGLRenderingContextBase* cb) : m_context(cb) { }
329     void onContextLost() override { m_context->forceLostContext(WebGLRenderingContext::RealLostContext); }
330     virtual ~WebGLRenderingContextLostCallback() {}
331 private:
332     WebGLRenderingContextBase* m_context;
333 };
334
335 class WebGLRenderingContextErrorMessageCallback : public GraphicsContext3D::ErrorMessageCallback {
336     WTF_MAKE_FAST_ALLOCATED;
337 public:
338     explicit WebGLRenderingContextErrorMessageCallback(WebGLRenderingContextBase* cb) : m_context(cb) { }
339     void onErrorMessage(const String& message, GC3Dint) override
340     {
341         if (m_context->m_synthesizedErrorsToConsole)
342             m_context->printGLErrorToConsole(message);
343     }
344     virtual ~WebGLRenderingContextErrorMessageCallback() { }
345 private:
346     WebGLRenderingContextBase* m_context;
347 };
348
349 std::unique_ptr<WebGLRenderingContextBase> WebGLRenderingContextBase::create(HTMLCanvasElement* canvas, WebGLContextAttributes* attrs, const String& type)
350 {
351 #if !ENABLE(WEBGL2)
352     UNUSED_PARAM(type);
353 #endif
354
355     Document& document = canvas->document();
356     Frame* frame = document.frame();
357     if (!frame)
358         return nullptr;
359
360     // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in
361     // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.
362     if (!frame->loader().client().allowWebGL(frame->settings().webGLEnabled())) {
363         canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Web page was not allowed to create a WebGL context."));
364         return nullptr;
365     }
366
367     bool isPendingPolicyResolution = false;
368     Document& topDocument = document.topDocument();
369     Page* page = topDocument.page();
370     bool forcingPendingPolicy = frame->settings().isForcePendingWebGLPolicy();
371
372     if (forcingPendingPolicy || (page && !topDocument.url().isLocalFile())) {
373         WebGLLoadPolicy policy = forcingPendingPolicy ? WebGLPendingCreation : page->mainFrame().loader().client().webGLPolicyForURL(topDocument.url());
374
375         if (policy == WebGLBlockCreation) {
376             LOG(WebGL, "The policy for this URL (%s) is to block WebGL.", topDocument.url().host().utf8().data());
377             return nullptr;
378         }
379
380         if (policy == WebGLPendingCreation) {
381             LOG(WebGL, "WebGL policy is pending. May need to be resolved later.");
382             isPendingPolicyResolution = true;
383         }
384     }
385
386     GraphicsContext3D::Attributes attributes = attrs ? attrs->attributes() : GraphicsContext3D::Attributes();
387
388     if (attributes.antialias) {
389         if (!frame->settings().openGLMultisamplingEnabled())
390             attributes.antialias = false;
391     }
392
393     attributes.noExtensions = true;
394     attributes.shareResources = false;
395     attributes.preferDiscreteGPU = true;
396
397     if (frame->settings().forceSoftwareWebGLRendering())
398         attributes.forceSoftwareRenderer = true;
399
400     if (page)
401         attributes.devicePixelRatio = page->deviceScaleFactor();
402
403 #if ENABLE(WEBGL2)
404     if (type == "webgl2")
405         attributes.useGLES3 = true;
406 #endif
407
408     if (isPendingPolicyResolution) {
409         LOG(WebGL, "Create a WebGL context that looks real, but will require a policy resolution if used.");
410         std::unique_ptr<WebGLRenderingContextBase> renderingContext = nullptr;
411 #if ENABLE(WEBGL2)
412         if (type == "webgl2")
413             renderingContext = std::unique_ptr<WebGL2RenderingContext>(new WebGL2RenderingContext(canvas, attributes));
414         else
415 #endif
416             renderingContext = std::unique_ptr<WebGLRenderingContext>(new WebGLRenderingContext(canvas, attributes));
417         renderingContext->suspendIfNeeded();
418         return renderingContext;
419     }
420
421     HostWindow* hostWindow = document.view()->root()->hostWindow();
422     RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(attributes, hostWindow));
423
424     if (!context || !context->makeContextCurrent()) {
425         canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Could not create a WebGL context."));
426         return nullptr;
427     }
428
429     Extensions3D* extensions = context->getExtensions();
430     if (extensions->supports("GL_EXT_debug_marker"))
431         extensions->pushGroupMarkerEXT("WebGLRenderingContext");
432
433     std::unique_ptr<WebGLRenderingContextBase> renderingContext = nullptr;
434 #if ENABLE(WEBGL2)
435     if (type == "webgl2")
436         renderingContext = std::unique_ptr<WebGL2RenderingContext>(new WebGL2RenderingContext(canvas, context, attributes));
437     else
438 #endif
439         renderingContext = std::unique_ptr<WebGLRenderingContext>(new WebGLRenderingContext(canvas, context, attributes));
440     renderingContext->suspendIfNeeded();
441
442     return renderingContext;
443 }
444
445 WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)
446     : CanvasRenderingContext(passedCanvas)
447     , ActiveDOMObject(&passedCanvas->document())
448     , m_context(0)
449     , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContextBase::dispatchContextLostEvent)
450     , m_restoreAllowed(false)
451     , m_restoreTimer(*this, &WebGLRenderingContextBase::maybeRestoreContext)
452     , m_generatedImageCache(0)
453     , m_contextLost(false)
454     , m_contextLostMode(SyntheticLostContext)
455     , m_attributes(attributes)
456     , m_synthesizedErrorsToConsole(true)
457     , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)
458     , m_isPendingPolicyResolution(true)
459     , m_hasRequestedPolicyResolution(false)
460 {
461 }
462
463 WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context, GraphicsContext3D::Attributes attributes)
464     : CanvasRenderingContext(passedCanvas)
465     , ActiveDOMObject(&passedCanvas->document())
466     , m_context(context)
467     , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContextBase::dispatchContextLostEvent)
468     , m_restoreAllowed(false)
469     , m_restoreTimer(*this, &WebGLRenderingContextBase::maybeRestoreContext)
470     , m_generatedImageCache(4)
471     , m_contextLost(false)
472     , m_contextLostMode(SyntheticLostContext)
473     , m_attributes(attributes)
474     , m_synthesizedErrorsToConsole(true)
475     , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)
476     , m_isPendingPolicyResolution(false)
477     , m_hasRequestedPolicyResolution(false)
478 {
479     ASSERT(m_context);
480     m_contextGroup = WebGLContextGroup::create();
481     m_contextGroup->addContext(this);
482     
483     m_context->setWebGLContext(this);
484
485     m_maxViewportDims[0] = m_maxViewportDims[1] = 0;
486     m_context->getIntegerv(GraphicsContext3D::MAX_VIEWPORT_DIMS, m_maxViewportDims);
487
488     setupFlags();
489     initializeNewContext();
490 }
491
492 void WebGLRenderingContextBase::initializeNewContext()
493 {
494     ASSERT(!m_contextLost);
495     m_needsUpdate = true;
496     m_markedCanvasDirty = false;
497     m_activeTextureUnit = 0;
498     m_packAlignment = 4;
499     m_unpackAlignment = 4;
500     m_unpackFlipY = false;
501     m_unpackPremultiplyAlpha = false;
502     m_unpackColorspaceConversion = GraphicsContext3D::BROWSER_DEFAULT_WEBGL;
503     m_boundArrayBuffer = nullptr;
504     m_currentProgram = nullptr;
505     m_framebufferBinding = nullptr;
506     m_renderbufferBinding = nullptr;
507     m_depthMask = true;
508     m_stencilEnabled = false;
509     m_stencilMask = 0xFFFFFFFF;
510     m_stencilMaskBack = 0xFFFFFFFF;
511     m_stencilFuncRef = 0;
512     m_stencilFuncRefBack = 0;
513     m_stencilFuncMask = 0xFFFFFFFF;
514     m_stencilFuncMaskBack = 0xFFFFFFFF;
515     m_layerCleared = false;
516     m_numGLErrorsToConsoleAllowed = maxGLErrorsAllowedToConsole;
517     
518     m_clearColor[0] = m_clearColor[1] = m_clearColor[2] = m_clearColor[3] = 0;
519     m_scissorEnabled = false;
520     m_clearDepth = 1;
521     m_clearStencil = 0;
522     m_colorMask[0] = m_colorMask[1] = m_colorMask[2] = m_colorMask[3] = true;
523
524     GC3Dint numCombinedTextureImageUnits = 0;
525     m_context->getIntegerv(GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);
526     m_textureUnits.clear();
527     m_textureUnits.resize(numCombinedTextureImageUnits);
528     for (GC3Dint i = 0; i < numCombinedTextureImageUnits; ++i)
529         m_unrenderableTextureUnits.add(i);
530
531     GC3Dint numVertexAttribs = 0;
532     m_context->getIntegerv(GraphicsContext3D::MAX_VERTEX_ATTRIBS, &numVertexAttribs);
533     m_maxVertexAttribs = numVertexAttribs;
534     
535     m_maxTextureSize = 0;
536     m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_maxTextureSize);
537     m_maxTextureLevel = WebGLTexture::computeLevelCount(m_maxTextureSize, m_maxTextureSize);
538     m_maxCubeMapTextureSize = 0;
539     m_context->getIntegerv(GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE, &m_maxCubeMapTextureSize);
540     m_maxCubeMapTextureLevel = WebGLTexture::computeLevelCount(m_maxCubeMapTextureSize, m_maxCubeMapTextureSize);
541     m_maxRenderbufferSize = 0;
542     m_context->getIntegerv(GraphicsContext3D::MAX_RENDERBUFFER_SIZE, &m_maxRenderbufferSize);
543
544     // These two values from EXT_draw_buffers are lazily queried.
545     m_maxDrawBuffers = 0;
546     m_maxColorAttachments = 0;
547
548     m_backDrawBuffer = GraphicsContext3D::BACK;
549     m_drawBuffersWebGLRequirementsChecked = false;
550     m_drawBuffersSupported = false;
551     
552     m_vertexAttribValue.resize(m_maxVertexAttribs);
553
554     if (!isGLES2NPOTStrict())
555         createFallbackBlackTextures1x1();
556
557     IntSize canvasSize = clampedCanvasSize();
558     m_context->reshape(canvasSize.width(), canvasSize.height());
559     m_context->viewport(0, 0, canvasSize.width(), canvasSize.height());
560     m_context->scissor(0, 0, canvasSize.width(), canvasSize.height());
561
562     m_context->setContextLostCallback(std::make_unique<WebGLRenderingContextLostCallback>(this));
563     m_context->setErrorMessageCallback(std::make_unique<WebGLRenderingContextErrorMessageCallback>(this));
564 }
565
566 void WebGLRenderingContextBase::setupFlags()
567 {
568     ASSERT(m_context);
569
570     if (Page* page = canvas()->document().page())
571         m_synthesizedErrorsToConsole = page->settings().webGLErrorsToConsoleEnabled();
572
573     m_isGLES2Compliant = m_context->isGLES2Compliant();
574     m_isErrorGeneratedOnOutOfBoundsAccesses = m_context->getExtensions()->isEnabled("GL_CHROMIUM_strict_attribs");
575     m_isResourceSafe = m_context->getExtensions()->isEnabled("GL_CHROMIUM_resource_safe");
576     if (m_isGLES2Compliant) {
577         m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_OES_texture_npot");
578         m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_OES_packed_depth_stencil");
579     } else {
580         m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_ARB_texture_non_power_of_two");
581         m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_EXT_packed_depth_stencil");
582     }
583     m_isRobustnessEXTSupported = m_context->getExtensions()->isEnabled("GL_EXT_robustness");
584 }
585
586 void WebGLRenderingContextBase::addCompressedTextureFormat(GC3Denum format)
587 {
588     if (!m_compressedTextureFormats.contains(format))
589         m_compressedTextureFormats.append(format);
590 }
591
592 WebGLRenderingContextBase::~WebGLRenderingContextBase()
593 {
594     // Remove all references to WebGLObjects so if they are the last reference
595     // they will be freed before the last context is removed from the context group.
596     m_boundArrayBuffer = nullptr;
597     m_defaultVertexArrayObject = nullptr;
598     m_boundVertexArrayObject = nullptr;
599     m_vertexAttrib0Buffer = nullptr;
600     m_currentProgram = nullptr;
601     m_framebufferBinding = nullptr;
602     m_renderbufferBinding = nullptr;
603
604     for (auto& textureUnit : m_textureUnits) {
605         textureUnit.texture2DBinding = nullptr;
606         textureUnit.textureCubeMapBinding = nullptr;
607     }
608
609     m_blackTexture2D = nullptr;
610     m_blackTextureCubeMap = nullptr;
611
612     if (!m_isPendingPolicyResolution) {
613         detachAndRemoveAllObjects();
614         destroyGraphicsContext3D();
615         m_contextGroup->removeContext(this);
616     }
617 }
618
619 void WebGLRenderingContextBase::destroyGraphicsContext3D()
620 {
621     if (m_isPendingPolicyResolution)
622         return;
623
624     if (m_context) {
625         m_context->setContextLostCallback(nullptr);
626         m_context->setErrorMessageCallback(nullptr);
627         m_context = nullptr;
628     }
629 }
630
631 void WebGLRenderingContextBase::markContextChanged()
632 {
633     if (m_framebufferBinding)
634         return;
635
636     m_context->markContextChanged();
637
638     m_layerCleared = false;
639     RenderBox* renderBox = canvas()->renderBox();
640     if (isAccelerated() && renderBox && renderBox->hasAcceleratedCompositing()) {
641         m_markedCanvasDirty = true;
642         canvas()->clearCopiedImage();
643         renderBox->contentChanged(CanvasChanged);
644     } else {
645         if (!m_markedCanvasDirty) {
646             m_markedCanvasDirty = true;
647             canvas()->didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));
648         }
649     }
650 }
651
652 bool WebGLRenderingContextBase::clearIfComposited(GC3Dbitfield mask)
653 {
654     if (isContextLostOrPending())
655         return false;
656
657     if (!m_context->layerComposited() || m_layerCleared
658         || m_attributes.preserveDrawingBuffer || (mask && m_framebufferBinding))
659         return false;
660
661     RefPtr<WebGLContextAttributes> contextAttributes = getContextAttributes();
662
663     // Determine if it's possible to combine the clear the user asked for and this clear.
664     bool combinedClear = mask && !m_scissorEnabled;
665
666     m_context->disable(GraphicsContext3D::SCISSOR_TEST);
667     if (combinedClear && (mask & GraphicsContext3D::COLOR_BUFFER_BIT))
668         m_context->clearColor(m_colorMask[0] ? m_clearColor[0] : 0,
669                               m_colorMask[1] ? m_clearColor[1] : 0,
670                               m_colorMask[2] ? m_clearColor[2] : 0,
671                               m_colorMask[3] ? m_clearColor[3] : 0);
672     else
673         m_context->clearColor(0, 0, 0, 0);
674     m_context->colorMask(true, true, true, true);
675     GC3Dbitfield clearMask = GraphicsContext3D::COLOR_BUFFER_BIT;
676     if (contextAttributes->depth()) {
677         if (!combinedClear || !m_depthMask || !(mask & GraphicsContext3D::DEPTH_BUFFER_BIT))
678             m_context->clearDepth(1.0f);
679         clearMask |= GraphicsContext3D::DEPTH_BUFFER_BIT;
680         m_context->depthMask(true);
681     }
682     if (contextAttributes->stencil()) {
683         if (combinedClear && (mask & GraphicsContext3D::STENCIL_BUFFER_BIT))
684             m_context->clearStencil(m_clearStencil & m_stencilMask);
685         else
686             m_context->clearStencil(0);
687         clearMask |= GraphicsContext3D::STENCIL_BUFFER_BIT;
688         m_context->stencilMaskSeparate(GraphicsContext3D::FRONT, 0xFFFFFFFF);
689     }
690     if (m_framebufferBinding)
691         m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);
692     m_context->clear(clearMask);
693
694     restoreStateAfterClear();
695     if (m_framebufferBinding)
696         m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
697     m_layerCleared = true;
698
699     return combinedClear;
700 }
701
702 void WebGLRenderingContextBase::restoreStateAfterClear()
703 {
704     // Restore the state that the context set.
705     if (m_scissorEnabled)
706         m_context->enable(GraphicsContext3D::SCISSOR_TEST);
707     m_context->clearColor(m_clearColor[0], m_clearColor[1],
708                           m_clearColor[2], m_clearColor[3]);
709     m_context->colorMask(m_colorMask[0], m_colorMask[1],
710                          m_colorMask[2], m_colorMask[3]);
711     m_context->clearDepth(m_clearDepth);
712     m_context->clearStencil(m_clearStencil);
713     m_context->stencilMaskSeparate(GraphicsContext3D::FRONT, m_stencilMask);
714     m_context->depthMask(m_depthMask);
715 }
716
717 void WebGLRenderingContextBase::markLayerComposited()
718 {
719     if (isContextLostOrPending())
720         return;
721     m_context->markLayerComposited();
722 }
723
724 void WebGLRenderingContextBase::paintRenderingResultsToCanvas()
725 {
726     if (isContextLostOrPending())
727         return;
728
729     if (canvas()->document().printing())
730         canvas()->clearPresentationCopy();
731
732     // Until the canvas is written to by the application, the clear that
733     // happened after it was composited should be ignored by the compositor.
734     if (m_context->layerComposited() && !m_attributes.preserveDrawingBuffer) {
735         m_context->paintCompositedResultsToCanvas(canvas()->buffer());
736
737         canvas()->makePresentationCopy();
738     } else
739         canvas()->clearPresentationCopy();
740     clearIfComposited();
741
742     if (!m_markedCanvasDirty && !m_layerCleared)
743         return;
744
745     canvas()->clearCopiedImage();
746     m_markedCanvasDirty = false;
747
748     m_context->paintRenderingResultsToCanvas(canvas()->buffer());
749 }
750
751 PassRefPtr<ImageData> WebGLRenderingContextBase::paintRenderingResultsToImageData()
752 {
753     if (isContextLostOrPending())
754         return nullptr;
755     clearIfComposited();
756     return m_context->paintRenderingResultsToImageData();
757 }
758
759 WebGLTexture::TextureExtensionFlag WebGLRenderingContextBase::textureExtensionFlags() const
760 {
761     return static_cast<WebGLTexture::TextureExtensionFlag>((m_oesTextureFloatLinear ? WebGLTexture::TextureExtensionFloatLinearEnabled : 0) | (m_oesTextureHalfFloatLinear ? WebGLTexture::TextureExtensionHalfFloatLinearEnabled : 0));
762 }
763
764 void WebGLRenderingContextBase::reshape(int width, int height)
765 {
766     if (isContextLostOrPending())
767         return;
768
769     // This is an approximation because at WebGLRenderingContext level we don't
770     // know if the underlying FBO uses textures or renderbuffers.
771     GC3Dint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);
772     // Limit drawing buffer size to 4k to avoid memory exhaustion.
773     const int sizeUpperLimit = 4096;
774     maxSize = std::min(maxSize, sizeUpperLimit);
775     GC3Dint maxWidth = std::min(maxSize, m_maxViewportDims[0]);
776     GC3Dint maxHeight = std::min(maxSize, m_maxViewportDims[1]);
777     width = clamp(width, 1, maxWidth);
778     height = clamp(height, 1, maxHeight);
779
780     if (m_needsUpdate) {
781         RenderBox* renderBox = canvas()->renderBox();
782         if (renderBox && renderBox->hasAcceleratedCompositing())
783             renderBox->contentChanged(CanvasChanged);
784         m_needsUpdate = false;
785     }
786
787     // We don't have to mark the canvas as dirty, since the newly created image buffer will also start off
788     // clear (and this matches what reshape will do).
789     m_context->reshape(width, height);
790
791     auto& textureUnit = m_textureUnits[m_activeTextureUnit];
792     m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(textureUnit.texture2DBinding.get()));
793     if (textureUnit.texture2DBinding && textureUnit.texture2DBinding->needToUseBlackTexture(textureExtensionFlags()))
794         m_unrenderableTextureUnits.add(m_activeTextureUnit);
795     m_context->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, objectOrZero(m_renderbufferBinding.get()));
796     if (m_framebufferBinding)
797       m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
798 }
799
800 int WebGLRenderingContextBase::drawingBufferWidth() const
801 {
802     if (m_isPendingPolicyResolution && !m_hasRequestedPolicyResolution)
803         return 0;
804
805     return m_context->getInternalFramebufferSize().width();
806 }
807
808 int WebGLRenderingContextBase::drawingBufferHeight() const
809 {
810     if (m_isPendingPolicyResolution && !m_hasRequestedPolicyResolution)
811         return 0;
812
813     return m_context->getInternalFramebufferSize().height();
814 }
815
816 unsigned WebGLRenderingContextBase::sizeInBytes(GC3Denum type)
817 {
818     switch (type) {
819     case GraphicsContext3D::BYTE:
820         return sizeof(GC3Dbyte);
821     case GraphicsContext3D::UNSIGNED_BYTE:
822         return sizeof(GC3Dubyte);
823     case GraphicsContext3D::SHORT:
824         return sizeof(GC3Dshort);
825     case GraphicsContext3D::UNSIGNED_SHORT:
826         return sizeof(GC3Dushort);
827     case GraphicsContext3D::INT:
828         return sizeof(GC3Dint);
829     case GraphicsContext3D::UNSIGNED_INT:
830         return sizeof(GC3Duint);
831     case GraphicsContext3D::FLOAT:
832         return sizeof(GC3Dfloat);
833     }
834     ASSERT_NOT_REACHED();
835     return 0;
836 }
837
838 void WebGLRenderingContextBase::activeTexture(GC3Denum texture, ExceptionCode&)
839 {
840     if (isContextLostOrPending())
841         return;
842     if (texture - GraphicsContext3D::TEXTURE0 >= m_textureUnits.size()) {
843         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "activeTexture", "texture unit out of range");
844         return;
845     }
846     m_activeTextureUnit = texture - GraphicsContext3D::TEXTURE0;
847     m_context->activeTexture(texture);
848 }
849
850 void WebGLRenderingContextBase::attachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode&)
851 {
852     if (isContextLostOrPending() || !validateWebGLObject("attachShader", program) || !validateWebGLObject("attachShader", shader))
853         return;
854     if (!program->attachShader(shader)) {
855         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "attachShader", "shader attachment already has shader");
856         return;
857     }
858     m_context->attachShader(objectOrZero(program), objectOrZero(shader));
859     shader->onAttached();
860 }
861
862 void WebGLRenderingContextBase::bindAttribLocation(WebGLProgram* program, GC3Duint index, const String& name, ExceptionCode&)
863 {
864     if (isContextLostOrPending() || !validateWebGLObject("bindAttribLocation", program))
865         return;
866     if (!validateLocationLength("bindAttribLocation", name))
867         return;
868     if (!validateString("bindAttribLocation", name))
869         return;
870     if (isPrefixReserved(name)) {
871         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindAttribLocation", "reserved prefix");
872         return;
873     }
874     if (index >= m_maxVertexAttribs) {
875         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bindAttribLocation", "index out of range");
876         return;
877     }
878     m_context->bindAttribLocation(objectOrZero(program), index, name);
879 }
880
881 bool WebGLRenderingContextBase::checkObjectToBeBound(const char* functionName, WebGLObject* object, bool& deleted)
882 {
883     deleted = false;
884     if (isContextLostOrPending())
885         return false;
886     if (object) {
887         if (!object->validate(contextGroup(), this)) {
888             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "object not from this context");
889             return false;
890         }
891         deleted = !object->object();
892     }
893     return true;
894 }
895
896 void WebGLRenderingContextBase::bindBuffer(GC3Denum target, WebGLBuffer* buffer, ExceptionCode&)
897 {
898     bool deleted;
899     if (!checkObjectToBeBound("bindBuffer", buffer, deleted))
900         return;
901     if (deleted)
902         buffer = 0;
903     if (buffer && buffer->getTarget() && buffer->getTarget() != target) {
904         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindBuffer", "buffers can not be used with multiple targets");
905         return;
906     }
907     if (target == GraphicsContext3D::ARRAY_BUFFER)
908         m_boundArrayBuffer = buffer;
909     else if (target == GraphicsContext3D::ELEMENT_ARRAY_BUFFER)
910         m_boundVertexArrayObject->setElementArrayBuffer(buffer);
911     else {
912         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindBuffer", "invalid target");
913         return;
914     }
915
916     m_context->bindBuffer(target, objectOrZero(buffer));
917     if (buffer)
918         buffer->setTarget(target);
919 }
920
921 void WebGLRenderingContextBase::bindFramebuffer(GC3Denum target, WebGLFramebuffer* buffer, ExceptionCode&)
922 {
923     bool deleted;
924     if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))
925         return;
926     if (deleted)
927         buffer = 0;
928     if (target != GraphicsContext3D::FRAMEBUFFER) {
929         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindFramebuffer", "invalid target");
930         return;
931     }
932     m_framebufferBinding = buffer;
933     m_context->bindFramebuffer(target, objectOrZero(buffer));
934     if (buffer)
935         buffer->setHasEverBeenBound();
936     applyStencilTest();
937 }
938
939 void WebGLRenderingContextBase::bindRenderbuffer(GC3Denum target, WebGLRenderbuffer* renderBuffer, ExceptionCode&)
940 {
941     bool deleted;
942     if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer, deleted))
943         return;
944     if (deleted)
945         renderBuffer = 0;
946     if (target != GraphicsContext3D::RENDERBUFFER) {
947         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindRenderbuffer", "invalid target");
948         return;
949     }
950     m_renderbufferBinding = renderBuffer;
951     m_context->bindRenderbuffer(target, objectOrZero(renderBuffer));
952     if (renderBuffer)
953         renderBuffer->setHasEverBeenBound();
954 }
955
956 void WebGLRenderingContextBase::bindTexture(GC3Denum target, WebGLTexture* texture, ExceptionCode&)
957 {
958     bool deleted;
959     if (!checkObjectToBeBound("bindTexture", texture, deleted))
960         return;
961     if (deleted)
962         texture = nullptr;
963     if (texture && texture->getTarget() && texture->getTarget() != target) {
964         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindTexture", "textures can not be used with multiple targets");
965         return;
966     }
967     GC3Dint maxLevel = 0;
968     auto& textureUnit = m_textureUnits[m_activeTextureUnit];
969     if (target == GraphicsContext3D::TEXTURE_2D) {
970         textureUnit.texture2DBinding = texture;
971         maxLevel = m_maxTextureLevel;
972         if (texture && texture->needToUseBlackTexture(textureExtensionFlags()))
973             m_unrenderableTextureUnits.add(m_activeTextureUnit);
974         else
975             m_unrenderableTextureUnits.remove(m_activeTextureUnit);
976     } else if (target == GraphicsContext3D::TEXTURE_CUBE_MAP) {
977         textureUnit.textureCubeMapBinding = texture;
978         maxLevel = m_maxCubeMapTextureLevel;
979         if (texture && texture->needToUseBlackTexture(textureExtensionFlags()))
980             m_unrenderableTextureUnits.add(m_activeTextureUnit);
981         else
982             m_unrenderableTextureUnits.remove(m_activeTextureUnit);
983     } else {
984         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindTexture", "invalid target");
985         return;
986     }
987     m_context->bindTexture(target, objectOrZero(texture));
988     if (texture)
989         texture->setTarget(target, maxLevel);
990
991     // Note: previously we used to automatically set the TEXTURE_WRAP_R
992     // repeat mode to CLAMP_TO_EDGE for cube map textures, because OpenGL
993     // ES 2.0 doesn't expose this flag (a bug in the specification) and
994     // otherwise the application has no control over the seams in this
995     // dimension. However, it appears that supporting this properly on all
996     // platforms is fairly involved (will require a HashMap from texture ID
997     // in all ports), and we have not had any complaints, so the logic has
998     // been removed.
999 }
1000
1001 void WebGLRenderingContextBase::blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha)
1002 {
1003     if (isContextLostOrPending())
1004         return;
1005     m_context->blendColor(red, green, blue, alpha);
1006 }
1007
1008 void WebGLRenderingContextBase::blendEquation(GC3Denum mode)
1009 {
1010     if (isContextLostOrPending() || !validateBlendEquation("blendEquation", mode))
1011         return;
1012     m_context->blendEquation(mode);
1013 }
1014
1015 void WebGLRenderingContextBase::blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha)
1016 {
1017     if (isContextLostOrPending() || !validateBlendEquation("blendEquation", modeRGB) || !validateBlendEquation("blendEquation", modeAlpha))
1018         return;
1019     m_context->blendEquationSeparate(modeRGB, modeAlpha);
1020 }
1021
1022
1023 void WebGLRenderingContextBase::blendFunc(GC3Denum sfactor, GC3Denum dfactor)
1024 {
1025     if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", sfactor, dfactor))
1026         return;
1027     m_context->blendFunc(sfactor, dfactor);
1028 }
1029
1030 void WebGLRenderingContextBase::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha)
1031 {
1032     // Note: Alpha does not have the same restrictions as RGB.
1033     if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", srcRGB, dstRGB))
1034         return;
1035     m_context->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
1036 }
1037
1038 void WebGLRenderingContextBase::bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode&)
1039 {
1040     if (isContextLostOrPending())
1041         return;
1042     WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);
1043     if (!buffer)
1044         return;
1045     if (size < 0) {
1046         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "size < 0");
1047         return;
1048     }
1049     if (!size) {
1050         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "size == 0");
1051         return;
1052     }
1053     if (!isErrorGeneratedOnOutOfBoundsAccesses()) {
1054         if (!buffer->associateBufferData(static_cast<GC3Dsizeiptr>(size))) {
1055             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");
1056             return;
1057         }
1058     }
1059
1060     m_context->moveErrorsToSyntheticErrorList();
1061     m_context->bufferData(target, static_cast<GC3Dsizeiptr>(size), usage);
1062     if (m_context->moveErrorsToSyntheticErrorList()) {
1063         // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.
1064         buffer->disassociateBufferData();
1065     }
1066 }
1067
1068 void WebGLRenderingContextBase::bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode&)
1069 {
1070     if (isContextLostOrPending())
1071         return;
1072     WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);
1073     if (!buffer)
1074         return;
1075     if (!data) {
1076         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "no data");
1077         return;
1078     }
1079     if (!isErrorGeneratedOnOutOfBoundsAccesses()) {
1080         if (!buffer->associateBufferData(data)) {
1081             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");
1082             return;
1083         }
1084     }
1085
1086     m_context->moveErrorsToSyntheticErrorList();
1087     m_context->bufferData(target, data->byteLength(), data->data(), usage);
1088     if (m_context->moveErrorsToSyntheticErrorList()) {
1089         // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.
1090         buffer->disassociateBufferData();
1091     }
1092 }
1093
1094 void WebGLRenderingContextBase::bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode&)
1095 {
1096     if (isContextLostOrPending())
1097         return;
1098     WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);
1099     if (!buffer)
1100         return;
1101     if (!data) {
1102         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "no data");
1103         return;
1104     }
1105     if (!isErrorGeneratedOnOutOfBoundsAccesses()) {
1106         if (!buffer->associateBufferData(data)) {
1107             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");
1108             return;
1109         }
1110     }
1111
1112     m_context->moveErrorsToSyntheticErrorList();
1113     m_context->bufferData(target, data->byteLength(), data->baseAddress(), usage);
1114     if (m_context->moveErrorsToSyntheticErrorList()) {
1115         // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.
1116         buffer->disassociateBufferData();
1117     }
1118 }
1119
1120 void WebGLRenderingContextBase::bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode&)
1121 {
1122     if (isContextLostOrPending())
1123         return;
1124     WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);
1125     if (!buffer)
1126         return;
1127     if (offset < 0) {
1128         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset < 0");
1129         return;
1130     }
1131     if (!data)
1132         return;
1133     if (!isErrorGeneratedOnOutOfBoundsAccesses()) {
1134         if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data)) {
1135             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset out of range");
1136             return;
1137         }
1138     }
1139
1140     m_context->moveErrorsToSyntheticErrorList();
1141     m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->data());
1142     if (m_context->moveErrorsToSyntheticErrorList()) {
1143         // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.
1144         buffer->disassociateBufferData();
1145     }
1146 }
1147
1148 void WebGLRenderingContextBase::bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode&)
1149 {
1150     if (isContextLostOrPending())
1151         return;
1152     WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);
1153     if (!buffer)
1154         return;
1155     if (offset < 0) {
1156         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset < 0");
1157         return;
1158     }
1159     if (!data)
1160         return;
1161     if (!isErrorGeneratedOnOutOfBoundsAccesses()) {
1162         if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data)) {
1163             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset out of range");
1164             return;
1165         }
1166     }
1167
1168     m_context->moveErrorsToSyntheticErrorList();
1169     m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->baseAddress());
1170     if (m_context->moveErrorsToSyntheticErrorList()) {
1171         // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.
1172         buffer->disassociateBufferData();
1173     }
1174 }
1175
1176 GC3Denum WebGLRenderingContextBase::checkFramebufferStatus(GC3Denum target)
1177 {
1178     if (isContextLostOrPending())
1179         return GraphicsContext3D::FRAMEBUFFER_UNSUPPORTED;
1180     if (target != GraphicsContext3D::FRAMEBUFFER) {
1181         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "checkFramebufferStatus", "invalid target");
1182         return 0;
1183     }
1184     if (!m_framebufferBinding || !m_framebufferBinding->object())
1185         return GraphicsContext3D::FRAMEBUFFER_COMPLETE;
1186     const char* reason = "framebuffer incomplete";
1187     GC3Denum result = m_framebufferBinding->checkStatus(&reason);
1188     if (result != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {
1189         printGLWarningToConsole("checkFramebufferStatus", reason);
1190         return result;
1191     }
1192     result = m_context->checkFramebufferStatus(target);
1193     return result;
1194 }
1195
1196 void WebGLRenderingContextBase::clearColor(GC3Dfloat r, GC3Dfloat g, GC3Dfloat b, GC3Dfloat a)
1197 {
1198     if (isContextLostOrPending())
1199         return;
1200     if (std::isnan(r))
1201         r = 0;
1202     if (std::isnan(g))
1203         g = 0;
1204     if (std::isnan(b))
1205         b = 0;
1206     if (std::isnan(a))
1207         a = 1;
1208     m_clearColor[0] = r;
1209     m_clearColor[1] = g;
1210     m_clearColor[2] = b;
1211     m_clearColor[3] = a;
1212     m_context->clearColor(r, g, b, a);
1213 }
1214
1215 void WebGLRenderingContextBase::clearDepth(GC3Dfloat depth)
1216 {
1217     if (isContextLostOrPending())
1218         return;
1219     m_clearDepth = depth;
1220     m_context->clearDepth(depth);
1221 }
1222
1223 void WebGLRenderingContextBase::clearStencil(GC3Dint s)
1224 {
1225     if (isContextLostOrPending())
1226         return;
1227     m_clearStencil = s;
1228     m_context->clearStencil(s);
1229 }
1230
1231 void WebGLRenderingContextBase::colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha)
1232 {
1233     if (isContextLostOrPending())
1234         return;
1235     m_colorMask[0] = red;
1236     m_colorMask[1] = green;
1237     m_colorMask[2] = blue;
1238     m_colorMask[3] = alpha;
1239     m_context->colorMask(red, green, blue, alpha);
1240 }
1241
1242 void WebGLRenderingContextBase::compileShader(WebGLShader* shader, ExceptionCode&)
1243 {
1244     if (isContextLostOrPending() || !validateWebGLObject("compileShader", shader))
1245         return;
1246     m_context->compileShader(objectOrZero(shader));
1247     GC3Dint value;
1248     m_context->getShaderiv(objectOrZero(shader), GraphicsContext3D::COMPILE_STATUS, &value);
1249     shader->setValid(value);
1250 }
1251
1252 void WebGLRenderingContextBase::compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,
1253                                                  GC3Dsizei height, GC3Dint border, ArrayBufferView* data)
1254 {
1255     if (isContextLostOrPending())
1256         return;
1257     if (!validateTexFuncLevel("compressedTexImage2D", target, level))
1258         return;
1259
1260     if (!validateCompressedTexFormat(internalformat)) {
1261         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "compressedTexImage2D", "invalid internalformat");
1262         return;
1263     }
1264     if (border) {
1265         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "compressedTexImage2D", "border not 0");
1266         return;
1267     }
1268     if (!validateCompressedTexDimensions("compressedTexImage2D", target, level, width, height, internalformat))
1269         return;
1270     if (!validateCompressedTexFuncData("compressedTexImage2D", width, height, internalformat, data))
1271         return;
1272
1273     WebGLTexture* tex = validateTextureBinding("compressedTexImage2D", target, true);
1274     if (!tex)
1275         return;
1276     if (!validateNPOTTextureLevel(width, height, level, "compressedTexImage2D"))
1277         return;
1278     m_context->moveErrorsToSyntheticErrorList();
1279     m_context->compressedTexImage2D(target, level, internalformat, width, height,
1280         border, data->byteLength(), data->baseAddress());
1281     if (m_context->moveErrorsToSyntheticErrorList()) {
1282         // The compressedTexImage2D function failed. Tell the WebGLTexture it doesn't have the data for this level.
1283         tex->markInvalid(target, level);
1284         return;
1285     }
1286
1287     tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
1288     tex->setCompressed();
1289 }
1290
1291 void WebGLRenderingContextBase::compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
1292                                                     GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data)
1293 {
1294     if (isContextLostOrPending())
1295         return;
1296     if (!validateTexFuncLevel("compressedTexSubImage2D", target, level))
1297         return;
1298     if (!validateCompressedTexFormat(format)) {
1299         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "compressedTexSubImage2D", "invalid format");
1300         return;
1301     }
1302     if (!validateCompressedTexFuncData("compressedTexSubImage2D", width, height, format, data))
1303         return;
1304
1305     WebGLTexture* tex = validateTextureBinding("compressedTexSubImage2D", target, true);
1306     if (!tex)
1307         return;
1308
1309     if (format != tex->getInternalFormat(target, level)) {
1310         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "compressedTexSubImage2D", "format does not match texture format");
1311         return;
1312     }
1313
1314     if (!validateCompressedTexSubDimensions("compressedTexSubImage2D", target, level, xoffset, yoffset, width, height, format, tex))
1315         return;
1316
1317     graphicsContext3D()->compressedTexSubImage2D(target, level, xoffset, yoffset,
1318                                                  width, height, format, data->byteLength(), data->baseAddress());
1319     tex->setCompressed();
1320 }
1321
1322 bool WebGLRenderingContextBase::validateSettableTexFormat(const char* functionName, GC3Denum format)
1323 {
1324     if (GraphicsContext3D::getClearBitsByFormat(format) & (GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {
1325         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "format can not be set, only rendered to");
1326         return false;
1327     }
1328     return true;
1329 }
1330
1331 void WebGLRenderingContextBase::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
1332 {
1333     if (isContextLostOrPending())
1334         return;
1335     if (!validateTexFuncLevel("copyTexSubImage2D", target, level))
1336         return;
1337     WebGLTexture* tex = validateTextureBinding("copyTexSubImage2D", target, true);
1338     if (!tex)
1339         return;
1340     if (!validateSize("copyTexSubImage2D", xoffset, yoffset) || !validateSize("copyTexSubImage2D", width, height))
1341         return;
1342     // Before checking if it is in the range, check if overflow happens first.
1343     if (xoffset + width < 0 || yoffset + height < 0) {
1344         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "bad dimensions");
1345         return;
1346     }
1347     if (xoffset + width > tex->getWidth(target, level) || yoffset + height > tex->getHeight(target, level)) {
1348         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "rectangle out of range");
1349         return;
1350     }
1351     GC3Denum internalformat = tex->getInternalFormat(target, level);
1352     if (!validateSettableTexFormat("copyTexSubImage2D", internalformat))
1353         return;
1354     if (!isTexInternalFormatColorBufferCombinationValid(internalformat, getBoundFramebufferColorFormat())) {
1355         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyTexSubImage2D", "framebuffer is incompatible format");
1356         return;
1357     }
1358     const char* reason = "framebuffer incomplete";
1359     if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {
1360         synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "copyTexSubImage2D", reason);
1361         return;
1362     }
1363     clearIfComposited();
1364     if (isResourceSafe())
1365         m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
1366     else {
1367         GC3Dint clippedX, clippedY;
1368         GC3Dsizei clippedWidth, clippedHeight;
1369         if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {
1370             GC3Denum format = tex->getInternalFormat(target, level);
1371             GC3Denum type = tex->getType(target, level);
1372             std::unique_ptr<unsigned char[]> zero;
1373             if (width && height) {
1374                 unsigned int size;
1375                 GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &size, 0);
1376                 if (error != GraphicsContext3D::NO_ERROR) {
1377                     synthesizeGLError(error, "copyTexSubImage2D", "bad dimensions");
1378                     return;
1379                 }
1380                 zero = std::make_unique<unsigned char[]>(size);
1381                 if (!zero) {
1382                     synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "out of memory");
1383                     return;
1384                 }
1385                 memset(zero.get(), 0, size);
1386             }
1387             m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, zero.get());
1388             if (clippedWidth > 0 && clippedHeight > 0)
1389                 m_context->copyTexSubImage2D(target, level, xoffset + clippedX - x, yoffset + clippedY - y,
1390                                              clippedX, clippedY, clippedWidth, clippedHeight);
1391         } else
1392             m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
1393     }
1394 }
1395
1396 PassRefPtr<WebGLBuffer> WebGLRenderingContextBase::createBuffer()
1397 {
1398     if (isContextLostOrPending())
1399         return nullptr;
1400     RefPtr<WebGLBuffer> o = WebGLBuffer::create(this);
1401     addSharedObject(o.get());
1402     return o;
1403 }
1404
1405 PassRefPtr<WebGLFramebuffer> WebGLRenderingContextBase::createFramebuffer()
1406 {
1407     if (isContextLostOrPending())
1408         return nullptr;
1409     RefPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);
1410     addContextObject(o.get());
1411     return o;
1412 }
1413
1414 PassRefPtr<WebGLTexture> WebGLRenderingContextBase::createTexture()
1415 {
1416     if (isContextLostOrPending())
1417         return nullptr;
1418     RefPtr<WebGLTexture> o = WebGLTexture::create(this);
1419     addSharedObject(o.get());
1420     return o;
1421 }
1422
1423 PassRefPtr<WebGLProgram> WebGLRenderingContextBase::createProgram()
1424 {
1425     if (isContextLostOrPending())
1426         return nullptr;
1427     RefPtr<WebGLProgram> o = WebGLProgram::create(this);
1428     addSharedObject(o.get());
1429     return o;
1430 }
1431
1432 PassRefPtr<WebGLRenderbuffer> WebGLRenderingContextBase::createRenderbuffer()
1433 {
1434     if (isContextLostOrPending())
1435         return nullptr;
1436     RefPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);
1437     addSharedObject(o.get());
1438     return o;
1439 }
1440
1441 PassRefPtr<WebGLShader> WebGLRenderingContextBase::createShader(GC3Denum type, ExceptionCode&)
1442 {
1443     if (isContextLostOrPending())
1444         return nullptr;
1445     if (type != GraphicsContext3D::VERTEX_SHADER && type != GraphicsContext3D::FRAGMENT_SHADER) {
1446         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "createShader", "invalid shader type");
1447         return nullptr;
1448     }
1449
1450     RefPtr<WebGLShader> o = WebGLShader::create(this, type);
1451     addSharedObject(o.get());
1452     return o;
1453 }
1454
1455 void WebGLRenderingContextBase::cullFace(GC3Denum mode)
1456 {
1457     if (isContextLostOrPending())
1458         return;
1459     m_context->cullFace(mode);
1460 }
1461
1462 bool WebGLRenderingContextBase::deleteObject(WebGLObject* object)
1463 {
1464     if (isContextLostOrPending() || !object)
1465         return false;
1466     if (!object->validate(contextGroup(), this)) {
1467         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "delete", "object does not belong to this context");
1468         return false;
1469     }
1470     if (object->object())
1471         // We need to pass in context here because we want
1472         // things in this context unbound.
1473         object->deleteObject(graphicsContext3D());
1474     return true;
1475 }
1476
1477 void WebGLRenderingContextBase::deleteBuffer(WebGLBuffer* buffer)
1478 {
1479     if (!deleteObject(buffer))
1480         return;
1481     if (m_boundArrayBuffer == buffer)
1482         m_boundArrayBuffer = nullptr;
1483
1484     m_boundVertexArrayObject->unbindBuffer(buffer);
1485 }
1486
1487 void WebGLRenderingContextBase::deleteFramebuffer(WebGLFramebuffer* framebuffer)
1488 {
1489     if (!deleteObject(framebuffer))
1490         return;
1491     if (framebuffer == m_framebufferBinding) {
1492         m_framebufferBinding = nullptr;
1493         m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);
1494     }
1495 }
1496
1497 void WebGLRenderingContextBase::deleteProgram(WebGLProgram* program)
1498 {
1499     deleteObject(program);
1500     // We don't reset m_currentProgram to 0 here because the deletion of the
1501     // current program is delayed.
1502 }
1503
1504 void WebGLRenderingContextBase::deleteRenderbuffer(WebGLRenderbuffer* renderbuffer)
1505 {
1506     if (!deleteObject(renderbuffer))
1507         return;
1508     if (renderbuffer == m_renderbufferBinding)
1509         m_renderbufferBinding = nullptr;
1510     if (m_framebufferBinding)
1511         m_framebufferBinding->removeAttachmentFromBoundFramebuffer(renderbuffer);
1512 }
1513
1514 void WebGLRenderingContextBase::deleteShader(WebGLShader* shader)
1515 {
1516     deleteObject(shader);
1517 }
1518
1519 void WebGLRenderingContextBase::deleteTexture(WebGLTexture* texture)
1520 {
1521     if (!deleteObject(texture))
1522         return;
1523
1524     unsigned current = 0;
1525     for (auto& textureUnit : m_textureUnits) {
1526         if (texture == textureUnit.texture2DBinding) {
1527             textureUnit.texture2DBinding = nullptr;
1528             m_unrenderableTextureUnits.remove(current);
1529         }
1530         if (texture == textureUnit.textureCubeMapBinding) {
1531             textureUnit.textureCubeMapBinding = nullptr;
1532             m_unrenderableTextureUnits.remove(current);
1533         }
1534         ++current;
1535     }
1536     if (m_framebufferBinding)
1537         m_framebufferBinding->removeAttachmentFromBoundFramebuffer(texture);
1538 }
1539
1540 void WebGLRenderingContextBase::depthFunc(GC3Denum func)
1541 {
1542     if (isContextLostOrPending())
1543         return;
1544     m_context->depthFunc(func);
1545 }
1546
1547 void WebGLRenderingContextBase::depthMask(GC3Dboolean flag)
1548 {
1549     if (isContextLostOrPending())
1550         return;
1551     m_depthMask = flag;
1552     m_context->depthMask(flag);
1553 }
1554
1555 void WebGLRenderingContextBase::depthRange(GC3Dfloat zNear, GC3Dfloat zFar)
1556 {
1557     if (isContextLostOrPending())
1558         return;
1559     if (zNear > zFar) {
1560         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "depthRange", "zNear > zFar");
1561         return;
1562     }
1563     m_context->depthRange(zNear, zFar);
1564 }
1565
1566 void WebGLRenderingContextBase::detachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode&)
1567 {
1568     if (isContextLostOrPending() || !validateWebGLObject("detachShader", program) || !validateWebGLObject("detachShader", shader))
1569         return;
1570     if (!program->detachShader(shader)) {
1571         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "detachShader", "shader not attached");
1572         return;
1573     }
1574     m_context->detachShader(objectOrZero(program), objectOrZero(shader));
1575     shader->onDetached(graphicsContext3D());
1576 }
1577
1578 void WebGLRenderingContextBase::disable(GC3Denum cap)
1579 {
1580     if (isContextLostOrPending() || !validateCapability("disable", cap))
1581         return;
1582     if (cap == GraphicsContext3D::STENCIL_TEST) {
1583         m_stencilEnabled = false;
1584         applyStencilTest();
1585         return;
1586     }
1587     if (cap == GraphicsContext3D::SCISSOR_TEST)
1588         m_scissorEnabled = false;
1589     m_context->disable(cap);
1590 }
1591
1592 void WebGLRenderingContextBase::disableVertexAttribArray(GC3Duint index, ExceptionCode&)
1593 {
1594     if (isContextLostOrPending())
1595         return;
1596     if (index >= m_maxVertexAttribs) {
1597         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "disableVertexAttribArray", "index out of range");
1598         return;
1599     }
1600
1601     WebGLVertexArrayObjectBase::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);
1602     state.enabled = false;
1603
1604     if (index > 0 || isGLES2Compliant())
1605         m_context->disableVertexAttribArray(index);
1606 }
1607
1608 bool WebGLRenderingContextBase::validateNPOTTextureLevel(GC3Dsizei width, GC3Dsizei height, GC3Dint level, const char* functionName)
1609 {
1610     if (!isGLES2NPOTStrict() && level && WebGLTexture::isNPOT(width, height)) {
1611         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level > 0 not power of 2");
1612         return false;
1613     }
1614
1615     return true;
1616 }
1617
1618 bool WebGLRenderingContextBase::validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset)
1619 {
1620     RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();
1621     
1622     if (!elementArrayBuffer)
1623         return false;
1624
1625     if (offset < 0)
1626         return false;
1627
1628     if (type == GraphicsContext3D::UNSIGNED_INT) {
1629         // For an unsigned int array, offset must be divisible by 4 for alignment reasons.
1630         if (offset % 4)
1631             return false;
1632
1633         // Make uoffset an element offset.
1634         offset /= 4;
1635
1636         GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 4;
1637         if (offset > n || count > n - offset)
1638             return false;
1639     } else if (type == GraphicsContext3D::UNSIGNED_SHORT) {
1640         // For an unsigned short array, offset must be divisible by 2 for alignment reasons.
1641         if (offset % 2)
1642             return false;
1643
1644         // Make uoffset an element offset.
1645         offset /= 2;
1646
1647         GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 2;
1648         if (offset > n || count > n - offset)
1649             return false;
1650     } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {
1651         GC3Dsizeiptr n = elementArrayBuffer->byteLength();
1652         if (offset > n || count > n - offset)
1653             return false;
1654     }
1655     return true;
1656 }
1657
1658 bool WebGLRenderingContextBase::validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired)
1659 {
1660     ASSERT(count >= 0 && offset >= 0);
1661     unsigned lastIndex = 0;
1662     
1663     RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();
1664
1665     if (!elementArrayBuffer)
1666         return false;
1667
1668     if (!count) {
1669         numElementsRequired = 0;
1670         return true;
1671     }
1672
1673     if (!elementArrayBuffer->elementArrayBuffer())
1674         return false;
1675
1676     unsigned long uoffset = offset;
1677     unsigned long n = count;
1678
1679     if (type == GraphicsContext3D::UNSIGNED_INT) {
1680         // Make uoffset an element offset.
1681         uoffset /= sizeof(GC3Duint);
1682         const GC3Duint* p = static_cast<const GC3Duint*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;
1683         while (n-- > 0) {
1684             if (*p > lastIndex)
1685                 lastIndex = *p;
1686             ++p;
1687         }
1688     } else if (type == GraphicsContext3D::UNSIGNED_SHORT) {
1689         // Make uoffset an element offset.
1690         uoffset /= sizeof(GC3Dushort);
1691         const GC3Dushort* p = static_cast<const GC3Dushort*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;
1692         while (n-- > 0) {
1693             if (*p > lastIndex)
1694                 lastIndex = *p;
1695             ++p;
1696         }
1697     } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {
1698         const GC3Dubyte* p = static_cast<const GC3Dubyte*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;
1699         while (n-- > 0) {
1700             if (*p > lastIndex)
1701                 lastIndex = *p;
1702             ++p;
1703         }
1704     }
1705
1706     // Then set the last index in the index array and make sure it is valid.
1707     numElementsRequired = lastIndex + 1;
1708     return numElementsRequired > 0;
1709 }
1710
1711 bool WebGLRenderingContextBase::validateVertexAttributes(unsigned elementCount, unsigned primitiveCount)
1712 {
1713     if (!m_currentProgram)
1714         return false;
1715
1716     // Look in each enabled vertex attrib and check if they've been bound to a buffer.
1717     for (unsigned i = 0; i < m_maxVertexAttribs; ++i) {
1718         if (!m_boundVertexArrayObject->getVertexAttribState(i).validateBinding())
1719             return false;
1720     }
1721
1722     if (elementCount <= 0)
1723         return true;
1724
1725     // Look in each consumed vertex attrib (by the current program).
1726     bool sawNonInstancedAttrib = false;
1727     bool sawEnabledAttrib = false;
1728     int numActiveAttribLocations = m_currentProgram->numActiveAttribLocations();
1729     for (int i = 0; i < numActiveAttribLocations; ++i) {
1730         int loc = m_currentProgram->getActiveAttribLocation(i);
1731         if (loc >= 0 && loc < static_cast<int>(m_maxVertexAttribs)) {
1732             const WebGLVertexArrayObjectBase::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(loc);
1733             if (state.enabled) {
1734                 sawEnabledAttrib = true;
1735                 // Avoid off-by-one errors in numElements computation.
1736                 // For the last element, we will only touch the data for the
1737                 // element and nothing beyond it.
1738                 int bytesRemaining = static_cast<int>(state.bufferBinding->byteLength() - state.offset);
1739                 unsigned numElements = 0;
1740                 ASSERT(state.stride > 0);
1741                 if (bytesRemaining >= state.bytesPerElement)
1742                     numElements = 1 + (bytesRemaining - state.bytesPerElement) / state.stride;
1743                 unsigned instancesRequired = 0;
1744                 if (state.divisor) {
1745                     instancesRequired = ceil(static_cast<float>(primitiveCount) / state.divisor);
1746                     if (instancesRequired > numElements)
1747                         return false;
1748                 } else {
1749                     sawNonInstancedAttrib = true;
1750                     if (elementCount > numElements)
1751                         return false;
1752                 }
1753             }
1754         }
1755     }
1756
1757     if (!sawNonInstancedAttrib && sawEnabledAttrib)
1758         return false;
1759
1760     // Guard against access into non-existent buffers.
1761     if (elementCount && !sawEnabledAttrib && !m_currentProgram->isUsingVertexAttrib0())
1762         return false;
1763
1764     return true;
1765 }
1766
1767 bool WebGLRenderingContextBase::validateWebGLObject(const char* functionName, WebGLObject* object)
1768 {
1769     if (!object || !object->object()) {
1770         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no object or object deleted");
1771         return false;
1772     }
1773     if (!object->validate(contextGroup(), this)) {
1774         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "object does not belong to this context");
1775         return false;
1776     }
1777     return true;
1778 }
1779
1780 bool WebGLRenderingContextBase::validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primitiveCount)
1781 {
1782     if (isContextLostOrPending() || !validateDrawMode(functionName, mode))
1783         return false;
1784
1785     if (!validateStencilSettings(functionName))
1786         return false;
1787
1788     if (first < 0 || count < 0) {
1789         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "first or count < 0");
1790         return false;
1791     }
1792
1793     if (!count) {
1794         markContextChanged();
1795         return false;
1796     }
1797
1798     if (primitiveCount < 0) {
1799         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "primcount < 0");
1800         return false;
1801     }
1802
1803     if (!isErrorGeneratedOnOutOfBoundsAccesses()) {
1804         // Ensure we have a valid rendering state
1805         Checked<GC3Dint, RecordOverflow> checkedFirst(first);
1806         Checked<GC3Dint, RecordOverflow> checkedCount(count);
1807         Checked<GC3Dint, RecordOverflow> checkedSum = checkedFirst + checkedCount;
1808         Checked<GC3Dint, RecordOverflow> checkedPrimitiveCount(primitiveCount);
1809         if (checkedSum.hasOverflowed() || checkedPrimitiveCount.hasOverflowed() || !validateVertexAttributes(checkedSum.unsafeGet(), checkedPrimitiveCount.unsafeGet())) {
1810             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");
1811             return false;
1812         }
1813         if (!validateSimulatedVertexAttrib0(checkedSum.unsafeGet() - 1)) {
1814             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access outside the bounds of the simulated vertexAttrib0 array");
1815             return false;
1816         }
1817     } else {
1818         if (!validateVertexAttributes(0)) {
1819             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attribs not setup correctly");
1820             return false;
1821         }
1822     }
1823
1824     const char* reason = "framebuffer incomplete";
1825     if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {
1826         synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, functionName, reason);
1827         return false;
1828     }
1829
1830     return true;
1831 }
1832
1833 bool WebGLRenderingContextBase::validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements, GC3Dsizei primitiveCount)
1834 {
1835     if (isContextLostOrPending() || !validateDrawMode(functionName, mode))
1836         return false;
1837     
1838     if (!validateStencilSettings(functionName))
1839         return false;
1840     
1841     switch (type) {
1842     case GraphicsContext3D::UNSIGNED_BYTE:
1843     case GraphicsContext3D::UNSIGNED_SHORT:
1844         break;
1845     case GraphicsContext3D::UNSIGNED_INT:
1846         if (m_oesElementIndexUint || isWebGL2())
1847             break;
1848         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid type");
1849         return false;
1850     default:
1851         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid type");
1852         return false;
1853     }
1854     
1855     if (count < 0 || offset < 0) {
1856         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "count or offset < 0");
1857         return false;
1858     }
1859     
1860     if (!count) {
1861         markContextChanged();
1862         return false;
1863     }
1864     
1865     if (primitiveCount < 0) {
1866         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "primcount < 0");
1867         return false;
1868     }
1869     
1870     if (!m_boundVertexArrayObject->getElementArrayBuffer()) {
1871         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no ELEMENT_ARRAY_BUFFER bound");
1872         return false;
1873     }
1874     
1875     if (!isErrorGeneratedOnOutOfBoundsAccesses()) {
1876         // Ensure we have a valid rendering state
1877         if (!validateElementArraySize(count, type, static_cast<GC3Dintptr>(offset))) {
1878             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "request out of bounds for current ELEMENT_ARRAY_BUFFER");
1879             return false;
1880         }
1881         if (!count)
1882             return false;
1883         
1884         Checked<GC3Dint, RecordOverflow> checkedCount(count);
1885         Checked<GC3Dint, RecordOverflow> checkedPrimitiveCount(primitiveCount);
1886         if (checkedCount.hasOverflowed() || checkedPrimitiveCount.hasOverflowed()) {
1887             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");
1888             return false;
1889         }
1890         
1891         if (!validateIndexArrayConservative(type, numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {
1892             if (!validateIndexArrayPrecise(checkedCount.unsafeGet(), type, static_cast<GC3Dintptr>(offset), numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {
1893                 synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");
1894                 return false;
1895             }
1896         }
1897
1898         if (!validateSimulatedVertexAttrib0(numElements)) {
1899             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access outside the bounds of the simulated vertexAttrib0 array");
1900             return false;
1901         }
1902
1903     } else {
1904         if (!validateVertexAttributes(0)) {
1905             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attribs not setup correctly");
1906             return false;
1907         }
1908     }
1909     
1910     const char* reason = "framebuffer incomplete";
1911     if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {
1912         synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, functionName, reason);
1913         return false;
1914     }
1915     
1916     return true;
1917 }
1918
1919 void WebGLRenderingContextBase::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode&)
1920 {
1921     if (!validateDrawArrays("drawArrays", mode, first, count, 0))
1922         return;
1923
1924     clearIfComposited();
1925
1926     bool vertexAttrib0Simulated = false;
1927     if (!isGLES2Compliant())
1928         vertexAttrib0Simulated = simulateVertexAttrib0(first + count - 1);
1929     bool usesFallbackTexture = false;
1930     if (!isGLES2NPOTStrict())
1931         usesFallbackTexture = checkTextureCompleteness("drawArrays", true);
1932
1933     m_context->drawArrays(mode, first, count);
1934
1935     if (!isGLES2Compliant() && vertexAttrib0Simulated)
1936         restoreStatesAfterVertexAttrib0Simulation();
1937     if (usesFallbackTexture)
1938         checkTextureCompleteness("drawArrays", false);
1939     markContextChanged();
1940 }
1941
1942 void WebGLRenderingContextBase::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode&)
1943 {
1944     unsigned numElements = 0;
1945     if (!validateDrawElements("drawElements", mode, count, type, offset, numElements, 0))
1946         return;
1947
1948     clearIfComposited();
1949
1950     bool vertexAttrib0Simulated = false;
1951     if (!isGLES2Compliant()) {
1952         if (!numElements)
1953             validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);
1954         vertexAttrib0Simulated = simulateVertexAttrib0(numElements);
1955     }
1956
1957     bool usesFallbackTexture = false;
1958     if (!isGLES2NPOTStrict())
1959         usesFallbackTexture = checkTextureCompleteness("drawElements", true);
1960
1961     m_context->drawElements(mode, count, type, static_cast<GC3Dintptr>(offset));
1962
1963     if (!isGLES2Compliant() && vertexAttrib0Simulated)
1964         restoreStatesAfterVertexAttrib0Simulation();
1965     if (usesFallbackTexture)
1966         checkTextureCompleteness("drawElements", false);
1967     markContextChanged();
1968 }
1969
1970 void WebGLRenderingContextBase::enable(GC3Denum cap)
1971 {
1972     if (isContextLostOrPending() || !validateCapability("enable", cap))
1973         return;
1974     if (cap == GraphicsContext3D::STENCIL_TEST) {
1975         m_stencilEnabled = true;
1976         applyStencilTest();
1977         return;
1978     }
1979     if (cap == GraphicsContext3D::SCISSOR_TEST)
1980         m_scissorEnabled = true;
1981     m_context->enable(cap);
1982 }
1983
1984 void WebGLRenderingContextBase::enableVertexAttribArray(GC3Duint index, ExceptionCode&)
1985 {
1986     if (isContextLostOrPending())
1987         return;
1988     if (index >= m_maxVertexAttribs) {
1989         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "enableVertexAttribArray", "index out of range");
1990         return;
1991     }
1992
1993     WebGLVertexArrayObjectBase::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);
1994     state.enabled = true;
1995
1996     m_context->enableVertexAttribArray(index);
1997 }
1998
1999 void WebGLRenderingContextBase::finish()
2000 {
2001     if (isContextLostOrPending())
2002         return;
2003     m_context->finish();
2004 }
2005
2006 void WebGLRenderingContextBase::flush()
2007 {
2008     if (isContextLostOrPending())
2009         return;
2010     m_context->flush();
2011 }
2012
2013 void WebGLRenderingContextBase::framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer* buffer, ExceptionCode&)
2014 {
2015     if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferRenderbuffer", target, attachment))
2016         return;
2017     if (renderbuffertarget != GraphicsContext3D::RENDERBUFFER) {
2018         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "framebufferRenderbuffer", "invalid target");
2019         return;
2020     }
2021     if (buffer && !buffer->validate(contextGroup(), this)) {
2022         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferRenderbuffer", "no buffer or buffer not from this context");
2023         return;
2024     }
2025     // Don't allow the default framebuffer to be mutated; all current
2026     // implementations use an FBO internally in place of the default
2027     // FBO.
2028     if (!m_framebufferBinding || !m_framebufferBinding->object()) {
2029         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferRenderbuffer", "no framebuffer bound");
2030         return;
2031     }
2032     Platform3DObject bufferObject = objectOrZero(buffer);
2033     switch (attachment) {
2034     case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:
2035         m_context->framebufferRenderbuffer(target, GraphicsContext3D::DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);
2036         m_context->framebufferRenderbuffer(target, GraphicsContext3D::STENCIL_ATTACHMENT, renderbuffertarget, bufferObject);
2037         break;
2038     default:
2039         m_context->framebufferRenderbuffer(target, attachment, renderbuffertarget, bufferObject);
2040     }
2041     m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, buffer);
2042     applyStencilTest();
2043 }
2044
2045 void WebGLRenderingContextBase::framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture* texture, GC3Dint level, ExceptionCode&)
2046 {
2047     if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferTexture2D", target, attachment))
2048         return;
2049     if (level) {
2050         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "framebufferTexture2D", "level not 0");
2051         return;
2052     }
2053     if (texture && !texture->validate(contextGroup(), this)) {
2054         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferTexture2D", "no texture or texture not from this context");
2055         return;
2056     }
2057     // Don't allow the default framebuffer to be mutated; all current
2058     // implementations use an FBO internally in place of the default
2059     // FBO.
2060     if (!m_framebufferBinding || !m_framebufferBinding->object()) {
2061         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferTexture2D", "no framebuffer bound");
2062         return;
2063     }
2064     Platform3DObject textureObject = objectOrZero(texture);
2065     switch (attachment) {
2066     case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:
2067         m_context->framebufferTexture2D(target, GraphicsContext3D::DEPTH_ATTACHMENT, textarget, textureObject, level);
2068         m_context->framebufferTexture2D(target, GraphicsContext3D::STENCIL_ATTACHMENT, textarget, textureObject, level);
2069         break;
2070     case GraphicsContext3D::DEPTH_ATTACHMENT:
2071         m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);
2072         break;
2073     case GraphicsContext3D::STENCIL_ATTACHMENT:
2074         m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);
2075         break;
2076     default:
2077         m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);
2078     }
2079     m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, textarget, texture, level);
2080     applyStencilTest();
2081 }
2082
2083 void WebGLRenderingContextBase::frontFace(GC3Denum mode)
2084 {
2085     if (isContextLostOrPending())
2086         return;
2087     m_context->frontFace(mode);
2088 }
2089
2090 void WebGLRenderingContextBase::generateMipmap(GC3Denum target)
2091 {
2092     if (isContextLostOrPending())
2093         return;
2094     WebGLTexture* tex = validateTextureBinding("generateMipmap", target, false);
2095     if (!tex)
2096         return;
2097     if (!tex->canGenerateMipmaps()) {
2098         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "generateMipmap", "level 0 not power of 2 or not all the same size");
2099         return;
2100     }
2101     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=123916. Compressed textures should be allowed in WebGL 2:
2102     if (tex->isCompressed()) {
2103         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "generateMipmap", "trying to generate mipmaps from compressed texture");
2104         return;
2105     }
2106     if (!validateSettableTexFormat("generateMipmap", tex->getInternalFormat(target, 0)))
2107         return;
2108
2109     // generateMipmap won't work properly if minFilter is not NEAREST_MIPMAP_LINEAR
2110     // on Mac.  Remove the hack once this driver bug is fixed.
2111 #if OS(DARWIN)
2112     bool needToResetMinFilter = false;
2113     if (tex->getMinFilter() != GraphicsContext3D::NEAREST_MIPMAP_LINEAR) {
2114         m_context->texParameteri(target, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::NEAREST_MIPMAP_LINEAR);
2115         needToResetMinFilter = true;
2116     }
2117 #endif
2118     m_context->generateMipmap(target);
2119 #if OS(DARWIN)
2120     if (needToResetMinFilter)
2121         m_context->texParameteri(target, GraphicsContext3D::TEXTURE_MIN_FILTER, tex->getMinFilter());
2122 #endif
2123     tex->generateMipmapLevelInfo();
2124 }
2125
2126 PassRefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GC3Duint index, ExceptionCode&)
2127 {
2128     if (isContextLostOrPending() || !validateWebGLObject("getActiveAttrib", program))
2129         return nullptr;
2130     ActiveInfo info;
2131     if (!m_context->getActiveAttrib(objectOrZero(program), index, info))
2132         return nullptr;
2133
2134     LOG(WebGL, "Returning active attribute %d: %s", index, info.name.utf8().data());
2135
2136     return WebGLActiveInfo::create(info.name, info.type, info.size);
2137 }
2138
2139 PassRefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GC3Duint index, ExceptionCode&)
2140 {
2141     if (isContextLostOrPending() || !validateWebGLObject("getActiveUniform", program))
2142         return 0;
2143     ActiveInfo info;
2144     if (!m_context->getActiveUniform(objectOrZero(program), index, info))
2145         return nullptr;
2146     if (!isGLES2Compliant())
2147         if (info.size > 1 && !info.name.endsWith("[0]"))
2148             info.name.append("[0]");
2149
2150     LOG(WebGL, "Returning active uniform %d: %s", index, info.name.utf8().data());
2151
2152     return WebGLActiveInfo::create(info.name, info.type, info.size);
2153 }
2154
2155 bool WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program, Vector<RefPtr<WebGLShader>>& shaderObjects, ExceptionCode&)
2156 {
2157     shaderObjects.clear();
2158     if (isContextLostOrPending() || !validateWebGLObject("getAttachedShaders", program))
2159         return false;
2160
2161     const GC3Denum shaderType[] = {
2162         GraphicsContext3D::VERTEX_SHADER,
2163         GraphicsContext3D::FRAGMENT_SHADER
2164     };
2165     for (unsigned i = 0; i < sizeof(shaderType) / sizeof(GC3Denum); ++i) {
2166         WebGLShader* shader = program->getAttachedShader(shaderType[i]);
2167         if (shader)
2168             shaderObjects.append(shader);
2169     }
2170     return true;
2171 }
2172
2173 GC3Dint WebGLRenderingContextBase::getAttribLocation(WebGLProgram* program, const String& name)
2174 {
2175     if (isContextLostOrPending() || !validateWebGLObject("getAttribLocation", program))
2176         return -1;
2177     if (!validateLocationLength("getAttribLocation", name))
2178         return -1;
2179     if (!validateString("getAttribLocation", name))
2180         return -1;
2181     if (isPrefixReserved(name))
2182         return -1;
2183     if (!program->getLinkStatus()) {
2184         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getAttribLocation", "program not linked");
2185         return -1;
2186     }
2187     return m_context->getAttribLocation(objectOrZero(program), name);
2188 }
2189
2190 WebGLGetInfo WebGLRenderingContextBase::getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&)
2191 {
2192     if (isContextLostOrPending())
2193         return WebGLGetInfo();
2194     if (target != GraphicsContext3D::ARRAY_BUFFER && target != GraphicsContext3D::ELEMENT_ARRAY_BUFFER) {
2195         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid target");
2196         return WebGLGetInfo();
2197     }
2198
2199     if (pname != GraphicsContext3D::BUFFER_SIZE && pname != GraphicsContext3D::BUFFER_USAGE) {
2200         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid parameter name");
2201         return WebGLGetInfo();
2202     }
2203
2204     GC3Dint value = 0;
2205     m_context->getBufferParameteriv(target, pname, &value);
2206     if (pname == GraphicsContext3D::BUFFER_SIZE)
2207         return WebGLGetInfo(value);
2208     return WebGLGetInfo(static_cast<unsigned int>(value));
2209 }
2210
2211 PassRefPtr<WebGLContextAttributes> WebGLRenderingContextBase::getContextAttributes()
2212 {
2213     if (isContextLostOrPending())
2214         return nullptr;
2215     // We always need to return a new WebGLContextAttributes object to
2216     // prevent the user from mutating any cached version.
2217
2218     // Also, we need to enforce requested values of "false" for depth
2219     // and stencil, regardless of the properties of the underlying
2220     // GraphicsContext3D.
2221     RefPtr<WebGLContextAttributes> attributes = WebGLContextAttributes::create(m_context->getContextAttributes());
2222     if (!m_attributes.depth)
2223         attributes->setDepth(false);
2224     if (!m_attributes.stencil)
2225         attributes->setStencil(false);
2226     return attributes.release();
2227 }
2228
2229 GC3Denum WebGLRenderingContextBase::getError()
2230 {
2231     if (m_isPendingPolicyResolution)
2232         return GraphicsContext3D::NO_ERROR;
2233     return m_context->getError();
2234 }
2235
2236 WebGLGetInfo WebGLRenderingContextBase::getProgramParameter(WebGLProgram* program, GC3Denum pname, ExceptionCode&)
2237 {
2238     if (isContextLostOrPending() || !validateWebGLObject("getProgramParameter", program))
2239         return WebGLGetInfo();
2240
2241     GC3Dint value = 0;
2242     switch (pname) {
2243     case GraphicsContext3D::DELETE_STATUS:
2244         return WebGLGetInfo(program->isDeleted());
2245     case GraphicsContext3D::VALIDATE_STATUS:
2246         m_context->getProgramiv(objectOrZero(program), pname, &value);
2247         return WebGLGetInfo(static_cast<bool>(value));
2248     case GraphicsContext3D::LINK_STATUS:
2249         return WebGLGetInfo(program->getLinkStatus());
2250     case GraphicsContext3D::ATTACHED_SHADERS:
2251         m_context->getProgramiv(objectOrZero(program), pname, &value);
2252         return WebGLGetInfo(value);
2253     case GraphicsContext3D::ACTIVE_ATTRIBUTES:
2254     case GraphicsContext3D::ACTIVE_UNIFORMS:
2255         m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), pname, &value);
2256         return WebGLGetInfo(value);
2257     default:
2258         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getProgramParameter", "invalid parameter name");
2259         return WebGLGetInfo();
2260     }
2261 }
2262
2263 String WebGLRenderingContextBase::getProgramInfoLog(WebGLProgram* program, ExceptionCode&)
2264 {
2265     if (isContextLostOrPending() || !validateWebGLObject("getProgramInfoLog", program))
2266         return String();
2267     return ensureNotNull(m_context->getProgramInfoLog(objectOrZero(program)));
2268 }
2269
2270 WebGLGetInfo WebGLRenderingContextBase::getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&)
2271 {
2272     if (isContextLostOrPending())
2273         return WebGLGetInfo();
2274     if (target != GraphicsContext3D::RENDERBUFFER) {
2275         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid target");
2276         return WebGLGetInfo();
2277     }
2278     if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {
2279         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getRenderbufferParameter", "no renderbuffer bound");
2280         return WebGLGetInfo();
2281     }
2282
2283     if (m_renderbufferBinding->getInternalFormat() == GraphicsContext3D::DEPTH_STENCIL
2284         && !m_renderbufferBinding->isValid()) {
2285         ASSERT(!isDepthStencilSupported());
2286         int value = 0;
2287         switch (pname) {
2288         case GraphicsContext3D::RENDERBUFFER_WIDTH:
2289             value = m_renderbufferBinding->getWidth();
2290             break;
2291         case GraphicsContext3D::RENDERBUFFER_HEIGHT:
2292             value = m_renderbufferBinding->getHeight();
2293             break;
2294         case GraphicsContext3D::RENDERBUFFER_RED_SIZE:
2295         case GraphicsContext3D::RENDERBUFFER_GREEN_SIZE:
2296         case GraphicsContext3D::RENDERBUFFER_BLUE_SIZE:
2297         case GraphicsContext3D::RENDERBUFFER_ALPHA_SIZE:
2298             value = 0;
2299             break;
2300         case GraphicsContext3D::RENDERBUFFER_DEPTH_SIZE:
2301             value = 24;
2302             break;
2303         case GraphicsContext3D::RENDERBUFFER_STENCIL_SIZE:
2304             value = 8;
2305             break;
2306         case GraphicsContext3D::RENDERBUFFER_INTERNAL_FORMAT:
2307             return WebGLGetInfo(m_renderbufferBinding->getInternalFormat());
2308         default:
2309             synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");
2310             return WebGLGetInfo();
2311         }
2312         return WebGLGetInfo(value);
2313     }
2314
2315     GC3Dint value = 0;
2316     switch (pname) {
2317     case GraphicsContext3D::RENDERBUFFER_WIDTH:
2318     case GraphicsContext3D::RENDERBUFFER_HEIGHT:
2319     case GraphicsContext3D::RENDERBUFFER_RED_SIZE:
2320     case GraphicsContext3D::RENDERBUFFER_GREEN_SIZE:
2321     case GraphicsContext3D::RENDERBUFFER_BLUE_SIZE:
2322     case GraphicsContext3D::RENDERBUFFER_ALPHA_SIZE:
2323     case GraphicsContext3D::RENDERBUFFER_DEPTH_SIZE:
2324     case GraphicsContext3D::RENDERBUFFER_STENCIL_SIZE:
2325         m_context->getRenderbufferParameteriv(target, pname, &value);
2326         return WebGLGetInfo(value);
2327     case GraphicsContext3D::RENDERBUFFER_INTERNAL_FORMAT:
2328         return WebGLGetInfo(m_renderbufferBinding->getInternalFormat());
2329     default:
2330         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");
2331         return WebGLGetInfo();
2332     }
2333 }
2334
2335 WebGLGetInfo WebGLRenderingContextBase::getShaderParameter(WebGLShader* shader, GC3Denum pname, ExceptionCode&)
2336 {
2337     if (isContextLostOrPending() || !validateWebGLObject("getShaderParameter", shader))
2338         return WebGLGetInfo();
2339     GC3Dint value = 0;
2340     switch (pname) {
2341     case GraphicsContext3D::DELETE_STATUS:
2342         return WebGLGetInfo(shader->isDeleted());
2343     case GraphicsContext3D::COMPILE_STATUS:
2344         m_context->getShaderiv(objectOrZero(shader), pname, &value);
2345         return WebGLGetInfo(static_cast<bool>(value));
2346     case GraphicsContext3D::SHADER_TYPE:
2347         m_context->getShaderiv(objectOrZero(shader), pname, &value);
2348         return WebGLGetInfo(static_cast<unsigned int>(value));
2349     default:
2350         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderParameter", "invalid parameter name");
2351         return WebGLGetInfo();
2352     }
2353 }
2354
2355 String WebGLRenderingContextBase::getShaderInfoLog(WebGLShader* shader, ExceptionCode&)
2356 {
2357     if (isContextLostOrPending() || !validateWebGLObject("getShaderInfoLog", shader))
2358         return String();
2359     return ensureNotNull(m_context->getShaderInfoLog(objectOrZero(shader)));
2360 }
2361
2362 PassRefPtr<WebGLShaderPrecisionFormat> WebGLRenderingContextBase::getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode&)
2363 {
2364     if (isContextLostOrPending())
2365         return nullptr;
2366     switch (shaderType) {
2367     case GraphicsContext3D::VERTEX_SHADER:
2368     case GraphicsContext3D::FRAGMENT_SHADER:
2369         break;
2370     default:
2371         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderPrecisionFormat", "invalid shader type");
2372         return nullptr;
2373     }
2374     switch (precisionType) {
2375     case GraphicsContext3D::LOW_FLOAT:
2376     case GraphicsContext3D::MEDIUM_FLOAT:
2377     case GraphicsContext3D::HIGH_FLOAT:
2378     case GraphicsContext3D::LOW_INT:
2379     case GraphicsContext3D::MEDIUM_INT:
2380     case GraphicsContext3D::HIGH_INT:
2381         break;
2382     default:
2383         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderPrecisionFormat", "invalid precision type");
2384         return nullptr;
2385     }
2386
2387     GC3Dint range[2] = {0, 0};
2388     GC3Dint precision = 0;
2389     m_context->getShaderPrecisionFormat(shaderType, precisionType, range, &precision);
2390     return WebGLShaderPrecisionFormat::create(range[0], range[1], precision);
2391 }
2392
2393 String WebGLRenderingContextBase::getShaderSource(WebGLShader* shader, ExceptionCode&)
2394 {
2395     if (isContextLostOrPending() || !validateWebGLObject("getShaderSource", shader))
2396         return String();
2397     return ensureNotNull(shader->getSource());
2398 }
2399
2400 WebGLGetInfo WebGLRenderingContextBase::getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode&)
2401 {
2402     if (isContextLostOrPending())
2403         return WebGLGetInfo();
2404     WebGLTexture* tex = validateTextureBinding("getTexParameter", target, false);
2405     if (!tex)
2406         return WebGLGetInfo();
2407     GC3Dint value = 0;
2408     switch (pname) {
2409     case GraphicsContext3D::TEXTURE_MAG_FILTER:
2410     case GraphicsContext3D::TEXTURE_MIN_FILTER:
2411     case GraphicsContext3D::TEXTURE_WRAP_S:
2412     case GraphicsContext3D::TEXTURE_WRAP_T:
2413         m_context->getTexParameteriv(target, pname, &value);
2414         return WebGLGetInfo(static_cast<unsigned int>(value));
2415     case Extensions3D::TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic
2416         if (m_extTextureFilterAnisotropic) {
2417             m_context->getTexParameteriv(target, pname, &value);
2418             return WebGLGetInfo(static_cast<unsigned int>(value));
2419         }
2420         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getTexParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");
2421         return WebGLGetInfo();
2422     default:
2423         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getTexParameter", "invalid parameter name");
2424         return WebGLGetInfo();
2425     }
2426 }
2427
2428 WebGLGetInfo WebGLRenderingContextBase::getUniform(WebGLProgram* program, const WebGLUniformLocation* uniformLocation, ExceptionCode&)
2429 {
2430     if (isContextLostOrPending() || !validateWebGLObject("getUniform", program))
2431         return WebGLGetInfo();
2432     if (!uniformLocation || uniformLocation->program() != program) {
2433         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getUniform", "no uniformlocation or not valid for this program");
2434         return WebGLGetInfo();
2435     }
2436     GC3Dint location = uniformLocation->location();
2437
2438     GC3Denum baseType;
2439     unsigned length;
2440     switch (uniformLocation->type()) {
2441     case GraphicsContext3D::BOOL:
2442         baseType = GraphicsContext3D::BOOL;
2443         length = 1;
2444         break;
2445     case GraphicsContext3D::BOOL_VEC2:
2446         baseType = GraphicsContext3D::BOOL;
2447         length = 2;
2448         break;
2449     case GraphicsContext3D::BOOL_VEC3:
2450         baseType = GraphicsContext3D::BOOL;
2451         length = 3;
2452         break;
2453     case GraphicsContext3D::BOOL_VEC4:
2454         baseType = GraphicsContext3D::BOOL;
2455         length = 4;
2456         break;
2457     case GraphicsContext3D::INT:
2458         baseType = GraphicsContext3D::INT;
2459         length = 1;
2460         break;
2461     case GraphicsContext3D::INT_VEC2:
2462         baseType = GraphicsContext3D::INT;
2463         length = 2;
2464         break;
2465     case GraphicsContext3D::INT_VEC3:
2466         baseType = GraphicsContext3D::INT;
2467         length = 3;
2468         break;
2469     case GraphicsContext3D::INT_VEC4:
2470         baseType = GraphicsContext3D::INT;
2471         length = 4;
2472         break;
2473     case GraphicsContext3D::FLOAT:
2474         baseType = GraphicsContext3D::FLOAT;
2475         length = 1;
2476         break;
2477     case GraphicsContext3D::FLOAT_VEC2:
2478         baseType = GraphicsContext3D::FLOAT;
2479         length = 2;
2480         break;
2481     case GraphicsContext3D::FLOAT_VEC3:
2482         baseType = GraphicsContext3D::FLOAT;
2483         length = 3;
2484         break;
2485     case GraphicsContext3D::FLOAT_VEC4:
2486         baseType = GraphicsContext3D::FLOAT;
2487         length = 4;
2488         break;
2489     case GraphicsContext3D::FLOAT_MAT2:
2490         baseType = GraphicsContext3D::FLOAT;
2491         length = 4;
2492         break;
2493     case GraphicsContext3D::FLOAT_MAT3:
2494         baseType = GraphicsContext3D::FLOAT;
2495         length = 9;
2496         break;
2497     case GraphicsContext3D::FLOAT_MAT4:
2498         baseType = GraphicsContext3D::FLOAT;
2499         length = 16;
2500         break;
2501     case GraphicsContext3D::SAMPLER_2D:
2502     case GraphicsContext3D::SAMPLER_CUBE:
2503         baseType = GraphicsContext3D::INT;
2504         length = 1;
2505         break;
2506     default:
2507         // Can't handle this type
2508         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getUniform", "unhandled type");
2509         return WebGLGetInfo();
2510     }
2511     switch (baseType) {
2512     case GraphicsContext3D::FLOAT: {
2513         GC3Dfloat value[16] = {0};
2514         if (m_isRobustnessEXTSupported)
2515             m_context->getExtensions()->getnUniformfvEXT(objectOrZero(program), location, 16 * sizeof(GC3Dfloat), value);
2516         else
2517             m_context->getUniformfv(objectOrZero(program), location, value);
2518         if (length == 1)
2519             return WebGLGetInfo(value[0]);
2520         return WebGLGetInfo(Float32Array::create(value, length).release());
2521     }
2522     case GraphicsContext3D::INT: {
2523         GC3Dint value[4] = {0};
2524         if (m_isRobustnessEXTSupported)
2525             m_context->getExtensions()->getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);
2526         else
2527             m_context->getUniformiv(objectOrZero(program), location, value);
2528         if (length == 1)
2529             return WebGLGetInfo(value[0]);
2530         return WebGLGetInfo(Int32Array::create(value, length).release());
2531     }
2532     case GraphicsContext3D::BOOL: {
2533         GC3Dint value[4] = {0};
2534         if (m_isRobustnessEXTSupported)
2535             m_context->getExtensions()->getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);
2536         else
2537             m_context->getUniformiv(objectOrZero(program), location, value);
2538         if (length > 1) {
2539             bool boolValue[16] = {0};
2540             for (unsigned j = 0; j < length; j++)
2541                 boolValue[j] = static_cast<bool>(value[j]);
2542             return WebGLGetInfo(boolValue, length);
2543         }
2544         return WebGLGetInfo(static_cast<bool>(value[0]));
2545     }
2546     default:
2547         notImplemented();
2548     }
2549
2550     // If we get here, something went wrong in our unfortunately complex logic above
2551     synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getUniform", "unknown error");
2552     return WebGLGetInfo();
2553 }
2554
2555 PassRefPtr<WebGLUniformLocation> WebGLRenderingContextBase::getUniformLocation(WebGLProgram* program, const String& name, ExceptionCode&)
2556 {
2557     if (isContextLostOrPending() || !validateWebGLObject("getUniformLocation", program))
2558         return nullptr;
2559     if (!validateLocationLength("getUniformLocation", name))
2560         return nullptr;
2561     if (!validateString("getUniformLocation", name))
2562         return nullptr;
2563     if (isPrefixReserved(name))
2564         return nullptr;
2565     if (!program->getLinkStatus()) {
2566         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getUniformLocation", "program not linked");
2567         return nullptr;
2568     }
2569     GC3Dint uniformLocation = m_context->getUniformLocation(objectOrZero(program), name);
2570     if (uniformLocation == -1)
2571         return nullptr;
2572
2573     GC3Dint activeUniforms = 0;
2574     m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), GraphicsContext3D::ACTIVE_UNIFORMS, &activeUniforms);
2575     for (GC3Dint i = 0; i < activeUniforms; i++) {
2576         ActiveInfo info;
2577         if (!m_context->getActiveUniform(objectOrZero(program), i, info))
2578             return nullptr;
2579         // Strip "[0]" from the name if it's an array.
2580         if (info.name.endsWith("[0]"))
2581             info.name = info.name.left(info.name.length() - 3);
2582         // If it's an array, we need to iterate through each element, appending "[index]" to the name.
2583         for (GC3Dint index = 0; index < info.size; ++index) {
2584             String uniformName = info.name + "[" + String::number(index) + "]";
2585
2586             if (name == uniformName || name == info.name)
2587                 return WebGLUniformLocation::create(program, uniformLocation, info.type);
2588         }
2589     }
2590     return nullptr;
2591 }
2592
2593 WebGLGetInfo WebGLRenderingContextBase::getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode&)
2594 {
2595     if (isContextLostOrPending())
2596         return WebGLGetInfo();
2597
2598     if (index >= m_maxVertexAttribs) {
2599         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getVertexAttrib", "index out of range");
2600         return WebGLGetInfo();
2601     }
2602
2603     const WebGLVertexArrayObjectBase::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);
2604
2605     if ((isWebGL2() || m_angleInstancedArrays) && pname == GraphicsContext3D::VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE)
2606         return WebGLGetInfo(state.divisor);
2607
2608     switch (pname) {
2609     case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
2610         if ((!isGLES2Compliant() && !index && m_boundVertexArrayObject->getVertexAttribState(0).bufferBinding == m_vertexAttrib0Buffer)
2611             || !state.bufferBinding
2612             || !state.bufferBinding->object())
2613             return WebGLGetInfo();
2614         return WebGLGetInfo(PassRefPtr<WebGLBuffer>(state.bufferBinding));
2615     case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_ENABLED:
2616         return WebGLGetInfo(state.enabled);
2617     case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_NORMALIZED:
2618         return WebGLGetInfo(state.normalized);
2619     case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_SIZE:
2620         return WebGLGetInfo(state.size);
2621     case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_STRIDE:
2622         return WebGLGetInfo(state.originalStride);
2623     case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_TYPE:
2624         return WebGLGetInfo(state.type);
2625     case GraphicsContext3D::CURRENT_VERTEX_ATTRIB:
2626         return WebGLGetInfo(Float32Array::create(m_vertexAttribValue[index].value, 4).release());
2627     default:
2628         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getVertexAttrib", "invalid parameter name");
2629         return WebGLGetInfo();
2630     }
2631 }
2632
2633 long long WebGLRenderingContextBase::getVertexAttribOffset(GC3Duint index, GC3Denum pname)
2634 {
2635     if (isContextLostOrPending())
2636         return 0;
2637     GC3Dsizeiptr result = m_context->getVertexAttribOffset(index, pname);
2638     return static_cast<long long>(result);
2639 }
2640
2641 GC3Dboolean WebGLRenderingContextBase::isBuffer(WebGLBuffer* buffer)
2642 {
2643     if (!buffer || isContextLostOrPending())
2644         return 0;
2645
2646     if (!buffer->hasEverBeenBound())
2647         return 0;
2648
2649     return m_context->isBuffer(buffer->object());
2650 }
2651
2652 bool WebGLRenderingContextBase::isContextLost() const
2653 {
2654     return m_contextLost;
2655 }
2656
2657 bool WebGLRenderingContextBase::isContextLostOrPending()
2658 {
2659     if (m_isPendingPolicyResolution && !m_hasRequestedPolicyResolution) {
2660         LOG(WebGL, "Context is being used. Attempt to resolve the policy.");
2661         Document& document = canvas()->document().topDocument();
2662         Page* page = document.page();
2663         if (page && !document.url().isLocalFile())
2664             page->mainFrame().loader().client().resolveWebGLPolicyForURL(document.url());
2665         // FIXME: We don't currently do anything with the result from resolution. A more
2666         // complete implementation might try to construct a real context, etc and proceed
2667         // with normal operation.
2668         // https://bugs.webkit.org/show_bug.cgi?id=129122
2669         m_hasRequestedPolicyResolution = true;
2670     }
2671
2672     return m_contextLost || m_isPendingPolicyResolution;
2673 }
2674
2675 GC3Dboolean WebGLRenderingContextBase::isEnabled(GC3Denum cap)
2676 {
2677     if (isContextLostOrPending() || !validateCapability("isEnabled", cap))
2678         return 0;
2679     if (cap == GraphicsContext3D::STENCIL_TEST)
2680         return m_stencilEnabled;
2681     return m_context->isEnabled(cap);
2682 }
2683
2684 GC3Dboolean WebGLRenderingContextBase::isFramebuffer(WebGLFramebuffer* framebuffer)
2685 {
2686     if (!framebuffer || isContextLostOrPending())
2687         return 0;
2688
2689     if (!framebuffer->hasEverBeenBound())
2690         return 0;
2691
2692     return m_context->isFramebuffer(framebuffer->object());
2693 }
2694
2695 GC3Dboolean WebGLRenderingContextBase::isProgram(WebGLProgram* program)
2696 {
2697     if (!program || isContextLostOrPending())
2698         return 0;
2699
2700     return m_context->isProgram(program->object());
2701 }
2702
2703 GC3Dboolean WebGLRenderingContextBase::isRenderbuffer(WebGLRenderbuffer* renderbuffer)
2704 {
2705     if (!renderbuffer || isContextLostOrPending())
2706         return 0;
2707
2708     if (!renderbuffer->hasEverBeenBound())
2709         return 0;
2710
2711     return m_context->isRenderbuffer(renderbuffer->object());
2712 }
2713
2714 GC3Dboolean WebGLRenderingContextBase::isShader(WebGLShader* shader)
2715 {
2716     if (!shader || isContextLostOrPending())
2717         return 0;
2718
2719     return m_context->isShader(shader->object());
2720 }
2721
2722 GC3Dboolean WebGLRenderingContextBase::isTexture(WebGLTexture* texture)
2723 {
2724     if (!texture || isContextLostOrPending())
2725         return 0;
2726
2727     if (!texture->hasEverBeenBound())
2728         return 0;
2729
2730     return m_context->isTexture(texture->object());
2731 }
2732
2733 void WebGLRenderingContextBase::lineWidth(GC3Dfloat width)
2734 {
2735     if (isContextLostOrPending())
2736         return;
2737     m_context->lineWidth(width);
2738 }
2739
2740 void WebGLRenderingContextBase::linkProgram(WebGLProgram* program, ExceptionCode&)
2741 {
2742     if (isContextLostOrPending() || !validateWebGLObject("linkProgram", program))
2743         return;
2744     WebGLShader* vertexShader = program->getAttachedShader(GraphicsContext3D::VERTEX_SHADER);
2745     WebGLShader* fragmentShader = program->getAttachedShader(GraphicsContext3D::FRAGMENT_SHADER);
2746     if (!vertexShader || !vertexShader->isValid() || !fragmentShader || !fragmentShader->isValid() || !m_context->precisionsMatch(objectOrZero(vertexShader), objectOrZero(fragmentShader)) || !m_context->checkVaryingsPacking(objectOrZero(vertexShader), objectOrZero(fragmentShader))) {
2747         program->setLinkStatus(false);
2748         return;
2749     }
2750
2751     m_context->linkProgram(objectOrZero(program));
2752     program->increaseLinkCount();
2753 }
2754
2755 void WebGLRenderingContextBase::pixelStorei(GC3Denum pname, GC3Dint param)
2756 {
2757     if (isContextLostOrPending())
2758         return;
2759     switch (pname) {
2760     case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:
2761         m_unpackFlipY = param;
2762         break;
2763     case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:
2764         m_unpackPremultiplyAlpha = param;
2765         break;
2766     case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:
2767         if (param == GraphicsContext3D::BROWSER_DEFAULT_WEBGL || param == GraphicsContext3D::NONE)
2768             m_unpackColorspaceConversion = static_cast<GC3Denum>(param);
2769         else {
2770             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "pixelStorei", "invalid parameter for UNPACK_COLORSPACE_CONVERSION_WEBGL");
2771             return;
2772         }
2773         break;
2774     case GraphicsContext3D::PACK_ALIGNMENT:
2775     case GraphicsContext3D::UNPACK_ALIGNMENT:
2776         if (param == 1 || param == 2 || param == 4 || param == 8) {
2777             if (pname == GraphicsContext3D::PACK_ALIGNMENT)
2778                 m_packAlignment = param;
2779             else // GraphicsContext3D::UNPACK_ALIGNMENT:
2780                 m_unpackAlignment = param;
2781             m_context->pixelStorei(pname, param);
2782         } else {
2783             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "pixelStorei", "invalid parameter for alignment");
2784             return;
2785         }
2786         break;
2787     default:
2788         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "pixelStorei", "invalid parameter name");
2789         return;
2790     }
2791 }
2792
2793 void WebGLRenderingContextBase::polygonOffset(GC3Dfloat factor, GC3Dfloat units)
2794 {
2795     if (isContextLostOrPending())
2796         return;
2797     m_context->polygonOffset(factor, units);
2798 }
2799
2800 void WebGLRenderingContextBase::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode&)
2801 {
2802     if (isContextLostOrPending())
2803         return;
2804     // Due to WebGL's same-origin restrictions, it is not possible to
2805     // taint the origin using the WebGL API.
2806     ASSERT(canvas()->originClean());
2807     // Validate input parameters.
2808     if (!pixels) {
2809         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "readPixels", "no destination ArrayBufferView");
2810         return;
2811     }
2812     switch (format) {
2813     case GraphicsContext3D::ALPHA:
2814     case GraphicsContext3D::RGB:
2815     case GraphicsContext3D::RGBA:
2816         break;
2817     default:
2818         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid format");
2819         return;
2820     }
2821     switch (type) {
2822     case GraphicsContext3D::UNSIGNED_BYTE:
2823     case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:
2824     case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:
2825     case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:
2826         break;
2827     default:
2828         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid type");
2829         return;
2830     }
2831     if (format != GraphicsContext3D::RGBA || type != GraphicsContext3D::UNSIGNED_BYTE) {
2832         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "format not RGBA or type not UNSIGNED_BYTE");
2833         return;
2834     }
2835     // Validate array type against pixel type.
2836     if (pixels->getType() != JSC::TypeUint8) {
2837         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "ArrayBufferView not Uint8Array");
2838         return;
2839     }
2840     const char* reason = "framebuffer incomplete";
2841     if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {
2842         synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "readPixels", reason);
2843         return;
2844     }
2845     // Calculate array size, taking into consideration of PACK_ALIGNMENT.
2846     unsigned int totalBytesRequired = 0;
2847     unsigned int padding = 0;
2848     if (!m_isRobustnessEXTSupported) {
2849         GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);
2850         if (error != GraphicsContext3D::NO_ERROR) {
2851             synthesizeGLError(error, "readPixels", "invalid dimensions");
2852             return;
2853         }
2854         if (pixels->byteLength() < totalBytesRequired) {
2855             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "ArrayBufferView not large enough for dimensions");
2856             return;
2857         }
2858     }
2859
2860     clearIfComposited();
2861     void* data = pixels->baseAddress();
2862
2863     {
2864         if (m_isRobustnessEXTSupported)
2865             m_context->getExtensions()->readnPixelsEXT(x, y, width, height, format, type, pixels->byteLength(), data);
2866         else
2867             m_context->readPixels(x, y, width, height, format, type, data);
2868     }
2869
2870 #if OS(DARWIN)
2871     if (m_isRobustnessEXTSupported) // we haven't computed padding
2872         m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);
2873     // FIXME: remove this section when GL driver bug on Mac AND the GLES driver bug
2874     // on QC is fixed, i.e., when alpha is off, readPixels should
2875     // set alpha to 255 instead of 0.
2876     if (!m_framebufferBinding && !m_context->getContextAttributes().alpha) {
2877         unsigned char* pixels = reinterpret_cast<unsigned char*>(data);
2878         for (GC3Dsizei iy = 0; iy < height; ++iy) {
2879             for (GC3Dsizei ix = 0; ix < width; ++ix) {
2880                 pixels[3] = 255;
2881                 pixels += 4;
2882             }
2883             pixels += padding;
2884         }
2885     }
2886 #endif
2887 }
2888
2889 void WebGLRenderingContextBase::releaseShaderCompiler()
2890 {
2891     if (isContextLostOrPending())
2892         return;
2893     m_context->releaseShaderCompiler();
2894 }
2895
2896 void WebGLRenderingContextBase::sampleCoverage(GC3Dfloat value, GC3Dboolean invert)
2897 {
2898     if (isContextLostOrPending())
2899         return;
2900     m_context->sampleCoverage(value, invert);
2901 }
2902
2903 void WebGLRenderingContextBase::scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
2904 {
2905     if (isContextLostOrPending())
2906         return;
2907     if (!validateSize("scissor", width, height))
2908         return;
2909     m_context->scissor(x, y, width, height);
2910 }
2911
2912 void WebGLRenderingContextBase::shaderSource(WebGLShader* shader, const String& string, ExceptionCode&)
2913 {
2914     if (isContextLostOrPending() || !validateWebGLObject("shaderSource", shader))
2915         return;
2916     String stringWithoutComments = StripComments(string).result();
2917     if (!validateString("shaderSource", stringWithoutComments))
2918         return;
2919     shader->setSource(string);
2920     m_context->shaderSource(objectOrZero(shader), stringWithoutComments);
2921 }
2922
2923 void WebGLRenderingContextBase::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask)
2924 {
2925     if (isContextLostOrPending())
2926         return;
2927     if (!validateStencilFunc("stencilFunc", func))
2928         return;
2929     m_stencilFuncRef = ref;
2930     m_stencilFuncRefBack = ref;
2931     m_stencilFuncMask = mask;
2932     m_stencilFuncMaskBack = mask;
2933     m_context->stencilFunc(func, ref, mask);
2934 }
2935
2936 void WebGLRenderingContextBase::stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask)
2937 {
2938     if (isContextLostOrPending())
2939         return;
2940     if (!validateStencilFunc("stencilFuncSeparate", func))
2941         return;
2942     switch (face) {
2943     case GraphicsContext3D::FRONT_AND_BACK:
2944         m_stencilFuncRef = ref;
2945         m_stencilFuncRefBack = ref;
2946         m_stencilFuncMask = mask;
2947         m_stencilFuncMaskBack = mask;
2948         break;
2949     case GraphicsContext3D::FRONT:
2950         m_stencilFuncRef = ref;
2951         m_stencilFuncMask = mask;
2952         break;
2953     case GraphicsContext3D::BACK:
2954         m_stencilFuncRefBack = ref;
2955         m_stencilFuncMaskBack = mask;
2956         break;
2957     default:
2958         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "stencilFuncSeparate", "invalid face");
2959         return;
2960     }
2961     m_context->stencilFuncSeparate(face, func, ref, mask);
2962 }
2963
2964 void WebGLRenderingContextBase::stencilMask(GC3Duint mask)
2965 {
2966     if (isContextLostOrPending())
2967         return;
2968     m_stencilMask = mask;
2969     m_stencilMaskBack = mask;
2970     m_context->stencilMask(mask);
2971 }
2972
2973 void WebGLRenderingContextBase::stencilMaskSeparate(GC3Denum face, GC3Duint mask)
2974 {
2975     if (isContextLostOrPending())
2976         return;
2977     switch (face) {
2978     case GraphicsContext3D::FRONT_AND_BACK:
2979         m_stencilMask = mask;
2980         m_stencilMaskBack = mask;
2981         break;
2982     case GraphicsContext3D::FRONT:
2983         m_stencilMask = mask;
2984         break;
2985     case GraphicsContext3D::BACK:
2986         m_stencilMaskBack = mask;
2987         break;
2988     default:
2989         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "stencilMaskSeparate", "invalid face");
2990         return;
2991     }
2992     m_context->stencilMaskSeparate(face, mask);
2993 }
2994
2995 void WebGLRenderingContextBase::stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass)
2996 {
2997     if (isContextLostOrPending())
2998         return;
2999     m_context->stencilOp(fail, zfail, zpass);
3000 }
3001
3002 void WebGLRenderingContextBase::stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass)
3003 {
3004     if (isContextLostOrPending())
3005         return;
3006     m_context->stencilOpSeparate(face, fail, zfail, zpass);
3007 }
3008
3009 void WebGLRenderingContextBase::texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)
3010 {
3011     // FIXME: For now we ignore any errors returned.
3012     ec = 0;
3013     WebGLTexture* tex = validateTextureBinding("texImage2D", target, true);
3014     ASSERT(validateTexFuncParameters("texImage2D", TexImage, target, level, internalformat, width, height, border, format, type));
3015     ASSERT(tex);
3016     ASSERT(validateNPOTTextureLevel(width, height, level, "texImage2D"));
3017     if (!pixels) {
3018         // Note: Chromium's OpenGL implementation clears textures and isResourceSafe() is therefore true.
3019         // For other implementations, if they are using ANGLE_depth_texture, ANGLE depth textures
3020         // can not be cleared with texImage2D and must be cleared by binding to an fbo and calling
3021         // clear.
3022         if (isResourceSafe())
3023             m_context->texImage2D(target, level, internalformat, width, height, border, format, type, nullptr);
3024         else {
3025             bool succeed = m_context->texImage2DResourceSafe(target, level, internalformat, width, height,
3026                                                              border, format, type, m_unpackAlignment);
3027             if (!succeed)
3028                 return;
3029         }
3030     } else {
3031         ASSERT(validateSettableTexFormat("texImage2D", internalformat));
3032         m_context->moveErrorsToSyntheticErrorList();
3033         m_context->texImage2D(target, level, internalformat, width, height,
3034                               border, format, type, pixels);
3035         if (m_context->moveErrorsToSyntheticErrorList()) {
3036             // The texImage2D function failed. Tell the WebGLTexture it doesn't have the data for this level.
3037             tex->markInvalid(target, level);
3038             return;
3039         }
3040     }
3041     tex->setLevelInfo(target, level, internalformat, width, height, type);
3042 }
3043
3044 void WebGLRenderingContextBase::texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)
3045 {
3046     ec = 0;
3047     Vector<uint8_t> data;
3048     GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);
3049     if (!imageExtractor.extractSucceeded()) {
3050         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");
3051         return;
3052     }
3053     GraphicsContext3D::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();
3054     GraphicsContext3D::AlphaOp alphaOp = imageExtractor.imageAlphaOp();
3055     const void* imagePixelData = imageExtractor.imagePixelData();
3056
3057     bool needConversion = true;
3058     if (type == GraphicsContext3D::UNSIGNED_BYTE && sourceDataFormat == GraphicsContext3D::DataFormatRGBA8 && format == GraphicsContext3D::RGBA && alphaOp == GraphicsContext3D::AlphaDoNothing && !flipY)
3059         needConversion = false;
3060     else {
3061         if (!m_context->packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {
3062             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "packImage error");
3063             return;
3064         }
3065     }
3066
3067     if (m_unpackAlignment != 1)
3068         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
3069     texImage2DBase(target, level, internalformat, image->width(), image->height(), 0, format, type, needConversion ? data.data() : imagePixelData, ec);
3070     if (m_unpackAlignment != 1)
3071         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
3072 }
3073
3074 bool WebGLRenderingContextBase::validateTexFunc(const char* functionName, TexFuncValidationFunctionType functionType, TexFuncValidationSourceType sourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset)
3075 {
3076     if (!validateTexFuncParameters(functionName, functionType, target, level, internalformat, width, height, border, format, type))
3077         return false;
3078
3079     WebGLTexture* texture = validateTextureBinding(functionName, target, true);
3080     if (!texture)
3081         return false;
3082
3083     if (functionType != TexSubImage) {
3084         if (!validateNPOTTextureLevel(width, height, level, functionName))
3085             return false;
3086         // For SourceArrayBufferView, function validateTexFuncData() would handle whether to validate the SettableTexFormat
3087         // by checking if the ArrayBufferView is null or not.
3088         if (sourceType != SourceArrayBufferView) {
3089             if (!validateSettableTexFormat(functionName, format))
3090                 return false;
3091         }
3092     } else {
3093         if (!validateSettableTexFormat(functionName, format))
3094             return false;
3095         if (!validateSize(functionName, xoffset, yoffset))
3096             return false;
3097         // Before checking if it is in the range, check if overflow happens first.
3098         if (xoffset + width < 0 || yoffset + height < 0) {
3099             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "bad dimensions");
3100             return false;
3101         }
3102         if (xoffset + width > texture->getWidth(target, level) || yoffset + height > texture->getHeight(target, level)) {
3103             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "dimensions out of range");
3104             return false;
3105         }
3106         if (texture->getInternalFormat(target, level) != format || texture->getType(target, level) != type) {
3107             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type and format do not match texture");
3108             return false;
3109         }
3110     }
3111
3112     return true;
3113 }
3114
3115 void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
3116                                        GC3Dsizei width, GC3Dsizei height, GC3Dint border,
3117                                        GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode& ec)
3118 {
3119     if (isContextLostOrPending() || !validateTexFuncData("texImage2D", level, width, height, internalformat, format, type, pixels, NullAllowed)
3120         || !validateTexFunc("texImage2D", TexImage, SourceArrayBufferView, target, level, internalformat, width, height, border, format, type, 0, 0))
3121         return;
3122     void* data = pixels ? pixels->baseAddress() : 0;
3123     Vector<uint8_t> tempData;
3124     bool changeUnpackAlignment = false;
3125     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
3126         if (!m_context->extractTextureData(width, height, format, type,
3127                                            m_unpackAlignment,
3128                                            m_unpackFlipY, m_unpackPremultiplyAlpha,
3129                                            data,
3130                                            tempData))
3131             return;
3132         data = tempData.data();
3133         changeUnpackAlignment = true;
3134     }
3135     if (changeUnpackAlignment)
3136         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
3137     texImage2DBase(target, level, internalformat, width, height, border,
3138                    format, type, data, ec);
3139     if (changeUnpackAlignment)
3140         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
3141 }
3142
3143 void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
3144                                        GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)
3145 {
3146     ec = 0;
3147     if (isContextLostOrPending() || !pixels || !validateTexFunc("texImage2D", TexImage, SourceImageData, target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, 0, 0))
3148         return;
3149     Vector<uint8_t> data;
3150     bool needConversion = true;
3151     // The data from ImageData is always of format RGBA8.
3152     // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.
3153     if (!m_unpackFlipY && !m_unpackPremultiplyAlpha && format == GraphicsContext3D::RGBA && type == GraphicsContext3D::UNSIGNED_BYTE)
3154         needConversion = false;
3155     else {
3156         if (!m_context->extractImageData(pixels, format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
3157             synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");
3158             return;
3159         }
3160     }
3161     if (m_unpackAlignment != 1)
3162         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
3163     texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, needConversion ? data.data() : pixels->data()->data(), ec);
3164     if (m_unpackAlignment != 1)
3165         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
3166 }
3167
3168 PassRefPtr<Image> WebGLRenderingContextBase::drawImageIntoBuffer(Image& image, int width, int height, int deviceScaleFactor)
3169 {
3170     IntSize size(width, height);
3171     size.scale(deviceScaleFactor);
3172     ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);
3173     if (!buf) {
3174         synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "texImage2D", "out of memory");
3175         return nullptr;
3176     }
3177
3178     FloatRect srcRect(FloatPoint(), image.size());
3179     FloatRect destRect(FloatPoint(), size);
3180     buf->context().drawImage(image, destRect, srcRect);
3181     return buf->copyImage(ImageBuffer::fastCopyImageMode());
3182 }
3183
3184 void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
3185                                        GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)
3186 {
3187     ec = 0;
3188     if (isContextLostOrPending() || !validateHTMLImageElement("texImage2D", image, ec))
3189         return;
3190
3191     RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());
3192     if (!imageForRender)
3193         return;
3194
3195     if (imageForRender->isSVGImage())
3196         imageForRender = drawImageIntoBuffer(*imageForRender, image->width(), image->height(), 1);
3197
3198     if (!imageForRender || !validateTexFunc("texImage2D", TexImage, SourceHTMLImageElement, target, level, internalformat, imageForRender->width(), imageForRender->height(), 0, format, type, 0, 0))
3199         return;
3200
3201     texImage2DImpl(target, level, internalformat, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
3202 }
3203
3204 void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
3205                                        GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)
3206 {
3207     ec = 0;
3208     if (isContextLostOrPending() || !validateHTMLCanvasElement("texImage2D", canvas, ec) || !validateTexFunc("texImage2D", TexImage, SourceHTMLCanvasElement, target, level, internalformat, canvas->width(), canvas->height(), 0, format, type, 0, 0))
3209         return;
3210
3211     WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);
3212     // If possible, copy from the canvas element directly to the texture
3213     // via the GPU, without a read-back to system memory.
3214     //
3215     // FIXME: restriction of (RGB || RGBA)/UNSIGNED_BYTE should be lifted when
3216     // ImageBuffer::copyToPlatformTexture implementations are fully functional.
3217     if (texture
3218         && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA)
3219         && type == GraphicsContext3D::UNSIGNED_BYTE
3220         && (texture->getType(target, level) == GraphicsContext3D::UNSIGNED_BYTE || !texture->isValid(target, level))) {
3221         ImageBuffer* buffer = canvas->buffer();
3222         if (buffer && buffer->copyToPlatformTexture(*m_context.get(), target, texture->object(), internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
3223             texture->setLevelInfo(target, level, internalformat, canvas->width(), canvas->height(), type);
3224             return;
3225         }
3226     }
3227
3228     RefPtr<ImageData> imageData = canvas->getImageData();
3229     if (imageData)
3230         texImage2D(target, level, internalformat, format, type, imageData.get(), ec);
3231     else
3232         texImage2DImpl(target, level, internalformat, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
3233 }
3234
3235 #if ENABLE(VIDEO)
3236 PassRefPtr<Image> WebGLRenderingContextBase::videoFrameToImage(HTMLVideoElement* video, BackingStoreCopy backingStoreCopy, ExceptionCode&)
3237 {
3238     IntSize size(video->videoWidth(), video->videoHeight());
3239     ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);
3240     if (!buf) {
3241         synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "texImage2D", "out of memory");
3242         return nullptr;
3243     }
3244     FloatRect destRect(0, 0, size.width(), size.height());
3245     // FIXME: Turn this into a GPU-GPU texture copy instead of CPU readback.
3246     video->paintCurrentFrameInContext(buf->context(), destRect);
3247     return buf->copyImage(backingStoreCopy);
3248 }
3249
3250 void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
3251                                        GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)
3252 {
3253     ec = 0;
3254     if (isContextLostOrPending() || !validateHTMLVideoElement("texImage2D", video, ec)
3255         || !validateTexFunc("texImage2D", TexImage, SourceHTMLVideoElement, target, level, internalformat, video->videoWidth(), video->videoHeight(), 0, format, type, 0, 0))
3256         return;
3257
3258     // Go through the fast path doing a GPU-GPU textures copy without a readback to system memory if possible.
3259     // Otherwise, it will fall back to the normal SW path.
3260     // FIXME: The current restrictions require that format shoud be RGB or RGBA,
3261     // type should be UNSIGNED_BYTE and level should be 0. It may be lifted in the future.
3262     WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);
3263     if (GraphicsContext3D::TEXTURE_2D == target && texture
3264         && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA)
3265         && type == GraphicsContext3D::UNSIGNED_BYTE
3266         && (texture->getType(target, level) == GraphicsContext3D::UNSIGNED_BYTE || !texture->isValid(target, level))
3267         && !level) {
3268         if (video->copyVideoTextureToPlatformTexture(m_context.get(), texture->object(), target, level, internalformat, format, type, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
3269             texture->setLevelInfo(target, level, internalformat, video->videoWidth(), video->videoHeight(), type);
3270             return;
3271         }
3272     }
3273
3274     // Normal pure SW path.
3275     RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode(), ec);
3276     if (!image)
3277         return;
3278     texImage2DImpl(target, level, internalformat, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
3279 }
3280 #endif
3281
3282 void WebGLRenderingContextBase::texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat paramf, GC3Dint parami, bool isFloat)
3283 {
3284     if (isContextLostOrPending())
3285         return;
3286     WebGLTexture* tex = validateTextureBinding("texParameter", target, false);
3287     if (!tex)
3288         return;
3289     switch (pname) {
3290     case GraphicsContext3D::TEXTURE_MIN_FILTER:
3291     case GraphicsContext3D::TEXTURE_MAG_FILTER:
3292         break;
3293     case GraphicsContext3D::TEXTURE_WRAP_S:
3294     case GraphicsContext3D::TEXTURE_WRAP_T:
3295         if ((isFloat && paramf != GraphicsContext3D::CLAMP_TO_EDGE && paramf != GraphicsContext3D::MIRRORED_REPEAT && paramf != GraphicsContext3D::REPEAT)
3296             || (!isFloat && parami != GraphicsContext3D::CLAMP_TO_EDGE && parami != GraphicsContext3D::MIRRORED_REPEAT && parami != GraphicsContext3D::REPEAT)) {
3297             synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter");
3298             return;
3299         }
3300         break;
3301     case Extensions3D::TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic
3302         if (!m_extTextureFilterAnisotropic) {
3303             synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter, EXT_texture_filter_anisotropic not enabled");
3304             return;
3305         }
3306         break;
3307     default:
3308         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter name");
3309         return;
3310     }
3311     if (isFloat) {
3312         tex->setParameterf(pname, paramf);
3313         m_context->texParameterf(target, pname, paramf);
3314     } else {
3315         tex->setParameteri(pname, parami);
3316         m_context->texParameteri(target, pname, parami);
3317     }
3318 }
3319
3320 void WebGLRenderingContextBase::texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param)
3321 {
3322     texParameter(target, pname, param, 0, true);
3323 }
3324
3325 void WebGLRenderingContextBase::texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param)
3326 {
3327     texParameter(target, pname, 0, param, false);
3328 }
3329
3330 void WebGLRenderingContextBase::uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode&)
3331 {
3332     if (isContextLostOrPending() || !location)
3333         return;
3334
3335     if (location->program() != m_currentProgram) {
3336         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1f", "location not for current program");
3337         return;
3338     }
3339
3340     m_context->uniform1f(location->location(), x);
3341 }
3342
3343 void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&)
3344 {
3345     if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, 1))
3346         return;
3347
3348     m_context->uniform1fv(location->location(), v->length(), v->data());
3349 }
3350
3351 void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&)
3352 {
3353     if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, size, 1))
3354         return;
3355
3356     m_context->uniform1fv(location->location(), size, v);
3357 }
3358
3359 void WebGLRenderingContextBase::uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode&)
3360 {
3361     if (isContextLostOrPending() || !location)
3362         return;
3363
3364     if (location->program() != m_currentProgram) {
3365         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1i", "location not for current program");
3366         return;
3367     }
3368
3369     if ((location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE) && x >= (int)m_textureUnits.size()) {
3370         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1i", "invalid texture unit");
3371         return;
3372     }
3373
3374     m_context->uniform1i(location->location(), x);
3375 }
3376
3377 void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&)
3378 {
3379     if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, 1))
3380         return;
3381
3382     if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE)
3383         for (unsigned i = 0; i < v->length(); ++i) {
3384             if (v->data()[i] >= static_cast<int>(m_textureUnits.size())) {
3385                 LOG(WebGL, "Texture unit size=%zu, v[%d]=%d. Location type = %04X.", m_textureUnits.size(), i, v->data()[i], location->type());
3386                 synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");
3387                 return;
3388             }
3389         }
3390
3391     m_context->uniform1iv(location->location(), v->length(), v->data());
3392 }
3393
3394 void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&)
3395 {
3396     if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, size, 1))
3397         return;
3398
3399     if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE)
3400         for (unsigned i = 0; i < static_cast<unsigned>(size); ++i) {
3401             if (((GC3Dint*)v)[i] >= static_cast<int>(m_textureUnits.size())) {
3402                 synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");
3403                 return;
3404             }
3405         }
3406
3407     m_context->uniform1iv(location->location(), size, v);
3408 }
3409
3410 void WebGLRenderingContextBase::uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode&)
3411 {
3412     if (isContextLostOrPending() || !location)
3413         return;
3414
3415     if (location->program() != m_currentProgram) {
3416         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2f", "location not for current program");
3417         return;
3418     }
3419
3420     m_context->uniform2f(location->location(), x, y);
3421 }
3422
3423 void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&)
3424 {
3425     if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, 2))
3426         return;
3427
3428     m_context->uniform2fv(location->location(), v->length() / 2, v->data());
3429 }
3430
3431 void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&)
3432 {
3433     if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, size, 2))
3434         return;
3435
3436     m_context->uniform2fv(location->location(), size / 2, v);
3437 }
3438
3439 void WebGLRenderingContextBase::uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode&)
3440 {
3441     if (isContextLostOrPending() || !location)
3442         return;
3443
3444     if (location->program() != m_currentProgram) {
3445         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2i", "location not for current program");
3446         return;
3447     }
3448
3449     m_context->uniform2i(location->location(), x, y);
3450 }
3451
3452 void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&)
3453 {
3454     if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, 2))
3455         return;
3456
3457     m_context->uniform2iv(location->location(), v->length() / 2, v->data());
3458 }
3459
3460 void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&)
3461 {
3462     if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, size, 2))
3463         return;
3464
3465     m_context->uniform2iv(location->location(), size / 2, v);
3466 }
3467
3468 void WebGLRenderingContextBase::uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode&)
3469 {
3470     if (isContextLostOrPending() || !location)
3471         return;
3472
3473     if (location->program() != m_currentProgram) {
3474         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3f", "location not for current program");
3475         return;
3476     }
3477
3478     m_context->uniform3f(location->location(), x, y, z);
3479 }
3480
3481 void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&)
3482 {
3483     if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, 3))
3484         return;
3485
3486     m_context->uniform3fv(location->location(), v->length() / 3, v->data());
3487 }
3488
3489 void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&)
3490 {
3491     if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, size, 3))
3492         return;
3493
3494     m_context->uniform3fv(location->location(), size / 3, v);
3495 }
3496
3497 void WebGLRenderingContextBase::uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode&)
3498 {
3499     if (isContextLostOrPending() || !location)
3500         return;
3501
3502     if (location->program() != m_currentProgram) {
3503         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3i", "location not for current program");
3504         return;
3505     }
3506
3507     m_context->uniform3i(location->location(), x, y, z);
3508 }
3509
3510 void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&)
3511 {
3512     if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, 3))
3513         return;
3514
3515     m_context->uniform3iv(location->location(), v->length() / 3, v->data());
3516 }
3517
3518 void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&)
3519 {
3520     if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, size, 3))
3521         return;
3522
3523     m_context->uniform3iv(location->location(), size / 3, v);
3524 }
3525
3526 void WebGLRenderingContextBase::uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode&)
3527 {
3528     if (isContextLostOrPending() || !location)
3529         return;
3530
3531     if (location->program() != m_currentProgram) {
3532         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4f", "location not for current program");
3533         return;
3534     }
3535
3536     m_context->uniform4f(location->location(), x, y, z, w);
3537 }
3538
3539 void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&)
3540 {
3541     if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, 4))
3542         return;
3543
3544     m_context->uniform4fv(location->location(), v->length() / 4, v->data());
3545 }
3546
3547 void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&)
3548 {
3549     if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, size, 4))
3550         return;
3551
3552     m_context->uniform4fv(location->location(), size / 4, v);
3553 }
3554
3555 void WebGLRenderingContextBase::uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode&)
3556 {
3557     if (isContextLostOrPending() || !location)
3558         return;
3559
3560     if (location->program() != m_currentProgram) {
3561         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4i", "location not for current program");
3562         return;
3563     }
3564
3565     m_context->uniform4i(location->location(), x, y, z, w);
3566 }
3567
3568 void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&)
3569 {
3570     if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, 4))
3571         return;
3572
3573     m_context->uniform4iv(location->location(), v->length() / 4, v->data());
3574 }
3575
3576 void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&)
3577 {
3578     if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, size, 4))
3579         return;
3580
3581     m_context->uniform4iv(location->location(), size / 4, v);
3582 }
3583
3584 void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode&)
3585 {
3586     if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))
3587         return;
3588     m_context->uniformMatrix2fv(location->location(), v->length() / 4, transpose, v->data());
3589 }
3590
3591 void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&)
3592 {
3593     if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, size, 4))
3594         return;
3595     m_context->uniformMatrix2fv(location->location(), size / 4, transpose, v);
3596 }
3597
3598 void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode&)
3599 {
3600     if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, 9))
3601         return;
3602     m_context->uniformMatrix3fv(location->location(), v->length() / 9, transpose, v->data());
3603 }
3604
3605 void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&)
3606 {
3607     if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, size, 9))
3608         return;
3609     m_context->uniformMatrix3fv(location->location(), size / 9, transpose, v);
3610 }
3611
3612 void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode&)
3613 {
3614     if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, 16))
3615         return;
3616     m_context->uniformMatrix4fv(location->location(), v->length() / 16, transpose, v->data());
3617 }
3618
3619 void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&)
3620 {
3621     if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, size, 16))
3622         return;
3623     m_context->uniformMatrix4fv(location->location(), size / 16, transpose, v);
3624 }
3625
3626 void WebGLRenderingContextBase::useProgram(WebGLProgram* program, ExceptionCode&)
3627 {
3628     bool deleted;
3629     if (!checkObjectToBeBound("useProgram", program, deleted))
3630         return;
3631     if (deleted)
3632         program = 0;
3633     if (program && !program->getLinkStatus()) {
3634         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "useProgram", "program not valid");
3635         return;
3636     }
3637     if (m_currentProgram != program) {
3638         if (m_currentProgram)
3639             m_currentProgram->onDetached(graphicsContext3D());
3640         m_currentProgram = program;
3641         m_context->useProgram(objectOrZero(program));
3642         if (program)
3643             program->onAttached();
3644     }
3645 }
3646
3647 void WebGLRenderingContextBase::validateProgram(WebGLProgram* program, ExceptionCode&)
3648 {
3649     if (isContextLostOrPending() || !validateWebGLObject("validateProgram", program))
3650         return;
3651     m_context->validateProgram(objectOrZero(program));
3652 }
3653
3654 void WebGLRenderingContextBase::vertexAttrib1f(GC3Duint index, GC3Dfloat v0)
3655 {
3656     vertexAttribfImpl("vertexAttrib1f", index, 1, v0, 0.0f, 0.0f, 1.0f);
3657 }
3658
3659 void WebGLRenderingContextBase::vertexAttrib1fv(GC3Duint index, Float32Array* v)
3660 {
3661     vertexAttribfvImpl("vertexAttrib1fv", index, v, 1);
3662 }
3663
3664 void WebGLRenderingContextBase::vertexAttrib1fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)
3665 {
3666     vertexAttribfvImpl("vertexAttrib1fv", index, v, size, 1);
3667 }
3668
3669 void WebGLRenderingContextBase::vertexAttrib2f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1)
3670 {
3671     vertexAttribfImpl("vertexAttrib2f", index, 2, v0, v1, 0.0f, 1.0f);
3672 }
3673
3674 void WebGLRenderingContextBase::vertexAttrib2fv(GC3Duint index, Float32Array* v)
3675 {
3676     vertexAttribfvImpl("vertexAttrib2fv", index, v, 2);
3677 }
3678
3679 void WebGLRenderingContextBase::vertexAttrib2fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)
3680 {
3681     vertexAttribfvImpl("vertexAttrib2fv", index, v, size, 2);
3682 }
3683
3684 void WebGLRenderingContextBase::vertexAttrib3f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2)
3685 {
3686     vertexAttribfImpl("vertexAttrib3f", index, 3, v0, v1, v2, 1.0f);
3687 }
3688
3689 void WebGLRenderingContextBase::vertexAttrib3fv(GC3Duint index, Float32Array* v)
3690 {
3691     vertexAttribfvImpl("vertexAttrib3fv", index, v, 3);
3692 }
3693
3694 void WebGLRenderingContextBase::vertexAttrib3fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)
3695 {
3696     vertexAttribfvImpl("vertexAttrib3fv", index, v, size, 3);
3697 }
3698
3699 void WebGLRenderingContextBase::vertexAttrib4f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)
3700 {
3701     vertexAttribfImpl("vertexAttrib4f", index, 4, v0, v1, v2, v3);
3702 }
3703
3704 void WebGLRenderingContextBase::vertexAttrib4fv(GC3Duint index, Float32Array* v)
3705 {
3706     vertexAttribfvImpl("vertexAttrib4fv", index, v, 4);
3707 }
3708
3709 void WebGLRenderingContextBase::vertexAttrib4fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)
3710 {
3711     vertexAttribfvImpl("vertexAttrib4fv", index, v, size, 4);
3712 }
3713
3714 void WebGLRenderingContextBase::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, long long offset, ExceptionCode&)
3715 {
3716     if (isContextLostOrPending())
3717         return;
3718     switch (type) {
3719     case GraphicsContext3D::BYTE:
3720     case GraphicsContext3D::UNSIGNED_BYTE:
3721     case GraphicsContext3D::SHORT:
3722     case GraphicsContext3D::UNSIGNED_SHORT:
3723     case GraphicsContext3D::FLOAT:
3724         break;
3725     default:
3726         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "vertexAttribPointer", "invalid type");
3727         return;
3728     }
3729     if (index >= m_maxVertexAttribs) {
3730         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribPointer", "index out of range");
3731         return;
3732     }
3733     if (size < 1 || size > 4 || stride < 0 || stride > 255 || offset < 0) {
3734         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribPointer", "bad size, stride or offset");
3735         return;
3736     }
3737     if (!m_boundArrayBuffer) {
3738         synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "vertexAttribPointer", "no bound ARRAY_BUFFER");
3739         return;
3740     }
3741     // Determine the number of elements the bound buffer can hold, given the offset, size, type and stride
3742     unsigned int typeSize = sizeInBytes(type);
3743     if (!typeSize) {
3744         synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "vertexAttribPo