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