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