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