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