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