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