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