The Tor Browser: content/canvas/src/WebGLContextGL.cpp@deefc01c0e14 (annotated)

content/canvas/src/WebGLContextGL.cpp@deefc01c0e14 (annotated)

content/canvas/src/WebGLContextGL.cpp

Thu, 15 Jan 2015 21:03:48 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 21:03:48 +0100
branch: TOR_BUG_9701
changeset 11: deefc01c0e14
permissions: -rw-r--r--

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "WebGLContext.h"
 #include "WebGLContextUtils.h"
 #include "WebGLBuffer.h"
 #include "WebGLVertexAttribData.h"
 #include "WebGLShader.h"
 #include "WebGLProgram.h"
 #include "WebGLUniformLocation.h"
 #include "WebGLFramebuffer.h"
 #include "WebGLRenderbuffer.h"
 #include "WebGLShaderPrecisionFormat.h"
 #include "WebGLTexture.h"
 #include "WebGLExtensions.h"
 #include "WebGLVertexArray.h"
 #include "nsString.h"
 #include "nsDebug.h"
 #include "gfxContext.h"
 #include "gfxPlatform.h"
 #include "GLContext.h"
 #include "nsContentUtils.h"
 #include "nsError.h"
 #include "nsLayoutUtils.h"
 #include "CanvasUtils.h"
 #include "gfxUtils.h"
 #include "jsfriendapi.h"
 #include "WebGLTexelConversions.h"
 #include "WebGLValidateStrings.h"
 #include <algorithm>
 // needed to check if current OS is lower than 10.7
 #if defined(MOZ_WIDGET_COCOA)
 #include "nsCocoaFeatures.h"
 #endif
 #include "mozilla/dom/BindingUtils.h"
 #include "mozilla/dom/ImageData.h"
 #include "mozilla/dom/ToJSValue.h"
 #include "mozilla/Endian.h"
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::gl;
 using namespace mozilla::gfx;
 static bool BaseTypeAndSizeFromUniformType(GLenum uType, GLenum *baseType, GLint *unitSize);
 const WebGLRectangleObject*
 WebGLContext::CurValidFBRectObject() const
 {
     const WebGLRectangleObject* rect = nullptr;
     if (mBoundFramebuffer) {
         // We don't really need to ask the driver.
         // Use 'precheck' to just check that our internal state looks good.
         GLenum precheckStatus = mBoundFramebuffer->PrecheckFramebufferStatus();
         if (precheckStatus == LOCAL_GL_FRAMEBUFFER_COMPLETE)
             rect = &mBoundFramebuffer->RectangleObject();
     } else {
         rect = static_cast<const WebGLRectangleObject*>(this);
     }
     return rect;
 }
 //
 //  WebGL API
 //
 void
 WebGLContext::ActiveTexture(GLenum texture)
 {
     if (IsContextLost())
         return;
     if (texture < LOCAL_GL_TEXTURE0 ||
         texture >= LOCAL_GL_TEXTURE0 + uint32_t(mGLMaxTextureUnits))
     {
         return ErrorInvalidEnum(
             "ActiveTexture: texture unit %d out of range. "
             "Accepted values range from TEXTURE0 to TEXTURE0 + %d. "
             "Notice that TEXTURE0 != 0.",
             texture, mGLMaxTextureUnits);
     }
     MakeContextCurrent();
     mActiveTexture = texture - LOCAL_GL_TEXTURE0;
     gl->fActiveTexture(texture);
 }
 void
 WebGLContext::AttachShader(WebGLProgram *program, WebGLShader *shader)
 {
     if (IsContextLost())
         return;
     if (!ValidateObject("attachShader: program", program) ||
         !ValidateObject("attachShader: shader", shader))
         return;
     // Per GLSL ES 2.0, we can only have one of each type of shader
     // attached.  This renders the next test somewhat moot, but we'll
     // leave it for when we support more than one shader of each type.
     if (program->HasAttachedShaderOfType(shader->ShaderType()))
         return ErrorInvalidOperation("attachShader: only one of each type of shader may be attached to a program");
     if (!program->AttachShader(shader))
         return ErrorInvalidOperation("attachShader: shader is already attached");
 }
 void
 WebGLContext::BindAttribLocation(WebGLProgram *prog, GLuint location,
                                  const nsAString& name)
 {
     if (IsContextLost())
         return;
     if (!ValidateObject("bindAttribLocation: program", prog))
         return;
     GLuint progname = prog->GLName();
     if (!ValidateGLSLVariableName(name, "bindAttribLocation"))
         return;
     if (!ValidateAttribIndex(location, "bindAttribLocation"))
         return;
     NS_LossyConvertUTF16toASCII cname(name);
     nsCString mappedName;
     prog->MapIdentifier(cname, &mappedName);
     MakeContextCurrent();
     gl->fBindAttribLocation(progname, location, mappedName.get());
 }
 void
 WebGLContext::BindFramebuffer(GLenum target, WebGLFramebuffer *wfb)
 {
     if (IsContextLost())
         return;
     if (target != LOCAL_GL_FRAMEBUFFER)
         return ErrorInvalidEnum("bindFramebuffer: target must be GL_FRAMEBUFFER");
     if (!ValidateObjectAllowDeletedOrNull("bindFramebuffer", wfb))
         return;
     // silently ignore a deleted frame buffer
     if (wfb && wfb->IsDeleted())
         return;
     MakeContextCurrent();
     if (!wfb) {
         gl->fBindFramebuffer(target, 0);
     } else {
         GLuint framebuffername = wfb->GLName();
         gl->fBindFramebuffer(target, framebuffername);
         wfb->SetHasEverBeenBound(true);
     }
     mBoundFramebuffer = wfb;
 }
 void
 WebGLContext::BindRenderbuffer(GLenum target, WebGLRenderbuffer *wrb)
 {
     if (IsContextLost())
         return;
     if (target != LOCAL_GL_RENDERBUFFER)
         return ErrorInvalidEnumInfo("bindRenderbuffer: target", target);
     if (!ValidateObjectAllowDeletedOrNull("bindRenderbuffer", wrb))
         return;
     // silently ignore a deleted buffer
     if (wrb && wrb->IsDeleted())
         return;
     if (wrb)
         wrb->SetHasEverBeenBound(true);
     MakeContextCurrent();
     // Sometimes we emulate renderbuffers (depth-stencil emu), so there's not
     // always a 1-1 mapping from `wrb` to GL name. Just have `wrb` handle it.
     if (wrb) {
         wrb->BindRenderbuffer();
     } else {
         gl->fBindRenderbuffer(target, 0);
     }
     mBoundRenderbuffer = wrb;
 }
 void
 WebGLContext::BindTexture(GLenum target, WebGLTexture *newTex)
 {
     if (IsContextLost())
         return;
      if (!ValidateObjectAllowDeletedOrNull("bindTexture", newTex))
         return;
     // silently ignore a deleted texture
     if (newTex && newTex->IsDeleted())
         return;
     WebGLRefPtr<WebGLTexture>* currentTexPtr = nullptr;
     if (target == LOCAL_GL_TEXTURE_2D) {
         currentTexPtr = &mBound2DTextures[mActiveTexture];
     } else if (target == LOCAL_GL_TEXTURE_CUBE_MAP) {
         currentTexPtr = &mBoundCubeMapTextures[mActiveTexture];
     } else {
         return ErrorInvalidEnumInfo("bindTexture: target", target);
     }
     WebGLTextureFakeBlackStatus currentTexFakeBlackStatus = WebGLTextureFakeBlackStatus::NotNeeded;
     if (*currentTexPtr) {
         currentTexFakeBlackStatus = (*currentTexPtr)->ResolvedFakeBlackStatus();
     }
     WebGLTextureFakeBlackStatus newTexFakeBlackStatus = WebGLTextureFakeBlackStatus::NotNeeded;
     if (newTex) {
         newTexFakeBlackStatus = newTex->ResolvedFakeBlackStatus();
     }
     *currentTexPtr = newTex;
     if (currentTexFakeBlackStatus != newTexFakeBlackStatus) {
         SetFakeBlackStatus(WebGLContextFakeBlackStatus::Unknown);
     }
     MakeContextCurrent();
     if (newTex)
         newTex->Bind(target);
     else
         gl->fBindTexture(target, 0 /* == texturename */);
 }
 void WebGLContext::BlendEquation(GLenum mode)
 {
     if (IsContextLost())
         return;
     if (!ValidateBlendEquationEnum(mode, "blendEquation: mode"))
         return;
     MakeContextCurrent();
     gl->fBlendEquation(mode);
 }
 void WebGLContext::BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
     if (IsContextLost())
         return;
     if (!ValidateBlendEquationEnum(modeRGB, "blendEquationSeparate: modeRGB") ||
         !ValidateBlendEquationEnum(modeAlpha, "blendEquationSeparate: modeAlpha"))
         return;
     MakeContextCurrent();
     gl->fBlendEquationSeparate(modeRGB, modeAlpha);
 }
 void WebGLContext::BlendFunc(GLenum sfactor, GLenum dfactor)
 {
     if (IsContextLost())
         return;
     if (!ValidateBlendFuncSrcEnum(sfactor, "blendFunc: sfactor") ||
         !ValidateBlendFuncDstEnum(dfactor, "blendFunc: dfactor"))
         return;
     if (!ValidateBlendFuncEnumsCompatibility(sfactor, dfactor, "blendFuncSeparate: srcRGB and dstRGB"))
         return;
     MakeContextCurrent();
     gl->fBlendFunc(sfactor, dfactor);
 }
 void
 WebGLContext::BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB,
                                 GLenum srcAlpha, GLenum dstAlpha)
 {
     if (IsContextLost())
         return;
     if (!ValidateBlendFuncSrcEnum(srcRGB, "blendFuncSeparate: srcRGB") ||
         !ValidateBlendFuncSrcEnum(srcAlpha, "blendFuncSeparate: srcAlpha") ||
         !ValidateBlendFuncDstEnum(dstRGB, "blendFuncSeparate: dstRGB") ||
         !ValidateBlendFuncDstEnum(dstAlpha, "blendFuncSeparate: dstAlpha"))
         return;
     // note that we only check compatibity for the RGB enums, no need to for the Alpha enums, see
     // "Section 6.8 forgetting to mention alpha factors?" thread on the public_webgl mailing list
     if (!ValidateBlendFuncEnumsCompatibility(srcRGB, dstRGB, "blendFuncSeparate: srcRGB and dstRGB"))
         return;
     MakeContextCurrent();
     gl->fBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 GLenum
 WebGLContext::CheckFramebufferStatus(GLenum target)
 {
     if (IsContextLost())
         return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
     if (target != LOCAL_GL_FRAMEBUFFER) {
         ErrorInvalidEnum("checkFramebufferStatus: target must be FRAMEBUFFER");
         return 0;
     }
     if (!mBoundFramebuffer)
         return LOCAL_GL_FRAMEBUFFER_COMPLETE;
     return mBoundFramebuffer->CheckFramebufferStatus();
 }
 void
 WebGLContext::CopyTexSubImage2D_base(GLenum target,
                                      GLint level,
                                      GLenum internalformat,
                                      GLint xoffset,
                                      GLint yoffset,
                                      GLint x,
                                      GLint y,
                                      GLsizei width,
                                      GLsizei height,
                                      bool sub)
 {
     const WebGLRectangleObject* framebufferRect = CurValidFBRectObject();
     GLsizei framebufferWidth = framebufferRect ? framebufferRect->Width() : 0;
     GLsizei framebufferHeight = framebufferRect ? framebufferRect->Height() : 0;
     const char* info = sub ? "copyTexSubImage2D" : "copyTexImage2D";
     WebGLTexImageFunc func = sub ? WebGLTexImageFunc::CopyTexSubImage : WebGLTexImageFunc::CopyTexImage;
     // TODO: This changes with color_buffer_float. Reassess when the
     // patch lands.
     if (!ValidateTexImage(2, target, level, internalformat,
                           xoffset, yoffset, 0,
                           width, height, 0,
 , internalformat, LOCAL_GL_UNSIGNED_BYTE,
                           func))
     {
         return;
     }
     MakeContextCurrent();
     WebGLTexture *tex = activeBoundTextureForTarget(target);
     if (!tex)
         return ErrorInvalidOperation("%s: no texture is bound to this target");
     if (CanvasUtils::CheckSaneSubrectSize(x, y, width, height, framebufferWidth, framebufferHeight)) {
         if (sub)
             gl->fCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
         else
             gl->fCopyTexImage2D(target, level, internalformat, x, y, width, height, 0);
     } else {
         // the rect doesn't fit in the framebuffer
         /*** first, we initialize the texture as black ***/
         // first, compute the size of the buffer we should allocate to initialize the texture as black
         if (!ValidateTexInputData(LOCAL_GL_UNSIGNED_BYTE, -1, func))
             return;
         uint32_t texelSize = GetBitsPerTexel(internalformat, LOCAL_GL_UNSIGNED_BYTE) / 8;
         CheckedUint32 checked_neededByteLength =
             GetImageSize(height, width, texelSize, mPixelStoreUnpackAlignment);
         if (!checked_neededByteLength.isValid())
             return ErrorInvalidOperation("%s: integer overflow computing the needed buffer size", info);
         uint32_t bytesNeeded = checked_neededByteLength.value();
         // now that the size is known, create the buffer
         // We need some zero pages, because GL doesn't guarantee the
         // contents of a texture allocated with nullptr data.
         // Hopefully calloc will just mmap zero pages here.
         void* tempZeroData = calloc(1, bytesNeeded);
         if (!tempZeroData)
             return ErrorOutOfMemory("%s: could not allocate %d bytes (for zero fill)", info, bytesNeeded);
         // now initialize the texture as black
         if (sub)
             gl->fTexSubImage2D(target, level, 0, 0, width, height,
                                internalformat, LOCAL_GL_UNSIGNED_BYTE, tempZeroData);
         else
             gl->fTexImage2D(target, level, internalformat, width, height,
 , internalformat, LOCAL_GL_UNSIGNED_BYTE, tempZeroData);
         free(tempZeroData);
         // if we are completely outside of the framebuffer, we can exit now with our black texture
         if (   x >= framebufferWidth
             || x+width <= 0
             || y >= framebufferHeight
             || y+height <= 0)
         {
             // we are completely outside of range, can exit now with buffer filled with zeros
             return DummyFramebufferOperation(info);
         }
         GLint   actual_x             = clamped(x, 0, framebufferWidth);
         GLint   actual_x_plus_width  = clamped(x + width, 0, framebufferWidth);
         GLsizei actual_width   = actual_x_plus_width  - actual_x;
         GLint   actual_xoffset = xoffset + actual_x - x;
         GLint   actual_y             = clamped(y, 0, framebufferHeight);
         GLint   actual_y_plus_height = clamped(y + height, 0, framebufferHeight);
         GLsizei actual_height  = actual_y_plus_height - actual_y;
         GLint   actual_yoffset = yoffset + actual_y - y;
         gl->fCopyTexSubImage2D(target, level, actual_xoffset, actual_yoffset, actual_x, actual_y, actual_width, actual_height);
     }
 }
 void
 WebGLContext::CopyTexImage2D(GLenum target,
                              GLint level,
                              GLenum internalformat,
                              GLint x,
                              GLint y,
                              GLsizei width,
                              GLsizei height,
                              GLint border)
 {
     if (IsContextLost())
         return;
     // copyTexImage2D only generates textures with type = UNSIGNED_BYTE
     const WebGLTexImageFunc func = WebGLTexImageFunc::CopyTexImage;
     const GLenum format = internalformat; // WebGL/ES Format
     const GLenum type = LOCAL_GL_UNSIGNED_BYTE; // WebGL/ES Format
     if (!ValidateTexImage(2, target, level, format,
 , 0, 0,
                           width, height, 0,
                           border, format, type,
                           func))
     {
         return;
     }
     if (mBoundFramebuffer) {
         if (!mBoundFramebuffer->CheckAndInitializeAttachments())
             return ErrorInvalidFramebufferOperation("copyTexImage2D: incomplete framebuffer");
         GLenum readPlaneBits = LOCAL_GL_COLOR_BUFFER_BIT;
         if (!mBoundFramebuffer->HasCompletePlanes(readPlaneBits)) {
             return ErrorInvalidOperation("copyTexImage2D: Read source attachment doesn't have the"
                                          " correct color/depth/stencil type.");
         }
     } else {
       ClearBackbufferIfNeeded();
     }
     bool texFormatRequiresAlpha = format == LOCAL_GL_RGBA ||
                                   format == LOCAL_GL_ALPHA ||
                                   format == LOCAL_GL_LUMINANCE_ALPHA;
     bool fboFormatHasAlpha = mBoundFramebuffer ? mBoundFramebuffer->ColorAttachment(0).HasAlpha()
                                                : bool(gl->GetPixelFormat().alpha > 0);
     if (texFormatRequiresAlpha && !fboFormatHasAlpha)
         return ErrorInvalidOperation("copyTexImage2D: texture format requires an alpha channel "
                                      "but the framebuffer doesn't have one");
     // check if the memory size of this texture may change with this call
     bool sizeMayChange = true;
     WebGLTexture* tex = activeBoundTextureForTarget(target);
     if (tex->HasImageInfoAt(target, level)) {
         const WebGLTexture::ImageInfo& imageInfo = tex->ImageInfoAt(target, level);
         sizeMayChange = width != imageInfo.Width() ||
                         height != imageInfo.Height() ||
                         format != imageInfo.WebGLFormat() ||
                         type != imageInfo.WebGLType();
     }
     if (sizeMayChange)
         GetAndFlushUnderlyingGLErrors();
     CopyTexSubImage2D_base(target, level, format, 0, 0, x, y, width, height, false);
     if (sizeMayChange) {
         GLenum error = GetAndFlushUnderlyingGLErrors();
         if (error) {
             GenerateWarning("copyTexImage2D generated error %s", ErrorName(error));
             return;
         }
     }
     tex->SetImageInfo(target, level, width, height, format, type,
                       WebGLImageDataStatus::InitializedImageData);
 }
 void
 WebGLContext::CopyTexSubImage2D(GLenum target,
                                 GLint level,
                                 GLint xoffset,
                                 GLint yoffset,
                                 GLint x,
                                 GLint y,
                                 GLsizei width,
                                 GLsizei height)
 {
     if (IsContextLost())
         return;
     switch (target) {
         case LOCAL_GL_TEXTURE_2D:
         case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X:
         case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
         case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
         case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
         case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
         case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
             break;
         default:
             return ErrorInvalidEnumInfo("copyTexSubImage2D: target", target);
     }
     if (level < 0)
         return ErrorInvalidValue("copyTexSubImage2D: level may not be negative");
     GLsizei maxTextureSize = MaxTextureSizeForTarget(target);
     if (!(maxTextureSize >> level))
         return ErrorInvalidValue("copyTexSubImage2D: 2^level exceeds maximum texture size");
     if (width < 0 || height < 0)
         return ErrorInvalidValue("copyTexSubImage2D: width and height may not be negative");
     if (xoffset < 0 || yoffset < 0)
         return ErrorInvalidValue("copyTexSubImage2D: xoffset and yoffset may not be negative");
     WebGLTexture *tex = activeBoundTextureForTarget(target);
     if (!tex)
         return ErrorInvalidOperation("copyTexSubImage2D: no texture bound to this target");
     if (!tex->HasImageInfoAt(target, level))
         return ErrorInvalidOperation("copyTexSubImage2D: no texture image previously defined for this level and face");
     const WebGLTexture::ImageInfo &imageInfo = tex->ImageInfoAt(target, level);
     GLsizei texWidth = imageInfo.Width();
     GLsizei texHeight = imageInfo.Height();
     if (xoffset + width > texWidth || xoffset + width < 0)
       return ErrorInvalidValue("copyTexSubImage2D: xoffset+width is too large");
     if (yoffset + height > texHeight || yoffset + height < 0)
       return ErrorInvalidValue("copyTexSubImage2D: yoffset+height is too large");
     GLenum webGLFormat = imageInfo.WebGLFormat();
     if (IsGLDepthFormat(webGLFormat) || IsGLDepthStencilFormat(webGLFormat))
         return ErrorInvalidOperation("copyTexSubImage2D: a base internal format of DEPTH_COMPONENT or DEPTH_STENCIL isn't supported");
     if (mBoundFramebuffer) {
         if (!mBoundFramebuffer->CheckAndInitializeAttachments())
             return ErrorInvalidFramebufferOperation("copyTexSubImage2D: incomplete framebuffer");
         GLenum readPlaneBits = LOCAL_GL_COLOR_BUFFER_BIT;
         if (!mBoundFramebuffer->HasCompletePlanes(readPlaneBits)) {
             return ErrorInvalidOperation("copyTexSubImage2D: Read source attachment doesn't have the"
                                          " correct color/depth/stencil type.");
         }
     } else {
         ClearBackbufferIfNeeded();
     }
     bool texFormatRequiresAlpha = FormatHasAlpha(webGLFormat);
     bool fboFormatHasAlpha = mBoundFramebuffer ? mBoundFramebuffer->ColorAttachment(0).HasAlpha()
                                                : bool(gl->GetPixelFormat().alpha > 0);
     if (texFormatRequiresAlpha && !fboFormatHasAlpha)
         return ErrorInvalidOperation("copyTexSubImage2D: texture format requires an alpha channel "
                                      "but the framebuffer doesn't have one");
     if (imageInfo.HasUninitializedImageData()) {
         tex->DoDeferredImageInitialization(target, level);
     }
     return CopyTexSubImage2D_base(target, level, webGLFormat, xoffset, yoffset, x, y, width, height, true);
 }
 already_AddRefed<WebGLProgram>
 WebGLContext::CreateProgram()
 {
     if (IsContextLost())
         return nullptr;
     nsRefPtr<WebGLProgram> globj = new WebGLProgram(this);
     return globj.forget();
 }
 already_AddRefed<WebGLShader>
 WebGLContext::CreateShader(GLenum type)
 {
     if (IsContextLost())
         return nullptr;
     if (type != LOCAL_GL_VERTEX_SHADER &&
         type != LOCAL_GL_FRAGMENT_SHADER)
     {
         ErrorInvalidEnumInfo("createShader: type", type);
         return nullptr;
     }
     nsRefPtr<WebGLShader> shader = new WebGLShader(this, type);
     return shader.forget();
 }
 void
 WebGLContext::CullFace(GLenum face)
 {
     if (IsContextLost())
         return;
     if (!ValidateFaceEnum(face, "cullFace"))
         return;
     MakeContextCurrent();
     gl->fCullFace(face);
 }
 void
 WebGLContext::DeleteFramebuffer(WebGLFramebuffer* fbuf)
 {
     if (IsContextLost())
         return;
     if (!ValidateObjectAllowDeletedOrNull("deleteFramebuffer", fbuf))
         return;
     if (!fbuf || fbuf->IsDeleted())
         return;
     fbuf->RequestDelete();
     if (mBoundFramebuffer == fbuf)
         BindFramebuffer(LOCAL_GL_FRAMEBUFFER,
                         static_cast<WebGLFramebuffer*>(nullptr));
 }
 void
 WebGLContext::DeleteRenderbuffer(WebGLRenderbuffer *rbuf)
 {
     if (IsContextLost())
         return;
     if (!ValidateObjectAllowDeletedOrNull("deleteRenderbuffer", rbuf))
         return;
     if (!rbuf || rbuf->IsDeleted())
         return;
     if (mBoundFramebuffer)
         mBoundFramebuffer->DetachRenderbuffer(rbuf);
     // Invalidate framebuffer status cache
     rbuf->NotifyFBsStatusChanged();
     if (mBoundRenderbuffer == rbuf)
         BindRenderbuffer(LOCAL_GL_RENDERBUFFER,
                          static_cast<WebGLRenderbuffer*>(nullptr));
     rbuf->RequestDelete();
 }
 void
 WebGLContext::DeleteTexture(WebGLTexture *tex)
 {
     if (IsContextLost())
         return;
     if (!ValidateObjectAllowDeletedOrNull("deleteTexture", tex))
         return;
     if (!tex || tex->IsDeleted())
         return;
     if (mBoundFramebuffer)
         mBoundFramebuffer->DetachTexture(tex);
     // Invalidate framebuffer status cache
     tex->NotifyFBsStatusChanged();
     GLuint activeTexture = mActiveTexture;
     for (int32_t i = 0; i < mGLMaxTextureUnits; i++) {
         if ((tex->Target() == LOCAL_GL_TEXTURE_2D && mBound2DTextures[i] == tex) ||
             (tex->Target() == LOCAL_GL_TEXTURE_CUBE_MAP && mBoundCubeMapTextures[i] == tex))
         {
             ActiveTexture(LOCAL_GL_TEXTURE0 + i);
             BindTexture(tex->Target(), static_cast<WebGLTexture*>(nullptr));
         }
     }
     ActiveTexture(LOCAL_GL_TEXTURE0 + activeTexture);
     tex->RequestDelete();
 }
 void
 WebGLContext::DeleteProgram(WebGLProgram *prog)
 {
     if (IsContextLost())
         return;
     if (!ValidateObjectAllowDeletedOrNull("deleteProgram", prog))
         return;
     if (!prog || prog->IsDeleted())
         return;
     prog->RequestDelete();
 }
 void
 WebGLContext::DeleteShader(WebGLShader *shader)
 {
     if (IsContextLost())
         return;
     if (!ValidateObjectAllowDeletedOrNull("deleteShader", shader))
         return;
     if (!shader || shader->IsDeleted())
         return;
     shader->RequestDelete();
 }
 void
 WebGLContext::DetachShader(WebGLProgram *program, WebGLShader *shader)
 {
     if (IsContextLost())
         return;
     if (!ValidateObject("detachShader: program", program) ||
         // it's valid to attempt to detach a deleted shader, since it's
         // still a shader
         !ValidateObjectAllowDeleted("detashShader: shader", shader))
         return;
     if (!program->DetachShader(shader))
         return ErrorInvalidOperation("detachShader: shader is not attached");
 }
 void
 WebGLContext::DepthFunc(GLenum func)
 {
     if (IsContextLost())
         return;
     if (!ValidateComparisonEnum(func, "depthFunc"))
         return;
     MakeContextCurrent();
     gl->fDepthFunc(func);
 }
 void
 WebGLContext::DepthRange(GLfloat zNear, GLfloat zFar)
 {
     if (IsContextLost())
         return;
     if (zNear > zFar)
         return ErrorInvalidOperation("depthRange: the near value is greater than the far value!");
     MakeContextCurrent();
     gl->fDepthRange(zNear, zFar);
 }
 void
 WebGLContext::FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum rbtarget, WebGLRenderbuffer *wrb)
 {
     if (IsContextLost())
         return;
     if (!mBoundFramebuffer)
         return ErrorInvalidOperation("framebufferRenderbuffer: cannot modify framebuffer 0");
     return mBoundFramebuffer->FramebufferRenderbuffer(target, attachment, rbtarget, wrb);
 }
 void
 WebGLContext::FramebufferTexture2D(GLenum target,
                                    GLenum attachment,
                                    GLenum textarget,
                                    WebGLTexture *tobj,
                                    GLint level)
 {
     if (IsContextLost())
         return;
     if (!mBoundFramebuffer)
         return ErrorInvalidOperation("framebufferRenderbuffer: cannot modify framebuffer 0");
     return mBoundFramebuffer->FramebufferTexture2D(target, attachment, textarget, tobj, level);
 }
 void
 WebGLContext::FrontFace(GLenum mode)
 {
     if (IsContextLost())
         return;
     switch (mode) {
         case LOCAL_GL_CW:
         case LOCAL_GL_CCW:
             break;
         default:
             return ErrorInvalidEnumInfo("frontFace: mode", mode);
     }
     MakeContextCurrent();
     gl->fFrontFace(mode);
 }
 already_AddRefed<WebGLActiveInfo>
 WebGLContext::GetActiveAttrib(WebGLProgram *prog, uint32_t index)
 {
     if (IsContextLost())
         return nullptr;
     if (!ValidateObject("getActiveAttrib: program", prog))
         return nullptr;
     MakeContextCurrent();
     GLint len = 0;
     GLuint progname = prog->GLName();;
     gl->fGetProgramiv(progname, LOCAL_GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &len);
     if (len == 0)
         return nullptr;
     nsAutoArrayPtr<char> name(new char[len]);
     GLint attrsize = 0;
     GLuint attrtype = 0;
     gl->fGetActiveAttrib(progname, index, len, &len, &attrsize, &attrtype, name);
     if (attrsize == 0 || attrtype == 0) {
         return nullptr;
     }
     nsCString reverseMappedName;
     prog->ReverseMapIdentifier(nsDependentCString(name), &reverseMappedName);
     nsRefPtr<WebGLActiveInfo> retActiveInfo =
         new WebGLActiveInfo(attrsize, attrtype, reverseMappedName);
     return retActiveInfo.forget();
 }
 void
 WebGLContext::GenerateMipmap(GLenum target)
 {
     if (IsContextLost())
         return;
     if (!ValidateTextureTargetEnum(target, "generateMipmap"))
         return;
     WebGLTexture *tex = activeBoundTextureForTarget(target);
     if (!tex)
         return ErrorInvalidOperation("generateMipmap: No texture is bound to this target.");
     GLenum imageTarget = (target == LOCAL_GL_TEXTURE_2D) ? LOCAL_GL_TEXTURE_2D
                                                          : LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X;
     if (!tex->HasImageInfoAt(imageTarget, 0))
     {
         return ErrorInvalidOperation("generateMipmap: Level zero of texture is not defined.");
     }
     if (!tex->IsFirstImagePowerOfTwo())
         return ErrorInvalidOperation("generateMipmap: Level zero of texture does not have power-of-two width and height.");
     GLenum webGLFormat = tex->ImageInfoAt(imageTarget, 0).WebGLFormat();
     if (IsTextureFormatCompressed(webGLFormat))
         return ErrorInvalidOperation("generateMipmap: Texture data at level zero is compressed.");
     if (IsExtensionEnabled(WebGLExtensionID::WEBGL_depth_texture) &&
         (IsGLDepthFormat(webGLFormat) || IsGLDepthStencilFormat(webGLFormat)))
     {
         return ErrorInvalidOperation("generateMipmap: "
                                      "A texture that has a base internal format of "
                                      "DEPTH_COMPONENT or DEPTH_STENCIL isn't supported");
     }
     if (!tex->AreAllLevel0ImageInfosEqual())
         return ErrorInvalidOperation("generateMipmap: The six faces of this cube map have different dimensions, format, or type.");
     tex->SetGeneratedMipmap();
     MakeContextCurrent();
     if (gl->WorkAroundDriverBugs()) {
         // bug 696495 - to work around failures in the texture-mips.html test on various drivers, we
         // set the minification filter before calling glGenerateMipmap. This should not carry a significant performance
         // overhead so we do it unconditionally.
         //
         // note that the choice of GL_NEAREST_MIPMAP_NEAREST really matters. See Chromium bug 101105.
         gl->fTexParameteri(target, LOCAL_GL_TEXTURE_MIN_FILTER, LOCAL_GL_NEAREST_MIPMAP_NEAREST);
         gl->fGenerateMipmap(target);
         gl->fTexParameteri(target, LOCAL_GL_TEXTURE_MIN_FILTER, tex->MinFilter());
     } else {
         gl->fGenerateMipmap(target);
     }
 }
 already_AddRefed<WebGLActiveInfo>
 WebGLContext::GetActiveUniform(WebGLProgram *prog, uint32_t index)
 {
     if (IsContextLost())
         return nullptr;
     if (!ValidateObject("getActiveUniform: program", prog))
         return nullptr;
     MakeContextCurrent();
     GLint len = 0;
     GLuint progname = prog->GLName();
     gl->fGetProgramiv(progname, LOCAL_GL_ACTIVE_UNIFORM_MAX_LENGTH, &len);
     if (len == 0)
         return nullptr;
     nsAutoArrayPtr<char> name(new char[len]);
     GLint usize = 0;
     GLuint utype = 0;
     gl->fGetActiveUniform(progname, index, len, &len, &usize, &utype, name);
     if (len == 0 || usize == 0 || utype == 0) {
         return nullptr;
     }
     nsCString reverseMappedName;
     prog->ReverseMapIdentifier(nsDependentCString(name), &reverseMappedName);
     // OpenGL ES 2.0 specifies that if foo is a uniform array, GetActiveUniform returns its name as "foo[0]".
     // See section 2.10 page 35 in the OpenGL ES 2.0.24 specification:
     //
     // > If the active uniform is an array, the uniform name returned in name will always
     // > be the name of the uniform array appended with "[0]".
     //
     // There is no such requirement in the OpenGL (non-ES) spec and indeed we have OpenGL implementations returning
     // "foo" instead of "foo[0]". So, when implementing WebGL on top of desktop OpenGL, we must check if the
     // returned name ends in [0], and if it doesn't, append that.
     //
     // In principle we don't need to do that on OpenGL ES, but this is such a tricky difference between the ES and non-ES
     // specs that it seems probable that some ES implementers will overlook it. Since the work-around is quite cheap,
     // we do it unconditionally.
     if (usize > 1 && reverseMappedName.CharAt(reverseMappedName.Length()-1) != ']')
         reverseMappedName.AppendLiteral("[0]");
     nsRefPtr<WebGLActiveInfo> retActiveInfo =
         new WebGLActiveInfo(usize, utype, reverseMappedName);
     return retActiveInfo.forget();
 }
 void
 WebGLContext::GetAttachedShaders(WebGLProgram *prog,
                                  Nullable< nsTArray<WebGLShader*> > &retval)
 {
     retval.SetNull();
     if (IsContextLost())
         return;
     if (!ValidateObjectAllowNull("getAttachedShaders", prog))
         return;
     MakeContextCurrent();
     if (!prog) {
         retval.SetNull();
         ErrorInvalidValue("getAttachedShaders: invalid program");
     } else if (prog->AttachedShaders().Length() == 0) {
         retval.SetValue().TruncateLength(0);
     } else {
         retval.SetValue().AppendElements(prog->AttachedShaders());
     }
 }
 GLint
 WebGLContext::GetAttribLocation(WebGLProgram *prog, const nsAString& name)
 {
     if (IsContextLost())
         return -1;
     if (!ValidateObject("getAttribLocation: program", prog))
         return -1;
     if (!ValidateGLSLVariableName(name, "getAttribLocation"))
         return -1;
     NS_LossyConvertUTF16toASCII cname(name);
     nsCString mappedName;
     prog->MapIdentifier(cname, &mappedName);
     GLuint progname = prog->GLName();
     MakeContextCurrent();
     return gl->fGetAttribLocation(progname, mappedName.get());
 }
 JS::Value
 WebGLContext::GetBufferParameter(GLenum target, GLenum pname)
 {
     if (IsContextLost())
         return JS::NullValue();
     if (target != LOCAL_GL_ARRAY_BUFFER && target != LOCAL_GL_ELEMENT_ARRAY_BUFFER) {
         ErrorInvalidEnumInfo("getBufferParameter: target", target);
         return JS::NullValue();
     }
     MakeContextCurrent();
     switch (pname) {
         case LOCAL_GL_BUFFER_SIZE:
         case LOCAL_GL_BUFFER_USAGE:
         {
             GLint i = 0;
             gl->fGetBufferParameteriv(target, pname, &i);
             if (pname == LOCAL_GL_BUFFER_SIZE) {
                 return JS::Int32Value(i);
             }
             MOZ_ASSERT(pname == LOCAL_GL_BUFFER_USAGE);
             return JS::NumberValue(uint32_t(i));
         }
             break;
         default:
             ErrorInvalidEnumInfo("getBufferParameter: parameter", pname);
     }
     return JS::NullValue();
 }
 JS::Value
 WebGLContext::GetFramebufferAttachmentParameter(JSContext* cx,
                                                 GLenum target,
                                                 GLenum attachment,
                                                 GLenum pname,
                                                 ErrorResult& rv)
 {
     if (IsContextLost())
         return JS::NullValue();
     if (target != LOCAL_GL_FRAMEBUFFER) {
         ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: target", target);
         return JS::NullValue();
     }
     if (!mBoundFramebuffer) {
         ErrorInvalidOperation("getFramebufferAttachmentParameter: cannot query framebuffer 0");
         return JS::NullValue();
     }
     if (attachment != LOCAL_GL_DEPTH_ATTACHMENT &&
         attachment != LOCAL_GL_STENCIL_ATTACHMENT &&
         attachment != LOCAL_GL_DEPTH_STENCIL_ATTACHMENT)
     {
         if (IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers))
         {
             if (attachment < LOCAL_GL_COLOR_ATTACHMENT0 ||
                 attachment >= GLenum(LOCAL_GL_COLOR_ATTACHMENT0 + mGLMaxColorAttachments))
             {
                 ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: attachment", attachment);
                 return JS::NullValue();
             }
             mBoundFramebuffer->EnsureColorAttachments(attachment - LOCAL_GL_COLOR_ATTACHMENT0);
         }
         else if (attachment != LOCAL_GL_COLOR_ATTACHMENT0)
         {
             ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: attachment", attachment);
             return JS::NullValue();
         }
     }
     MakeContextCurrent();
     const WebGLFramebuffer::Attachment& fba = mBoundFramebuffer->GetAttachment(attachment);
     if (fba.Renderbuffer()) {
         switch (pname) {
             case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT:
                 if (IsExtensionEnabled(WebGLExtensionID::EXT_sRGB)) {
                     const GLenum internalFormat = fba.Renderbuffer()->InternalFormat();
                     return (internalFormat == LOCAL_GL_SRGB_EXT ||
                             internalFormat == LOCAL_GL_SRGB_ALPHA_EXT ||
                             internalFormat == LOCAL_GL_SRGB8_ALPHA8_EXT) ?
                         JS::NumberValue(uint32_t(LOCAL_GL_SRGB_EXT)) :
                         JS::NumberValue(uint32_t(LOCAL_GL_LINEAR));
                 }
                 break;
             case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
                 return JS::NumberValue(uint32_t(LOCAL_GL_RENDERBUFFER));
             case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
                 return WebGLObjectAsJSValue(cx, fba.Renderbuffer(), rv);
             case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: {
                 if (!IsExtensionEnabled(WebGLExtensionID::EXT_color_buffer_half_float) &&
                     !IsExtensionEnabled(WebGLExtensionID::WEBGL_color_buffer_float))
                 {
                     break;
                 }
                 if (attachment == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
                     ErrorInvalidOperation("getFramebufferAttachmentParameter: Cannot get component"
                                           " type of a depth-stencil attachment.");
                     return JS::NullValue();
                 }
                 if (!fba.IsComplete())
                     return JS::NumberValue(uint32_t(LOCAL_GL_NONE));
                 uint32_t ret = LOCAL_GL_NONE;
                 switch (fba.Renderbuffer()->InternalFormat()) {
                 case LOCAL_GL_RGBA4:
                 case LOCAL_GL_RGB5_A1:
                 case LOCAL_GL_RGB565:
                 case LOCAL_GL_SRGB8_ALPHA8:
                     ret = LOCAL_GL_UNSIGNED_NORMALIZED;
                     break;
                 case LOCAL_GL_RGB16F:
                 case LOCAL_GL_RGBA16F:
                 case LOCAL_GL_RGB32F:
                 case LOCAL_GL_RGBA32F:
                     ret = LOCAL_GL_FLOAT;
                     break;
                 case LOCAL_GL_DEPTH_COMPONENT16:
                 case LOCAL_GL_STENCIL_INDEX8:
                     ret = LOCAL_GL_UNSIGNED_INT;
                     break;
                 default:
                     MOZ_ASSERT(false, "Unhandled RB component type.");
                     break;
                 }
                 return JS::NumberValue(uint32_t(ret));
             }
         }
         ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: pname", pname);
         return JS::NullValue();
     } else if (fba.Texture()) {
         switch (pname) {
              case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT:
                 if (IsExtensionEnabled(WebGLExtensionID::EXT_sRGB)) {
                     const GLenum webGLFormat =
                         fba.Texture()->ImageInfoBase().WebGLFormat();
                     return (webGLFormat == LOCAL_GL_SRGB ||
                             webGLFormat == LOCAL_GL_SRGB_ALPHA) ?
                         JS::NumberValue(uint32_t(LOCAL_GL_SRGB)) :
                         JS::NumberValue(uint32_t(LOCAL_GL_LINEAR));
                 }
                 break;
             case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
                 return JS::NumberValue(uint32_t(LOCAL_GL_TEXTURE));
             case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
                 return WebGLObjectAsJSValue(cx, fba.Texture(), rv);
             case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
                 return JS::Int32Value(fba.TexImageLevel());
             case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: {
                 GLenum face = fba.TexImageTarget();
                 if (face == LOCAL_GL_TEXTURE_2D)
                     face = 0;
                 return JS::Int32Value(face);
             }
             case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: {
                 if (!IsExtensionEnabled(WebGLExtensionID::EXT_color_buffer_half_float) &&
                     !IsExtensionEnabled(WebGLExtensionID::WEBGL_color_buffer_float))
                 {
                     break;
                 }
                 if (attachment == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
                     ErrorInvalidOperation("getFramebufferAttachmentParameter: cannot component"
                                           " type of depth-stencil attachments.");
                     return JS::NullValue();
                 }
                 if (!fba.IsComplete())
                     return JS::NumberValue(uint32_t(LOCAL_GL_NONE));
                 uint32_t ret = LOCAL_GL_NONE;
                 GLenum type = fba.Texture()->ImageInfoAt(fba.TexImageTarget(),
                                                          fba.TexImageLevel()).WebGLType();
                 switch (type) {
                 case LOCAL_GL_UNSIGNED_BYTE:
                 case LOCAL_GL_UNSIGNED_SHORT_4_4_4_4:
                 case LOCAL_GL_UNSIGNED_SHORT_5_5_5_1:
                 case LOCAL_GL_UNSIGNED_SHORT_5_6_5:
                     ret = LOCAL_GL_UNSIGNED_NORMALIZED;
                     break;
                 case LOCAL_GL_FLOAT:
                 case LOCAL_GL_HALF_FLOAT_OES:
                     ret = LOCAL_GL_FLOAT;
                     break;
                 case LOCAL_GL_UNSIGNED_SHORT:
                 case LOCAL_GL_UNSIGNED_INT:
                     ret = LOCAL_GL_UNSIGNED_INT;
                     break;
                 default:
                     MOZ_ASSERT(false, "Unhandled RB component type.");
                     break;
                 }
                 return JS::NumberValue(uint32_t(ret));
             }
         }
         ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: pname", pname);
         return JS::NullValue();
     } else {
         switch (pname) {
             case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
                 return JS::NumberValue(uint32_t(LOCAL_GL_NONE));
             default:
                 ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: pname", pname);
                 return JS::NullValue();
         }
     }
     return JS::NullValue();
 }
 JS::Value
 WebGLContext::GetRenderbufferParameter(GLenum target, GLenum pname)
 {
     if (IsContextLost())
         return JS::NullValue();
     if (target != LOCAL_GL_RENDERBUFFER) {
         ErrorInvalidEnumInfo("getRenderbufferParameter: target", target);
         return JS::NullValue();
     }
     if (!mBoundRenderbuffer) {
         ErrorInvalidOperation("getRenderbufferParameter: no render buffer is bound");
         return JS::NullValue();
     }
     MakeContextCurrent();
     switch (pname) {
         case LOCAL_GL_RENDERBUFFER_WIDTH:
         case LOCAL_GL_RENDERBUFFER_HEIGHT:
         case LOCAL_GL_RENDERBUFFER_RED_SIZE:
         case LOCAL_GL_RENDERBUFFER_GREEN_SIZE:
         case LOCAL_GL_RENDERBUFFER_BLUE_SIZE:
         case LOCAL_GL_RENDERBUFFER_ALPHA_SIZE:
         case LOCAL_GL_RENDERBUFFER_DEPTH_SIZE:
         case LOCAL_GL_RENDERBUFFER_STENCIL_SIZE:
         {
             // RB emulation means we have to ask the RB itself.
             GLint i = mBoundRenderbuffer->GetRenderbufferParameter(target, pname);
             return JS::Int32Value(i);
         }
         case LOCAL_GL_RENDERBUFFER_INTERNAL_FORMAT:
         {
             return JS::NumberValue(mBoundRenderbuffer->InternalFormat());
         }
         default:
             ErrorInvalidEnumInfo("getRenderbufferParameter: parameter", pname);
     }
     return JS::NullValue();
 }
 already_AddRefed<WebGLTexture>
 WebGLContext::CreateTexture()
 {
     if (IsContextLost())
         return nullptr;
     nsRefPtr<WebGLTexture> globj = new WebGLTexture(this);
     return globj.forget();
 }
 static GLenum
 GetAndClearError(GLenum* errorVar)
 {
     MOZ_ASSERT(errorVar);
     GLenum ret = *errorVar;
     *errorVar = LOCAL_GL_NO_ERROR;
     return ret;
 }
 GLenum
 WebGLContext::GetError()
 {
     /* WebGL 1.0: Section 5.14.3: Setting and getting state:
      *   If the context's webgl context lost flag is set, returns
      *   CONTEXT_LOST_WEBGL the first time this method is called.
      *   Afterward, returns NO_ERROR until the context has been
      *   restored.
      *
      * WEBGL_lose_context:
      *   [When this extension is enabled: ] loseContext and
      *   restoreContext are allowed to generate INVALID_OPERATION errors
      *   even when the context is lost.
      */
     if (IsContextLost()) {
         if (mEmitContextLostErrorOnce) {
             mEmitContextLostErrorOnce = false;
             return LOCAL_GL_CONTEXT_LOST;
         }
         // Don't return yet, since WEBGL_lose_contexts contradicts the
         // original spec, and allows error generation while lost.
     }
     GLenum err = GetAndClearError(&mWebGLError);
     if (err != LOCAL_GL_NO_ERROR)
         return err;
     if (IsContextLost())
         return LOCAL_GL_NO_ERROR;
     // Either no WebGL-side error, or it's already been cleared.
     // UnderlyingGL-side errors, now.
     MakeContextCurrent();
     GetAndFlushUnderlyingGLErrors();
     err = GetAndClearError(&mUnderlyingGLError);
     return err;
 }
 JS::Value
 WebGLContext::GetProgramParameter(WebGLProgram *prog, GLenum pname)
 {
     if (IsContextLost())
         return JS::NullValue();
     if (!ValidateObjectAllowDeleted("getProgramParameter: program", prog))
         return JS::NullValue();
     GLuint progname = prog->GLName();
     MakeContextCurrent();
     switch (pname) {
         case LOCAL_GL_ATTACHED_SHADERS:
         case LOCAL_GL_ACTIVE_UNIFORMS:
         case LOCAL_GL_ACTIVE_ATTRIBUTES:
         {
             GLint i = 0;
             gl->fGetProgramiv(progname, pname, &i);
             return JS::Int32Value(i);
         }
         case LOCAL_GL_DELETE_STATUS:
             return JS::BooleanValue(prog->IsDeleteRequested());
         case LOCAL_GL_LINK_STATUS:
         {
             return JS::BooleanValue(prog->LinkStatus());
         }
         case LOCAL_GL_VALIDATE_STATUS:
         {
             GLint i = 0;
 #ifdef XP_MACOSX
             // See comment in ValidateProgram below.
             if (gl->WorkAroundDriverBugs())
                 i = 1;
             else
                 gl->fGetProgramiv(progname, pname, &i);
 #else
             gl->fGetProgramiv(progname, pname, &i);
 #endif
             return JS::BooleanValue(bool(i));
         }
             break;
         default:
             ErrorInvalidEnumInfo("getProgramParameter: parameter", pname);
     }
     return JS::NullValue();
 }
 void
 WebGLContext::GetProgramInfoLog(WebGLProgram *prog, nsAString& retval)
 {
     nsAutoCString s;
     GetProgramInfoLog(prog, s);
     if (s.IsVoid())
         retval.SetIsVoid(true);
     else
         CopyASCIItoUTF16(s, retval);
 }
 void
 WebGLContext::GetProgramInfoLog(WebGLProgram *prog, nsACString& retval)
 {
     if (IsContextLost())
     {
         retval.SetIsVoid(true);
         return;
     }
     if (!ValidateObject("getProgramInfoLog: program", prog)) {
         retval.Truncate();
         return;
     }
     GLuint progname = prog->GLName();
     MakeContextCurrent();
     GLint k = -1;
     gl->fGetProgramiv(progname, LOCAL_GL_INFO_LOG_LENGTH, &k);
     if (k == -1) {
         // If GetProgramiv doesn't modify |k|,
         // it's because there was a GL error.
         // GetProgramInfoLog should return null on error. (Bug 746740)
         retval.SetIsVoid(true);
         return;
     }
     if (k == 0) {
         retval.Truncate();
         return;
     }
     retval.SetCapacity(k);
     gl->fGetProgramInfoLog(progname, k, &k, (char*) retval.BeginWriting());
     retval.SetLength(k);
 }
 // here we have to support all pnames with both int and float params.
 // See this discussion:
 //  https://www.khronos.org/webgl/public-mailing-list/archives/1008/msg00014.html
 void WebGLContext::TexParameter_base(GLenum target, GLenum pname,
                                      GLint *intParamPtr,
                                      GLfloat *floatParamPtr)
 {
     MOZ_ASSERT(intParamPtr || floatParamPtr);
     if (IsContextLost())
         return;
     GLint intParam = intParamPtr ? *intParamPtr : GLint(*floatParamPtr);
     GLfloat floatParam = floatParamPtr ? *floatParamPtr : GLfloat(*intParamPtr);
     if (!ValidateTextureTargetEnum(target, "texParameter: target"))
         return;
     WebGLTexture *tex = activeBoundTextureForTarget(target);
     if (!tex)
         return ErrorInvalidOperation("texParameter: no texture is bound to this target");
     bool pnameAndParamAreIncompatible = false;
     bool paramValueInvalid = false;
     switch (pname) {
         case LOCAL_GL_TEXTURE_MIN_FILTER:
             switch (intParam) {
                 case LOCAL_GL_NEAREST:
                 case LOCAL_GL_LINEAR:
                 case LOCAL_GL_NEAREST_MIPMAP_NEAREST:
                 case LOCAL_GL_LINEAR_MIPMAP_NEAREST:
                 case LOCAL_GL_NEAREST_MIPMAP_LINEAR:
                 case LOCAL_GL_LINEAR_MIPMAP_LINEAR:
                     tex->SetMinFilter(intParam);
                     break;
                 default:
                     pnameAndParamAreIncompatible = true;
             }
             break;
         case LOCAL_GL_TEXTURE_MAG_FILTER:
             switch (intParam) {
                 case LOCAL_GL_NEAREST:
                 case LOCAL_GL_LINEAR:
                     tex->SetMagFilter(intParam);
                     break;
                 default:
                     pnameAndParamAreIncompatible = true;
             }
             break;
         case LOCAL_GL_TEXTURE_WRAP_S:
             switch (intParam) {
                 case LOCAL_GL_CLAMP_TO_EDGE:
                 case LOCAL_GL_MIRRORED_REPEAT:
                 case LOCAL_GL_REPEAT:
                     tex->SetWrapS(intParam);
                     break;
                 default:
                     pnameAndParamAreIncompatible = true;
             }
             break;
         case LOCAL_GL_TEXTURE_WRAP_T:
             switch (intParam) {
                 case LOCAL_GL_CLAMP_TO_EDGE:
                 case LOCAL_GL_MIRRORED_REPEAT:
                 case LOCAL_GL_REPEAT:
                     tex->SetWrapT(intParam);
                     break;
                 default:
                     pnameAndParamAreIncompatible = true;
             }
             break;
         case LOCAL_GL_TEXTURE_MAX_ANISOTROPY_EXT:
             if (IsExtensionEnabled(WebGLExtensionID::EXT_texture_filter_anisotropic)) {
                 if (floatParamPtr && floatParam < 1.f)
                     paramValueInvalid = true;
                 else if (intParamPtr && intParam < 1)
                     paramValueInvalid = true;
             }
             else
                 pnameAndParamAreIncompatible = true;
             break;
         default:
             return ErrorInvalidEnumInfo("texParameter: pname", pname);
     }
     if (pnameAndParamAreIncompatible) {
         if (intParamPtr)
             return ErrorInvalidEnum("texParameteri: pname %x and param %x (decimal %d) are mutually incompatible",
                                     pname, intParam, intParam);
         else
             return ErrorInvalidEnum("texParameterf: pname %x and param %g are mutually incompatible",
                                     pname, floatParam);
     } else if (paramValueInvalid) {
         if (intParamPtr)
             return ErrorInvalidValue("texParameteri: pname %x and param %x (decimal %d) is invalid",
                                     pname, intParam, intParam);
         else
             return ErrorInvalidValue("texParameterf: pname %x and param %g is invalid",
                                     pname, floatParam);
     }
     MakeContextCurrent();
     if (intParamPtr)
         gl->fTexParameteri(target, pname, intParam);
     else
         gl->fTexParameterf(target, pname, floatParam);
 }
 JS::Value
 WebGLContext::GetTexParameter(GLenum target, GLenum pname)
 {
     if (IsContextLost())
         return JS::NullValue();
     MakeContextCurrent();
     if (!ValidateTextureTargetEnum(target, "getTexParameter: target"))
         return JS::NullValue();
     if (!activeBoundTextureForTarget(target)) {
         ErrorInvalidOperation("getTexParameter: no texture bound");
         return JS::NullValue();
     }
     switch (pname) {
         case LOCAL_GL_TEXTURE_MIN_FILTER:
         case LOCAL_GL_TEXTURE_MAG_FILTER:
         case LOCAL_GL_TEXTURE_WRAP_S:
         case LOCAL_GL_TEXTURE_WRAP_T:
         {
             GLint i = 0;
             gl->fGetTexParameteriv(target, pname, &i);
             return JS::NumberValue(uint32_t(i));
         }
         case LOCAL_GL_TEXTURE_MAX_ANISOTROPY_EXT:
             if (IsExtensionEnabled(WebGLExtensionID::EXT_texture_filter_anisotropic)) {
                 GLfloat f = 0.f;
                 gl->fGetTexParameterfv(target, pname, &f);
                 return JS::DoubleValue(f);
             }
             ErrorInvalidEnumInfo("getTexParameter: parameter", pname);
             break;
         default:
             ErrorInvalidEnumInfo("getTexParameter: parameter", pname);
     }
     return JS::NullValue();
 }
 JS::Value
 WebGLContext::GetUniform(JSContext* cx, WebGLProgram *prog,
                          WebGLUniformLocation *location)
 {
     if (IsContextLost())
         return JS::NullValue();
     if (!ValidateObject("getUniform: program", prog))
         return JS::NullValue();
     if (!ValidateObject("getUniform: location", location))
         return JS::NullValue();
     if (location->Program() != prog) {
         ErrorInvalidValue("getUniform: this uniform location corresponds to another program");
         return JS::NullValue();
     }
     if (location->ProgramGeneration() != prog->Generation()) {
         ErrorInvalidOperation("getUniform: this uniform location is obsolete since the program has been relinked");
         return JS::NullValue();
     }
     GLuint progname = prog->GLName();
     MakeContextCurrent();
     GLint uniforms = 0;
     GLint uniformNameMaxLength = 0;
     gl->fGetProgramiv(progname, LOCAL_GL_ACTIVE_UNIFORMS, &uniforms);
     gl->fGetProgramiv(progname, LOCAL_GL_ACTIVE_UNIFORM_MAX_LENGTH, &uniformNameMaxLength);
     // we now need the type info to switch between fGetUniformfv and fGetUniformiv
     // the only way to get that is to iterate through all active uniforms by index until
     // one matches the given uniform location.
     GLenum uniformType = 0;
     nsAutoArrayPtr<GLchar> uniformName(new GLchar[uniformNameMaxLength]);
     // this buffer has 16 more bytes to be able to store [index] at the end.
     nsAutoArrayPtr<GLchar> uniformNameBracketIndex(new GLchar[uniformNameMaxLength + 16]);
     GLint index;
     for (index = 0; index < uniforms; ++index) {
         GLsizei length;
         GLint size;
         gl->fGetActiveUniform(progname, index, uniformNameMaxLength, &length,
                               &size, &uniformType, uniformName);
         if (gl->fGetUniformLocation(progname, uniformName) == location->Location())
             break;
         // now we handle the case of array uniforms. In that case, fGetActiveUniform returned as 'size'
         // the biggest index used plus one, so we need to loop over that. The 0 index has already been handled above,
         // so we can start at one. For each index, we construct the string uniformName + "[" + index + "]".
         if (size > 1) {
             bool found_it = false;
             if (uniformName[length - 1] == ']') { // if uniformName ends in [0]
                 // remove the [0] at the end
                 length -= 3;
                 uniformName[length] = 0;
             }
             for (GLint arrayIndex = 1; arrayIndex < size; arrayIndex++) {
                 sprintf(uniformNameBracketIndex.get(), "%s[%d]", uniformName.get(), arrayIndex);
                 if (gl->fGetUniformLocation(progname, uniformNameBracketIndex) == location->Location()) {
                     found_it = true;
                     break;
                 }
             }
             if (found_it) break;
         }
     }
     if (index == uniforms) {
         GenerateWarning("getUniform: internal error: hit an OpenGL driver bug");
         return JS::NullValue();
     }
     GLenum baseType;
     GLint unitSize;
     if (!BaseTypeAndSizeFromUniformType(uniformType, &baseType, &unitSize)) {
         GenerateWarning("getUniform: internal error: unknown uniform type 0x%x", uniformType);
         return JS::NullValue();
     }
     // this should never happen
     if (unitSize > 16) {
         GenerateWarning("getUniform: internal error: unexpected uniform unit size %d", unitSize);
         return JS::NullValue();
     }
     if (baseType == LOCAL_GL_FLOAT) {
         GLfloat fv[16] = { GLfloat(0) };
         gl->fGetUniformfv(progname, location->Location(), fv);
         if (unitSize == 1) {
             return JS::DoubleValue(fv[0]);
         } else {
             JSObject* obj = Float32Array::Create(cx, this, unitSize, fv);
             if (!obj) {
                 ErrorOutOfMemory("getUniform: out of memory");
                 return JS::NullValue();
             }
             return JS::ObjectOrNullValue(obj);
         }
     } else if (baseType == LOCAL_GL_INT) {
         GLint iv[16] = { 0 };
         gl->fGetUniformiv(progname, location->Location(), iv);
         if (unitSize == 1) {
             return JS::Int32Value(iv[0]);
         } else {
             JSObject* obj = Int32Array::Create(cx, this, unitSize, iv);
             if (!obj) {
                 ErrorOutOfMemory("getUniform: out of memory");
                 return JS::NullValue();
             }
             return JS::ObjectOrNullValue(obj);
         }
     } else if (baseType == LOCAL_GL_BOOL) {
         GLint iv[16] = { 0 };
         gl->fGetUniformiv(progname, location->Location(), iv);
         if (unitSize == 1) {
             return JS::BooleanValue(iv[0] ? true : false);
         } else {
             bool uv[16];
             for (int k = 0; k < unitSize; k++)
                 uv[k] = iv[k];
             JS::Rooted<JS::Value> val(cx);
             // Be careful: we don't want to convert all of |uv|!
             if (!ToJSValue(cx, uv, unitSize, &val)) {
                 ErrorOutOfMemory("getUniform: out of memory");
                 return JS::NullValue();
             }
             return val;
         }
     }
     // Else preserving behavior, but I'm not sure this is correct per spec
     return JS::UndefinedValue();
 }
 already_AddRefed<WebGLUniformLocation>
 WebGLContext::GetUniformLocation(WebGLProgram *prog, const nsAString& name)
 {
     if (IsContextLost())
         return nullptr;
     if (!ValidateObject("getUniformLocation: program", prog))
         return nullptr;
     if (!ValidateGLSLVariableName(name, "getUniformLocation"))
         return nullptr;
     NS_LossyConvertUTF16toASCII cname(name);
     nsCString mappedName;
     prog->MapIdentifier(cname, &mappedName);
     GLuint progname = prog->GLName();
     MakeContextCurrent();
     GLint intlocation = gl->fGetUniformLocation(progname, mappedName.get());
     nsRefPtr<WebGLUniformLocation> loc;
     if (intlocation >= 0) {
         WebGLUniformInfo info = prog->GetUniformInfoForMappedIdentifier(mappedName);
         loc = new WebGLUniformLocation(this,
                                        prog,
                                        intlocation,
                                        info);
     }
     return loc.forget();
 }
 void
 WebGLContext::Hint(GLenum target, GLenum mode)
 {
     if (IsContextLost())
         return;
     bool isValid = false;
     switch (target) {
         case LOCAL_GL_GENERATE_MIPMAP_HINT:
             isValid = true;
             break;
         case LOCAL_GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
             if (IsExtensionEnabled(WebGLExtensionID::OES_standard_derivatives))
                 isValid = true;
             break;
     }
     if (!isValid)
         return ErrorInvalidEnum("hint: invalid hint");
     MakeContextCurrent();
     gl->fHint(target, mode);
 }
 bool
 WebGLContext::IsFramebuffer(WebGLFramebuffer *fb)
 {
     if (IsContextLost())
         return false;
     return ValidateObjectAllowDeleted("isFramebuffer", fb) &&
         !fb->IsDeleted() &&
         fb->HasEverBeenBound();
 }
 bool
 WebGLContext::IsProgram(WebGLProgram *prog)
 {
     if (IsContextLost())
         return false;
     return ValidateObjectAllowDeleted("isProgram", prog) && !prog->IsDeleted();
 }
 bool
 WebGLContext::IsRenderbuffer(WebGLRenderbuffer *rb)
 {
     if (IsContextLost())
         return false;
     return ValidateObjectAllowDeleted("isRenderBuffer", rb) &&
         !rb->IsDeleted() &&
         rb->HasEverBeenBound();
 }
 bool
 WebGLContext::IsShader(WebGLShader *shader)
 {
     if (IsContextLost())
         return false;
     return ValidateObjectAllowDeleted("isShader", shader) &&
         !shader->IsDeleted();
 }
 bool
 WebGLContext::IsTexture(WebGLTexture *tex)
 {
     if (IsContextLost())
         return false;
     return ValidateObjectAllowDeleted("isTexture", tex) &&
         !tex->IsDeleted() &&
         tex->HasEverBeenBound();
 }
 // Try to bind an attribute that is an array to location 0:
 bool WebGLContext::BindArrayAttribToLocation0(WebGLProgram *program)
 {
     if (mBoundVertexArray->IsAttribArrayEnabled(0)) {
         return false;
     }
     GLint leastArrayLocation = -1;
     std::map<GLint, nsCString>::iterator itr;
     for (itr = program->mActiveAttribMap.begin();
          itr != program->mActiveAttribMap.end();
          itr++) {
         int32_t index = itr->first;
         if (mBoundVertexArray->IsAttribArrayEnabled(index) &&
             index < leastArrayLocation)
         {
             leastArrayLocation = index;
         }
     }
     if (leastArrayLocation > 0) {
         nsCString& attrName = program->mActiveAttribMap.find(leastArrayLocation)->second;
         const char* attrNameCStr = attrName.get();
         gl->fBindAttribLocation(program->GLName(), 0, attrNameCStr);
         return true;
     }
     return false;
 }
 void
 WebGLContext::LinkProgram(WebGLProgram *program)
 {
     if (IsContextLost())
         return;
     if (!ValidateObject("linkProgram", program))
         return;
     InvalidateBufferFetching(); // we do it early in this function
     // as some of the validation below changes program state
     GLuint progname = program->GLName();
     if (!program->NextGeneration()) {
         // XXX throw?
         return;
     }
     if (!program->HasBothShaderTypesAttached()) {
         GenerateWarning("linkProgram: this program doesn't have both a vertex shader"
                         " and a fragment shader");
         program->SetLinkStatus(false);
         return;
     }
     // bug 777028
     // Mesa can't handle more than 16 samplers per program, counting each array entry.
     if (gl->WorkAroundDriverBugs() &&
         mIsMesa &&
         program->UpperBoundNumSamplerUniforms() > 16)
     {
         GenerateWarning("Programs with more than 16 samplers are disallowed on Mesa drivers " "to avoid a Mesa crasher.");
         program->SetLinkStatus(false);
         return;
     }
     bool updateInfoSucceeded = false;
     GLint ok = 0;
     if (gl->WorkAroundDriverBugs() &&
         program->HasBadShaderAttached())
     {
         // it's a common driver bug, caught by program-test.html, that linkProgram doesn't
         // correctly preserve the state of an in-use program that has been attached a bad shader
         // see bug 777883
         ok = false;
     } else {
         MakeContextCurrent();
         gl->fLinkProgram(progname);
         gl->fGetProgramiv(progname, LOCAL_GL_LINK_STATUS, &ok);
         if (ok) {
             updateInfoSucceeded = program->UpdateInfo();
             program->SetLinkStatus(updateInfoSucceeded);
             if (BindArrayAttribToLocation0(program)) {
                 GenerateWarning("linkProgram: relinking program to make attrib0 an "
                                 "array.");
                 gl->fLinkProgram(progname);
                 gl->fGetProgramiv(progname, LOCAL_GL_LINK_STATUS, &ok);
                 if (ok) {
                     updateInfoSucceeded = program->UpdateInfo();
                     program->SetLinkStatus(updateInfoSucceeded);
                 }
             }
         }
     }
     if (ok) {
         // Bug 750527
         if (gl->WorkAroundDriverBugs() &&
             updateInfoSucceeded &&
             gl->Vendor() == gl::GLVendor::NVIDIA)
         {
             if (program == mCurrentProgram)
                 gl->fUseProgram(progname);
         }
     } else {
         program->SetLinkStatus(false);
         if (ShouldGenerateWarnings()) {
             // report shader/program infoLogs as warnings.
             // note that shader compilation errors can be deferred to linkProgram,
             // which is why we can't do anything in compileShader. In practice we could
             // report in compileShader the translation errors generated by ANGLE,
             // but it seems saner to keep a single way of obtaining shader infologs.
             nsAutoCString log;
             bool alreadyReportedShaderInfoLog = false;
             for (size_t i = 0; i < program->AttachedShaders().Length(); i++) {
                 WebGLShader* shader = program->AttachedShaders()[i];
                 if (shader->CompileStatus())
                     continue;
                 const char *shaderTypeName = nullptr;
                 if (shader->ShaderType() == LOCAL_GL_VERTEX_SHADER) {
                     shaderTypeName = "vertex";
                 } else if (shader->ShaderType() == LOCAL_GL_FRAGMENT_SHADER) {
                     shaderTypeName = "fragment";
                 } else {
                     // should have been validated earlier
                     MOZ_ASSERT(false);
                     shaderTypeName = "<unknown>";
                 }
                 GetShaderInfoLog(shader, log);
                 GenerateWarning("linkProgram: a %s shader used in this program failed to "
                                 "compile, with this log:\n%s\n",
                                 shaderTypeName,
                                 log.get());
                 alreadyReportedShaderInfoLog = true;
             }
             if (!alreadyReportedShaderInfoLog) {
                 GetProgramInfoLog(program, log);
                 if (!log.IsEmpty()) {
                     GenerateWarning("linkProgram failed, with this log:\n%s\n",
                                     log.get());
                 }
             }
         }
     }
 }
 void
 WebGLContext::PixelStorei(GLenum pname, GLint param)
 {
     if (IsContextLost())
         return;
     switch (pname) {
         case UNPACK_FLIP_Y_WEBGL:
             mPixelStoreFlipY = (param != 0);
             break;
         case UNPACK_PREMULTIPLY_ALPHA_WEBGL:
             mPixelStorePremultiplyAlpha = (param != 0);
             break;
         case UNPACK_COLORSPACE_CONVERSION_WEBGL:
             if (param == LOCAL_GL_NONE || param == BROWSER_DEFAULT_WEBGL)
                 mPixelStoreColorspaceConversion = param;
             else
                 return ErrorInvalidEnumInfo("pixelStorei: colorspace conversion parameter", param);
             break;
         case LOCAL_GL_PACK_ALIGNMENT:
         case LOCAL_GL_UNPACK_ALIGNMENT:
             if (param != 1 &&
                 param != 2 &&
                 param != 4 &&
                 param != 8)
                 return ErrorInvalidValue("pixelStorei: invalid pack/unpack alignment value");
             if (pname == LOCAL_GL_PACK_ALIGNMENT)
                 mPixelStorePackAlignment = param;
             else if (pname == LOCAL_GL_UNPACK_ALIGNMENT)
                 mPixelStoreUnpackAlignment = param;
             MakeContextCurrent();
             gl->fPixelStorei(pname, param);
             break;
         default:
             return ErrorInvalidEnumInfo("pixelStorei: parameter", pname);
     }
 }
 void
 WebGLContext::ReadPixels(GLint x, GLint y, GLsizei width,
                          GLsizei height, GLenum format,
                          GLenum type, const Nullable<ArrayBufferView> &pixels,
                          ErrorResult& rv)
 {
     if (IsContextLost())
         return;
     if (mCanvasElement->IsWriteOnly() && !nsContentUtils::IsCallerChrome()) {
         GenerateWarning("readPixels: Not allowed");
         return rv.Throw(NS_ERROR_DOM_SECURITY_ERR);
     }
     if (width < 0 || height < 0)
         return ErrorInvalidValue("readPixels: negative size passed");
     if (pixels.IsNull())
         return ErrorInvalidValue("readPixels: null destination buffer");
     const WebGLRectangleObject* framebufferRect = CurValidFBRectObject();
     GLsizei framebufferWidth = framebufferRect ? framebufferRect->Width() : 0;
     GLsizei framebufferHeight = framebufferRect ? framebufferRect->Height() : 0;
     uint32_t channels = 0;
     // Check the format param
     switch (format) {
         case LOCAL_GL_ALPHA:
             channels = 1;
             break;
         case LOCAL_GL_RGB:
             channels = 3;
             break;
         case LOCAL_GL_RGBA:
             channels = 4;
             break;
         default:
             return ErrorInvalidEnum("readPixels: Bad format");
     }
     uint32_t bytesPerPixel = 0;
     int requiredDataType = 0;
     // Check the type param
     bool isReadTypeValid = false;
     bool isReadTypeFloat = false;
     switch (type) {
         case LOCAL_GL_UNSIGNED_BYTE:
             isReadTypeValid = true;
             bytesPerPixel = 1*channels;
             requiredDataType = js::ArrayBufferView::TYPE_UINT8;
             break;
         case LOCAL_GL_UNSIGNED_SHORT_4_4_4_4:
         case LOCAL_GL_UNSIGNED_SHORT_5_5_5_1:
         case LOCAL_GL_UNSIGNED_SHORT_5_6_5:
             isReadTypeValid = true;
             bytesPerPixel = 2;
             requiredDataType = js::ArrayBufferView::TYPE_UINT16;
             break;
         case LOCAL_GL_FLOAT:
             if (IsExtensionEnabled(WebGLExtensionID::WEBGL_color_buffer_float) ||
                 IsExtensionEnabled(WebGLExtensionID::EXT_color_buffer_half_float))
             {
                 isReadTypeValid = true;
                 isReadTypeFloat = true;
                 bytesPerPixel = 4*channels;
                 requiredDataType = js::ArrayBufferView::TYPE_FLOAT32;
             }
             break;
     }
     if (!isReadTypeValid)
         return ErrorInvalidEnum("readPixels: Bad type", type);
     const ArrayBufferView& pixbuf = pixels.Value();
     int dataType = JS_GetArrayBufferViewType(pixbuf.Obj());
     // Check the pixels param type
     if (dataType != requiredDataType)
         return ErrorInvalidOperation("readPixels: Mismatched type/pixels types");
     // Check the pixels param size
     CheckedUint32 checked_neededByteLength =
         GetImageSize(height, width, bytesPerPixel, mPixelStorePackAlignment);
     CheckedUint32 checked_plainRowSize = CheckedUint32(width) * bytesPerPixel;
     CheckedUint32 checked_alignedRowSize =
         RoundedToNextMultipleOf(checked_plainRowSize, mPixelStorePackAlignment);
     if (!checked_neededByteLength.isValid())
         return ErrorInvalidOperation("readPixels: integer overflow computing the needed buffer size");
     // Compute length and data.  Don't reenter after this point, lest the
     // precomputed go out of sync with the instant length/data.
     pixbuf.ComputeLengthAndData();
     uint32_t dataByteLen = pixbuf.Length();
     if (checked_neededByteLength.value() > dataByteLen)
         return ErrorInvalidOperation("readPixels: buffer too small");
     void* data = pixbuf.Data();
     if (!data) {
         ErrorOutOfMemory("readPixels: buffer storage is null. Did we run out of memory?");
         return rv.Throw(NS_ERROR_OUT_OF_MEMORY);
     }
     bool isSourceTypeFloat = false;
     if (mBoundFramebuffer &&
         mBoundFramebuffer->ColorAttachmentCount() &&
         mBoundFramebuffer->ColorAttachment(0).IsDefined())
     {
         isSourceTypeFloat = mBoundFramebuffer->ColorAttachment(0).IsReadableFloat();
     }
     if (isReadTypeFloat != isSourceTypeFloat)
         return ErrorInvalidOperation("readPixels: Invalid type floatness");
     // Check the format and type params to assure they are an acceptable pair (as per spec)
     switch (format) {
         case LOCAL_GL_RGBA: {
             switch (type) {
                 case LOCAL_GL_UNSIGNED_BYTE:
                     break;
                 case LOCAL_GL_FLOAT:
                     break;
                 default:
                     return ErrorInvalidOperation("readPixels: Invalid format/type pair");
             }
             break;
         }
         default:
             return ErrorInvalidOperation("readPixels: Invalid format/type pair");
     }
     MakeContextCurrent();
     if (mBoundFramebuffer) {
         // prevent readback of arbitrary video memory through uninitialized renderbuffers!
         if (!mBoundFramebuffer->CheckAndInitializeAttachments())
             return ErrorInvalidFramebufferOperation("readPixels: incomplete framebuffer");
         GLenum readPlaneBits = LOCAL_GL_COLOR_BUFFER_BIT;
         if (!mBoundFramebuffer->HasCompletePlanes(readPlaneBits)) {
             return ErrorInvalidOperation("readPixels: Read source attachment doesn't have the"
                                          " correct color/depth/stencil type.");
         }
     } else {
       ClearBackbufferIfNeeded();
     }
     // Now that the errors are out of the way, on to actually reading
     // If we won't be reading any pixels anyways, just skip the actual reading
     if (width == 0 || height == 0)
         return DummyFramebufferOperation("readPixels");
     if (CanvasUtils::CheckSaneSubrectSize(x, y, width, height, framebufferWidth, framebufferHeight)) {
         // the easy case: we're not reading out-of-range pixels
         gl->fReadPixels(x, y, width, height, format, type, data);
     } else {
         // the rectangle doesn't fit entirely in the bound buffer. We then have to set to zero the part
         // of the buffer that correspond to out-of-range pixels. We don't want to rely on system OpenGL
         // to do that for us, because passing out of range parameters to a buggy OpenGL implementation
         // could conceivably allow to read memory we shouldn't be allowed to read. So we manually initialize
         // the buffer to zero and compute the parameters to pass to OpenGL. We have to use an intermediate buffer
         // to accomodate the potentially different strides (widths).
         // Zero the whole pixel dest area in the destination buffer.
         memset(data, 0, checked_neededByteLength.value());
         if (   x >= framebufferWidth
             || x+width <= 0
             || y >= framebufferHeight
             || y+height <= 0)
         {
             // we are completely outside of range, can exit now with buffer filled with zeros
             return DummyFramebufferOperation("readPixels");
         }
         // compute the parameters of the subrect we're actually going to call glReadPixels on
         GLint   subrect_x      = std::max(x, 0);
         GLint   subrect_end_x  = std::min(x+width, framebufferWidth);
         GLsizei subrect_width  = subrect_end_x - subrect_x;
         GLint   subrect_y      = std::max(y, 0);
         GLint   subrect_end_y  = std::min(y+height, framebufferHeight);
         GLsizei subrect_height = subrect_end_y - subrect_y;
         if (subrect_width < 0 || subrect_height < 0 ||
             subrect_width > width || subrect_height > height)
             return ErrorInvalidOperation("readPixels: integer overflow computing clipped rect size");
         // now we know that subrect_width is in the [0..width] interval, and same for heights.
         // now, same computation as above to find the size of the intermediate buffer to allocate for the subrect
         // no need to check again for integer overflow here, since we already know the sizes aren't greater than before
         uint32_t subrect_plainRowSize = subrect_width * bytesPerPixel;
     // There are checks above to ensure that this doesn't overflow.
         uint32_t subrect_alignedRowSize =
             RoundedToNextMultipleOf(subrect_plainRowSize, mPixelStorePackAlignment).value();
         uint32_t subrect_byteLength = (subrect_height-1)*subrect_alignedRowSize + subrect_plainRowSize;
         // create subrect buffer, call glReadPixels, copy pixels into destination buffer, delete subrect buffer
         GLubyte *subrect_data = new GLubyte[subrect_byteLength];
         gl->fReadPixels(subrect_x, subrect_y, subrect_width, subrect_height, format, type, subrect_data);
         // notice that this for loop terminates because we already checked that subrect_height is at most height
         for (GLint y_inside_subrect = 0; y_inside_subrect < subrect_height; ++y_inside_subrect) {
             GLint subrect_x_in_dest_buffer = subrect_x - x;
             GLint subrect_y_in_dest_buffer = subrect_y - y;
             memcpy(static_cast<GLubyte*>(data)
                      + checked_alignedRowSize.value() * (subrect_y_in_dest_buffer + y_inside_subrect)
                      + bytesPerPixel * subrect_x_in_dest_buffer, // destination
                    subrect_data + subrect_alignedRowSize * y_inside_subrect, // source
                    subrect_plainRowSize); // size
         }
         delete [] subrect_data;
     }
     // if we're reading alpha, we may need to do fixup.  Note that we don't allow
     // GL_ALPHA to readpixels currently, but we had the code written for it already.
     if (format == LOCAL_GL_ALPHA ||
         format == LOCAL_GL_RGBA)
     {
         bool needAlphaFixup;
         if (mBoundFramebuffer) {
             needAlphaFixup = !mBoundFramebuffer->ColorAttachment(0).HasAlpha();
         } else {
             needAlphaFixup = gl->GetPixelFormat().alpha == 0;
         }
         if (needAlphaFixup) {
             if (format == LOCAL_GL_ALPHA && type == LOCAL_GL_UNSIGNED_BYTE) {
                 // this is easy; it's an 0xff memset per row
                 uint8_t *row = static_cast<uint8_t*>(data);
                 for (GLint j = 0; j < height; ++j) {
                     memset(row, 0xff, checked_plainRowSize.value());
                     row += checked_alignedRowSize.value();
                 }
             } else if (format == LOCAL_GL_RGBA && type == LOCAL_GL_UNSIGNED_BYTE) {
                 // this is harder, we need to just set the alpha byte here
                 uint8_t *row = static_cast<uint8_t*>(data);
                 for (GLint j = 0; j < height; ++j) {
                     uint8_t *rowp = row;
 #if MOZ_LITTLE_ENDIAN
                     // offset to get the alpha byte; we're always going to
                     // move by 4 bytes
                     rowp += 3;
 #endif
                     uint8_t *endrowp = rowp + 4 * width;
                     while (rowp != endrowp) {
                         *rowp = 0xff;
                         rowp += 4;
                     }
                     row += checked_alignedRowSize.value();
                 }
             } else if (format == LOCAL_GL_RGBA && type == LOCAL_GL_FLOAT) {
                 float* row = static_cast<float*>(data);
                 for (GLint j = 0; j < height; ++j) {
                     float* pAlpha = row + 3;
                     float* pAlphaEnd = pAlpha + 4*width;
                     while (pAlpha != pAlphaEnd) {
                         *pAlpha = 1.0f;
                         pAlpha += 4;
                     }
                     row += checked_alignedRowSize.value();
                 }
             } else {
                 NS_WARNING("Unhandled case, how'd we get here?");
                 return rv.Throw(NS_ERROR_FAILURE);
             }
         }
     }
 }
 void
 WebGLContext::RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
     if (IsContextLost())
         return;
     if (!mBoundRenderbuffer)
         return ErrorInvalidOperation("renderbufferStorage called on renderbuffer 0");
     if (target != LOCAL_GL_RENDERBUFFER)
         return ErrorInvalidEnumInfo("renderbufferStorage: target", target);
     if (width < 0 || height < 0)
         return ErrorInvalidValue("renderbufferStorage: width and height must be >= 0");
     if (width > mGLMaxRenderbufferSize || height > mGLMaxRenderbufferSize)
         return ErrorInvalidValue("renderbufferStorage: width or height exceeds maximum renderbuffer size");
     // certain OpenGL ES renderbuffer formats may not exist on desktop OpenGL
     GLenum internalformatForGL = internalformat;
     switch (internalformat) {
     case LOCAL_GL_RGBA4:
     case LOCAL_GL_RGB5_A1:
         // 16-bit RGBA formats are not supported on desktop GL
         if (!gl->IsGLES()) internalformatForGL = LOCAL_GL_RGBA8;
         break;
     case LOCAL_GL_RGB565:
         // the RGB565 format is not supported on desktop GL
         if (!gl->IsGLES()) internalformatForGL = LOCAL_GL_RGB8;
         break;
     case LOCAL_GL_DEPTH_COMPONENT16:
         if (!gl->IsGLES() || gl->IsExtensionSupported(gl::GLContext::OES_depth24))
             internalformatForGL = LOCAL_GL_DEPTH_COMPONENT24;
         else if (gl->IsExtensionSupported(gl::GLContext::OES_packed_depth_stencil))
             internalformatForGL = LOCAL_GL_DEPTH24_STENCIL8;
         break;
     case LOCAL_GL_STENCIL_INDEX8:
         break;
     case LOCAL_GL_DEPTH_STENCIL:
         // We emulate this in WebGLRenderbuffer if we don't have the requisite extension.
         internalformatForGL = LOCAL_GL_DEPTH24_STENCIL8;
         break;
     case LOCAL_GL_SRGB8_ALPHA8_EXT:
         break;
     case LOCAL_GL_RGB16F:
     case LOCAL_GL_RGBA16F: {
         bool hasExtensions = IsExtensionEnabled(WebGLExtensionID::OES_texture_half_float) &&
                              IsExtensionEnabled(WebGLExtensionID::EXT_color_buffer_half_float);
         if (!hasExtensions)
             return ErrorInvalidEnumInfo("renderbufferStorage: internalformat", target);
         break;
     }
     case LOCAL_GL_RGB32F:
     case LOCAL_GL_RGBA32F: {
         bool hasExtensions = IsExtensionEnabled(WebGLExtensionID::OES_texture_float) &&
                              IsExtensionEnabled(WebGLExtensionID::WEBGL_color_buffer_float);
         if (!hasExtensions)
             return ErrorInvalidEnumInfo("renderbufferStorage: internalformat", target);
         break;
     }
     default:
         return ErrorInvalidEnumInfo("renderbufferStorage: internalformat", internalformat);
     }
     MakeContextCurrent();
     bool sizeChanges = width != mBoundRenderbuffer->Width() ||
                        height != mBoundRenderbuffer->Height() ||
                        internalformat != mBoundRenderbuffer->InternalFormat();
     if (sizeChanges) {
         // Invalidate framebuffer status cache
         mBoundRenderbuffer->NotifyFBsStatusChanged();
         GetAndFlushUnderlyingGLErrors();
         mBoundRenderbuffer->RenderbufferStorage(internalformatForGL, width, height);
         GLenum error = GetAndFlushUnderlyingGLErrors();
         if (error) {
             GenerateWarning("renderbufferStorage generated error %s", ErrorName(error));
             return;
         }
     } else {
         mBoundRenderbuffer->RenderbufferStorage(internalformatForGL, width, height);
     }
     mBoundRenderbuffer->SetInternalFormat(internalformat);
     mBoundRenderbuffer->SetInternalFormatForGL(internalformatForGL);
     mBoundRenderbuffer->setDimensions(width, height);
     mBoundRenderbuffer->SetImageDataStatus(WebGLImageDataStatus::UninitializedImageData);
 }
 void
 WebGLContext::Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
     if (IsContextLost())
         return;
     if (width < 0 || height < 0)
         return ErrorInvalidValue("scissor: negative size");
     MakeContextCurrent();
     gl->fScissor(x, y, width, height);
 }
 void
 WebGLContext::StencilFunc(GLenum func, GLint ref, GLuint mask)
 {
     if (IsContextLost())
         return;
     if (!ValidateComparisonEnum(func, "stencilFunc: func"))
         return;
     mStencilRefFront = ref;
     mStencilRefBack = ref;
     mStencilValueMaskFront = mask;
     mStencilValueMaskBack = mask;
     MakeContextCurrent();
     gl->fStencilFunc(func, ref, mask);
 }
 void
 WebGLContext::StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
     if (IsContextLost())
         return;
     if (!ValidateFaceEnum(face, "stencilFuncSeparate: face") ||
         !ValidateComparisonEnum(func, "stencilFuncSeparate: func"))
         return;
     switch (face) {
         case LOCAL_GL_FRONT_AND_BACK:
             mStencilRefFront = ref;
             mStencilRefBack = ref;
             mStencilValueMaskFront = mask;
             mStencilValueMaskBack = mask;
             break;
         case LOCAL_GL_FRONT:
             mStencilRefFront = ref;
             mStencilValueMaskFront = mask;
             break;
         case LOCAL_GL_BACK:
             mStencilRefBack = ref;
             mStencilValueMaskBack = mask;
             break;
     }
     MakeContextCurrent();
     gl->fStencilFuncSeparate(face, func, ref, mask);
 }
 void
 WebGLContext::StencilOp(GLenum sfail, GLenum dpfail, GLenum dppass)
 {
     if (IsContextLost())
         return;
     if (!ValidateStencilOpEnum(sfail, "stencilOp: sfail") ||
         !ValidateStencilOpEnum(dpfail, "stencilOp: dpfail") ||
         !ValidateStencilOpEnum(dppass, "stencilOp: dppass"))
         return;
     MakeContextCurrent();
     gl->fStencilOp(sfail, dpfail, dppass);
 }
 void
 WebGLContext::StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
     if (IsContextLost())
         return;
     if (!ValidateFaceEnum(face, "stencilOpSeparate: face") ||
         !ValidateStencilOpEnum(sfail, "stencilOpSeparate: sfail") ||
         !ValidateStencilOpEnum(dpfail, "stencilOpSeparate: dpfail") ||
         !ValidateStencilOpEnum(dppass, "stencilOpSeparate: dppass"))
         return;
     MakeContextCurrent();
     gl->fStencilOpSeparate(face, sfail, dpfail, dppass);
 }
 nsresult
 WebGLContext::SurfaceFromElementResultToImageSurface(nsLayoutUtils::SurfaceFromElementResult& res,
                                                      RefPtr<DataSourceSurface>& imageOut, WebGLTexelFormat *format)
 {
    *format = WebGLTexelFormat::None;
     if (!res.mSourceSurface)
         return NS_OK;
     RefPtr<DataSourceSurface> data = res.mSourceSurface->GetDataSurface();
     if (!data) {
         // SurfaceFromElement lied!
         return NS_OK;
     }
     if (!mPixelStorePremultiplyAlpha && res.mIsPremultiplied) {
       data = gfxUtils::UnpremultiplyDataSurface(data);
     }
     // We disallow loading cross-domain images and videos that have not been validated
     // with CORS as WebGL textures. The reason for doing that is that timing
     // attacks on WebGL shaders are able to retrieve approximations of the
     // pixel values in WebGL textures; see bug 655987.
     //
     // To prevent a loophole where a Canvas2D would be used as a proxy to load
     // cross-domain textures, we also disallow loading textures from write-only
     // Canvas2D's.
     // part 1: check that the DOM element is same-origin, or has otherwise been
     // validated for cross-domain use.
     if (!res.mCORSUsed) {
         bool subsumes;
         nsresult rv = mCanvasElement->NodePrincipal()->Subsumes(res.mPrincipal, &subsumes);
         if (NS_FAILED(rv) || !subsumes) {
             GenerateWarning("It is forbidden to load a WebGL texture from a cross-domain element that has not been validated with CORS. "
                                 "See https://developer.mozilla.org/en/WebGL/Cross-Domain_Textures");
             return NS_ERROR_DOM_SECURITY_ERR;
         }
     }
     // part 2: if the DOM element is write-only, it might contain
     // cross-domain image data.
     if (res.mIsWriteOnly) {
         GenerateWarning("The canvas used as source for texImage2D here is tainted (write-only). It is forbidden "
                         "to load a WebGL texture from a tainted canvas. A Canvas becomes tainted for example "
                         "when a cross-domain image is drawn on it. "
                         "See https://developer.mozilla.org/en/WebGL/Cross-Domain_Textures");
         return NS_ERROR_DOM_SECURITY_ERR;
     }
     // End of security checks, now we should be safe regarding cross-domain images
     // Notice that there is never a need to mark the WebGL canvas as write-only, since we reject write-only/cross-domain
     // texture sources in the first place.
     switch (data->GetFormat()) {
         case SurfaceFormat::B8G8R8A8:
             *format = WebGLTexelFormat::BGRA8; // careful, our ARGB means BGRA
             break;
         case SurfaceFormat::B8G8R8X8:
             *format = WebGLTexelFormat::BGRX8; // careful, our RGB24 is not tightly packed. Whence BGRX8.
             break;
         case SurfaceFormat::A8:
             *format = WebGLTexelFormat::A8;
             break;
         case SurfaceFormat::R5G6B5:
             *format = WebGLTexelFormat::RGB565;
             break;
         default:
             NS_ASSERTION(false, "Unsupported image format. Unimplemented.");
             return NS_ERROR_NOT_IMPLEMENTED;
     }
     imageOut = data;
     return NS_OK;
 }
 void
 WebGLContext::Uniform1i(WebGLUniformLocation *location_object, GLint a1)
 {
     GLint location;
     if (!ValidateUniformSetter("Uniform1i", location_object, location))
         return;
     // Only uniform1i can take sampler settings.
     if (!ValidateSamplerUniformSetter("Uniform1i", location_object, a1))
         return;
     MakeContextCurrent();
     gl->fUniform1i(location, a1);
 }
 void
 WebGLContext::Uniform2i(WebGLUniformLocation *location_object, GLint a1,
                         GLint a2)
 {
     GLint location;
     if (!ValidateUniformSetter("Uniform2i", location_object, location))
         return;
     MakeContextCurrent();
     gl->fUniform2i(location, a1, a2);
 }
 void
 WebGLContext::Uniform3i(WebGLUniformLocation *location_object, GLint a1,
                         GLint a2, GLint a3)
 {
     GLint location;
     if (!ValidateUniformSetter("Uniform3i", location_object, location))
         return;
     MakeContextCurrent();
     gl->fUniform3i(location, a1, a2, a3);
 }
 void
 WebGLContext::Uniform4i(WebGLUniformLocation *location_object, GLint a1,
                         GLint a2, GLint a3, GLint a4)
 {
     GLint location;
     if (!ValidateUniformSetter("Uniform4i", location_object, location))
         return;
     MakeContextCurrent();
     gl->fUniform4i(location, a1, a2, a3, a4);
 }
 void
 WebGLContext::Uniform1f(WebGLUniformLocation *location_object, GLfloat a1)
 {
     GLint location;
     if (!ValidateUniformSetter("Uniform1f", location_object, location))
         return;
     MakeContextCurrent();
     gl->fUniform1f(location, a1);
 }
 void
 WebGLContext::Uniform2f(WebGLUniformLocation *location_object, GLfloat a1,
                         GLfloat a2)
 {
     GLint location;
     if (!ValidateUniformSetter("Uniform2f", location_object, location))
         return;
     MakeContextCurrent();
     gl->fUniform2f(location, a1, a2);
 }
 void
 WebGLContext::Uniform3f(WebGLUniformLocation *location_object, GLfloat a1,
                         GLfloat a2, GLfloat a3)
 {
     GLint location;
     if (!ValidateUniformSetter("Uniform3f", location_object, location))
         return;
     MakeContextCurrent();
     gl->fUniform3f(location, a1, a2, a3);
 }
 void
 WebGLContext::Uniform4f(WebGLUniformLocation *location_object, GLfloat a1,
                         GLfloat a2, GLfloat a3, GLfloat a4)
 {
     GLint location;
     if (!ValidateUniformSetter("Uniform4f", location_object, location))
         return;
     MakeContextCurrent();
     gl->fUniform4f(location, a1, a2, a3, a4);
 }
 void
 WebGLContext::Uniform1iv_base(WebGLUniformLocation *location_object,
                               uint32_t arrayLength, const GLint* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformArraySetter("Uniform1iv", 1, location_object, location,
                                     numElementsToUpload, arrayLength)) {
         return;
     }
     if (!ValidateSamplerUniformSetter("Uniform1iv", location_object, data[0]))
         return;
     MakeContextCurrent();
     gl->fUniform1iv(location, numElementsToUpload, data);
 }
 void
 WebGLContext::Uniform2iv_base(WebGLUniformLocation *location_object,
                               uint32_t arrayLength, const GLint* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformArraySetter("Uniform2iv", 2, location_object, location,
                                     numElementsToUpload, arrayLength)) {
         return;
     }
     if (!ValidateSamplerUniformSetter("Uniform2iv", location_object, data[0]) ||
         !ValidateSamplerUniformSetter("Uniform2iv", location_object, data[1]))
     {
         return;
     }
     MakeContextCurrent();
     gl->fUniform2iv(location, numElementsToUpload, data);
 }
 void
 WebGLContext::Uniform3iv_base(WebGLUniformLocation *location_object,
                               uint32_t arrayLength, const GLint* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformArraySetter("Uniform3iv", 3, location_object, location,
                                     numElementsToUpload, arrayLength)) {
         return;
     }
     if (!ValidateSamplerUniformSetter("Uniform3iv", location_object, data[0]) ||
         !ValidateSamplerUniformSetter("Uniform3iv", location_object, data[1]) ||
         !ValidateSamplerUniformSetter("Uniform3iv", location_object, data[2]))
     {
         return;
     }
     MakeContextCurrent();
     gl->fUniform3iv(location, numElementsToUpload, data);
 }
 void
 WebGLContext::Uniform4iv_base(WebGLUniformLocation *location_object,
                               uint32_t arrayLength, const GLint* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformArraySetter("Uniform4iv", 4, location_object, location,
                                     numElementsToUpload, arrayLength)) {
         return;
     }
     if (!ValidateSamplerUniformSetter("Uniform4iv", location_object, data[0]) ||
         !ValidateSamplerUniformSetter("Uniform4iv", location_object, data[1]) ||
         !ValidateSamplerUniformSetter("Uniform4iv", location_object, data[2]) ||
         !ValidateSamplerUniformSetter("Uniform4iv", location_object, data[3]))
     {
         return;
     }
     MakeContextCurrent();
     gl->fUniform4iv(location, numElementsToUpload, data);
 }
 void
 WebGLContext::Uniform1fv_base(WebGLUniformLocation *location_object,
                               uint32_t arrayLength, const GLfloat* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformArraySetter("Uniform1fv", 1, location_object, location,
                                     numElementsToUpload, arrayLength)) {
         return;
     }
     MakeContextCurrent();
     gl->fUniform1fv(location, numElementsToUpload, data);
 }
 void
 WebGLContext::Uniform2fv_base(WebGLUniformLocation *location_object,
                               uint32_t arrayLength, const GLfloat* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformArraySetter("Uniform2fv", 2, location_object, location,
                                     numElementsToUpload, arrayLength)) {
         return;
     }
     MakeContextCurrent();
     gl->fUniform2fv(location, numElementsToUpload, data);
 }
 void
 WebGLContext::Uniform3fv_base(WebGLUniformLocation *location_object,
                               uint32_t arrayLength, const GLfloat* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformArraySetter("Uniform3fv", 3, location_object, location,
                                     numElementsToUpload, arrayLength)) {
         return;
     }
     MakeContextCurrent();
     gl->fUniform3fv(location, numElementsToUpload, data);
 }
 void
 WebGLContext::Uniform4fv_base(WebGLUniformLocation *location_object,
                               uint32_t arrayLength, const GLfloat* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformArraySetter("Uniform4fv", 4, location_object, location,
                                     numElementsToUpload, arrayLength)) {
         return;
     }
     MakeContextCurrent();
     gl->fUniform4fv(location, numElementsToUpload, data);
 }
 void
 WebGLContext::UniformMatrix2fv_base(WebGLUniformLocation* location_object,
                                     WebGLboolean aTranspose, uint32_t arrayLength,
                                     const float* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformMatrixArraySetter("UniformMatrix2fv", 2, location_object, location,
                                          numElementsToUpload, arrayLength, aTranspose)) {
         return;
     }
     MakeContextCurrent();
     gl->fUniformMatrix2fv(location, numElementsToUpload, false, data);
 }
 void
 WebGLContext::UniformMatrix3fv_base(WebGLUniformLocation* location_object,
                                     WebGLboolean aTranspose, uint32_t arrayLength,
                                     const float* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformMatrixArraySetter("UniformMatrix3fv", 3, location_object, location,
                                          numElementsToUpload, arrayLength, aTranspose)) {
         return;
     }
     MakeContextCurrent();
     gl->fUniformMatrix3fv(location, numElementsToUpload, false, data);
 }
 void
 WebGLContext::UniformMatrix4fv_base(WebGLUniformLocation* location_object,
                                     WebGLboolean aTranspose, uint32_t arrayLength,
                                     const float* data)
 {
     uint32_t numElementsToUpload;
     GLint location;
     if (!ValidateUniformMatrixArraySetter("UniformMatrix4fv", 4, location_object, location,
                                          numElementsToUpload, arrayLength, aTranspose)) {
         return;
     }
     MakeContextCurrent();
     gl->fUniformMatrix4fv(location, numElementsToUpload, false, data);
 }
 void
 WebGLContext::UseProgram(WebGLProgram *prog)
 {
     if (IsContextLost())
         return;
     if (!ValidateObjectAllowNull("useProgram", prog))
         return;
     MakeContextCurrent();
     InvalidateBufferFetching();
     GLuint progname = prog ? prog->GLName() : 0;
     if (prog && !prog->LinkStatus())
         return ErrorInvalidOperation("useProgram: program was not linked successfully");
     gl->fUseProgram(progname);
     mCurrentProgram = prog;
 }
 void
 WebGLContext::ValidateProgram(WebGLProgram *prog)
 {
     if (IsContextLost())
         return;
     if (!ValidateObject("validateProgram", prog))
         return;
     MakeContextCurrent();
 #ifdef XP_MACOSX
     // see bug 593867 for NVIDIA and bug 657201 for ATI. The latter is confirmed with Mac OS 10.6.7
     if (gl->WorkAroundDriverBugs()) {
         GenerateWarning("validateProgram: implemented as a no-operation on Mac to work around crashes");
         return;
     }
 #endif
     GLuint progname = prog->GLName();
     gl->fValidateProgram(progname);
 }
 already_AddRefed<WebGLFramebuffer>
 WebGLContext::CreateFramebuffer()
 {
     if (IsContextLost())
         return nullptr;
     nsRefPtr<WebGLFramebuffer> globj = new WebGLFramebuffer(this);
     return globj.forget();
 }
 already_AddRefed<WebGLRenderbuffer>
 WebGLContext::CreateRenderbuffer()
 {
     if (IsContextLost())
         return nullptr;
     nsRefPtr<WebGLRenderbuffer> globj = new WebGLRenderbuffer(this);
     return globj.forget();
 }
 void
 WebGLContext::Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
     if (IsContextLost())
         return;
     if (width < 0 || height < 0)
         return ErrorInvalidValue("viewport: negative size");
     MakeContextCurrent();
     gl->fViewport(x, y, width, height);
     mViewportX = x;
     mViewportY = y;
     mViewportWidth = width;
     mViewportHeight = height;
 }
 void
 WebGLContext::CompileShader(WebGLShader *shader)
 {
     if (IsContextLost())
         return;
     if (!ValidateObject("compileShader", shader))
         return;
     GLuint shadername = shader->GLName();
     shader->SetCompileStatus(false);
     MakeContextCurrent();
     ShShaderOutput targetShaderSourceLanguage = gl->IsGLES() ? SH_ESSL_OUTPUT : SH_GLSL_OUTPUT;
     bool useShaderSourceTranslation = true;
     if (shader->NeedsTranslation() && mShaderValidation) {
         ShHandle compiler = 0;
         ShBuiltInResources resources;
         memset(&resources, 0, sizeof(ShBuiltInResources));
         resources.MaxVertexAttribs = mGLMaxVertexAttribs;
         resources.MaxVertexUniformVectors = mGLMaxVertexUniformVectors;
         resources.MaxVaryingVectors = mGLMaxVaryingVectors;
         resources.MaxVertexTextureImageUnits = mGLMaxVertexTextureImageUnits;
         resources.MaxCombinedTextureImageUnits = mGLMaxTextureUnits;
         resources.MaxTextureImageUnits = mGLMaxTextureImageUnits;
         resources.MaxFragmentUniformVectors = mGLMaxFragmentUniformVectors;
         resources.MaxDrawBuffers = mGLMaxDrawBuffers;
         if (IsExtensionEnabled(WebGLExtensionID::EXT_frag_depth))
             resources.EXT_frag_depth = 1;
         if (IsExtensionEnabled(WebGLExtensionID::OES_standard_derivatives))
             resources.OES_standard_derivatives = 1;
         if (IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers))
             resources.EXT_draw_buffers = 1;
         // Tell ANGLE to allow highp in frag shaders. (unless disabled)
         // If underlying GLES doesn't have highp in frag shaders, it should complain anyways.
         resources.FragmentPrecisionHigh = mDisableFragHighP ? 0 : 1;
         if (gl->WorkAroundDriverBugs()) {
 #ifdef XP_MACOSX
             if (gl->Vendor() == gl::GLVendor::NVIDIA) {
                 // Work around bug 890432
                 resources.MaxExpressionComplexity = 1000;
             }
 #endif
         }
         // We're storing an actual instance of StripComments because, if we don't, the
         // cleanSource nsAString instance will be destroyed before the reference is
         // actually used.
         StripComments stripComments(shader->Source());
         const nsAString& cleanSource = Substring(stripComments.result().Elements(), stripComments.length());
         if (!ValidateGLSLString(cleanSource, "compileShader"))
             return;
         // shaderSource() already checks that the source stripped of comments is in the
         // 7-bit ASCII range, so we can skip the NS_IsAscii() check.
         NS_LossyConvertUTF16toASCII sourceCString(cleanSource);
         if (gl->WorkAroundDriverBugs()) {
             const uint32_t maxSourceLength = 0x3ffff;
             if (sourceCString.Length() > maxSourceLength)
                 return ErrorInvalidValue("compileShader: source has more than %d characters",
                                          maxSourceLength);
         }
         const char *s = sourceCString.get();
 #define WEBGL2_BYPASS_ANGLE
 #ifdef WEBGL2_BYPASS_ANGLE
         /*
          * The bypass don't bring a full support for GLSL ES 3.0, but the main purpose
          * is to natively bring gl_InstanceID (to do instanced rendering) and gl_FragData
          *
          * To remove the bypass code, just comment #define WEBGL2_BYPASS_ANGLE above
          *
          * To bypass angle, the context must be a WebGL 2 and the shader must have the
          * following line at the very top :
          *      #version proto-200
          *
          * In this case, byPassANGLE == true and here is what we do :
          *  We create two shader source code:
          *    - one for the driver, that enable GL_EXT_gpu_shader4
          *    - one for the angle compilor, to get informations about vertex attributes
          *      and uniforms
          */
         static const char *bypassPrefixSearch = "#version proto-200";
         static const char *bypassANGLEPrefix[2] = {"precision mediump float;\n"
                                                    "#define gl_VertexID 0\n"
                                                    "#define gl_InstanceID 0\n",
                                                    "precision mediump float;\n"
                                                    "#extension GL_EXT_draw_buffers : enable\n"
                                                    "#define gl_PrimitiveID 0\n"};
         const bool bypassANGLE = IsWebGL2() && (strstr(s, bypassPrefixSearch) != 0);
         const char *angleShaderCode = s;
         nsTArray<char> bypassANGLEShaderCode;
         nsTArray<char> bypassDriverShaderCode;
         if (bypassANGLE) {
             const int bypassStage = (shader->ShaderType() == LOCAL_GL_FRAGMENT_SHADER) ? 1 : 0;
             const char *originalShader = strstr(s, bypassPrefixSearch) + strlen(bypassPrefixSearch);
             int originalShaderSize = strlen(s) - (originalShader - s);
             int bypassShaderCodeSize = originalShaderSize + 4096 + 1;
             bypassANGLEShaderCode.SetLength(bypassShaderCodeSize);
             strcpy(bypassANGLEShaderCode.Elements(), bypassANGLEPrefix[bypassStage]);
             strcat(bypassANGLEShaderCode.Elements(), originalShader);
             bypassDriverShaderCode.SetLength(bypassShaderCodeSize);
             strcpy(bypassDriverShaderCode.Elements(), "#extension GL_EXT_gpu_shader4 : enable\n");
             strcat(bypassDriverShaderCode.Elements(), originalShader);
             angleShaderCode = bypassANGLEShaderCode.Elements();
         }
 #endif
         compiler = ShConstructCompiler((ShShaderType) shader->ShaderType(),
                                        SH_WEBGL_SPEC,
                                        targetShaderSourceLanguage,
                                        &resources);
         int compileOptions = SH_ATTRIBUTES_UNIFORMS |
                              SH_ENFORCE_PACKING_RESTRICTIONS;
         if (resources.MaxExpressionComplexity > 0) {
             compileOptions |= SH_LIMIT_EXPRESSION_COMPLEXITY;
         }
         // We want to do this everywhere, but:
 #ifndef XP_MACOSX // To do this on Mac, we need to do it only on Mac OSX > 10.6 as this
                   // causes the shader compiler in 10.6 to crash
         compileOptions |= SH_CLAMP_INDIRECT_ARRAY_BOUNDS;
 #endif
         if (useShaderSourceTranslation) {
             compileOptions |= SH_OBJECT_CODE
                             | SH_MAP_LONG_VARIABLE_NAMES;
 #ifdef XP_MACOSX
             if (gl->WorkAroundDriverBugs()) {
                 // Work around bug 665578 and bug 769810
                 if (gl->Vendor() == gl::GLVendor::ATI) {
                     compileOptions |= SH_EMULATE_BUILT_IN_FUNCTIONS;
                 }
                 // Work around bug 735560
                 if (gl->Vendor() == gl::GLVendor::Intel) {
                     compileOptions |= SH_EMULATE_BUILT_IN_FUNCTIONS;
                 }
             }
 #endif
         }
 #ifdef WEBGL2_BYPASS_ANGLE
         if (!ShCompile(compiler, &angleShaderCode, 1, compileOptions)) {
 #else
         if (!ShCompile(compiler, &s, 1, compileOptions)) {
 #endif
             size_t lenWithNull = 0;
             ShGetInfo(compiler, SH_INFO_LOG_LENGTH, &lenWithNull);
             if (!lenWithNull) {
                 // Error in ShGetInfo.
                 shader->SetTranslationFailure(NS_LITERAL_CSTRING("Internal error: failed to get shader info log"));
             } else {
                 size_t len = lenWithNull - 1;
                 nsAutoCString info;
                 info.SetLength(len); // Allocates len+1, for the null-term.
                 ShGetInfoLog(compiler, info.BeginWriting());
                 shader->SetTranslationFailure(info);
             }
             ShDestruct(compiler);
             shader->SetCompileStatus(false);
             return;
         }
         size_t num_attributes = 0;
         ShGetInfo(compiler, SH_ACTIVE_ATTRIBUTES, &num_attributes);
         size_t num_uniforms = 0;
         ShGetInfo(compiler, SH_ACTIVE_UNIFORMS, &num_uniforms);
         size_t attrib_max_length = 0;
         ShGetInfo(compiler, SH_ACTIVE_ATTRIBUTE_MAX_LENGTH, &attrib_max_length);
         size_t uniform_max_length = 0;
         ShGetInfo(compiler, SH_ACTIVE_UNIFORM_MAX_LENGTH, &uniform_max_length);
         size_t mapped_max_length = 0;
         ShGetInfo(compiler, SH_MAPPED_NAME_MAX_LENGTH, &mapped_max_length);
         shader->mAttribMaxNameLength = attrib_max_length;
         shader->mAttributes.Clear();
         shader->mUniforms.Clear();
         shader->mUniformInfos.Clear();
         nsAutoArrayPtr<char> attribute_name(new char[attrib_max_length+1]);
         nsAutoArrayPtr<char> uniform_name(new char[uniform_max_length+1]);
         nsAutoArrayPtr<char> mapped_name(new char[mapped_max_length+1]);
         for (size_t i = 0; i < num_uniforms; i++) {
             size_t length;
             int size;
             ShDataType type;
             ShGetActiveUniform(compiler, (int)i,
                                 &length, &size, &type,
                                 uniform_name,
                                 mapped_name);
             if (useShaderSourceTranslation) {
                 shader->mUniforms.AppendElement(WebGLMappedIdentifier(
                                                     nsDependentCString(uniform_name),
                                                     nsDependentCString(mapped_name)));
             }
             // we always query uniform info, regardless of useShaderSourceTranslation,
             // as we need it to validate uniform setter calls, and it doesn't rely on
             // shader translation.
             char mappedNameLength = strlen(mapped_name);
             char mappedNameLastChar = mappedNameLength > 1
                                       ? mapped_name[mappedNameLength - 1]
                                       : 0;
             shader->mUniformInfos.AppendElement(WebGLUniformInfo(
                                                     size,
                                                     mappedNameLastChar == ']',
                                                     type));
         }
         if (useShaderSourceTranslation) {
             for (size_t i = 0; i < num_attributes; i++) {
                 size_t length;
                 int size;
                 ShDataType type;
                 ShGetActiveAttrib(compiler, (int)i,
                                   &length, &size, &type,
                                   attribute_name,
                                   mapped_name);
                 shader->mAttributes.AppendElement(WebGLMappedIdentifier(
                                                     nsDependentCString(attribute_name),
                                                     nsDependentCString(mapped_name)));
             }
             size_t lenWithNull = 0;
             ShGetInfo(compiler, SH_OBJECT_CODE_LENGTH, &lenWithNull);
             MOZ_ASSERT(lenWithNull >= 1);
             size_t len = lenWithNull - 1;
             nsAutoCString translatedSrc;
             translatedSrc.SetLength(len); // Allocates len+1, for the null-term.
             ShGetObjectCode(compiler, translatedSrc.BeginWriting());
             CopyASCIItoUTF16(translatedSrc, shader->mTranslatedSource);
             const char *ts = translatedSrc.get();
 #ifdef WEBGL2_BYPASS_ANGLE
             if (bypassANGLE) {
                 const char* driverShaderCode = bypassDriverShaderCode.Elements();
                 gl->fShaderSource(shadername, 1, (const GLchar**) &driverShaderCode, nullptr);
             }
             else {
                 gl->fShaderSource(shadername, 1, &ts, nullptr);
             }
 #else
             gl->fShaderSource(shadername, 1, &ts, nullptr);
 #endif
         } else { // not useShaderSourceTranslation
             // we just pass the raw untranslated shader source. We then can't use ANGLE idenfier mapping.
             // that's really bad, as that means we can't be 100% conformant. We should work towards always
             // using ANGLE identifier mapping.
             gl->fShaderSource(shadername, 1, &s, nullptr);
             CopyASCIItoUTF16(s, shader->mTranslatedSource);
         }
         shader->SetTranslationSuccess();
         ShDestruct(compiler);
         gl->fCompileShader(shadername);
         GLint ok;
         gl->fGetShaderiv(shadername, LOCAL_GL_COMPILE_STATUS, &ok);
         shader->SetCompileStatus(ok);
     }
 }
 void
 WebGLContext::CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat,
                                    GLsizei width, GLsizei height, GLint border,
                                    const ArrayBufferView& view)
 {
     if (IsContextLost())
         return;
     const WebGLTexImageFunc func = WebGLTexImageFunc::CompTexImage;
     if (!ValidateTexImage(2, target, level, internalformat,
 , 0, 0, width, height, 0,
                           border, internalformat, LOCAL_GL_UNSIGNED_BYTE,
                           func))
     {
         return;
     }
     view.ComputeLengthAndData();
     uint32_t byteLength = view.Length();
     if (!ValidateCompTexImageDataSize(target, internalformat, width, height, byteLength, func)) {
         return;
     }
     if (!ValidateCompTexImageSize(target, level, internalformat, 0, 0,
                                   width, height, width, height, func))
     {
         return;
     }
     MakeContextCurrent();
     gl->fCompressedTexImage2D(target, level, internalformat, width, height, border, byteLength, view.Data());
     WebGLTexture* tex = activeBoundTextureForTarget(target);
     MOZ_ASSERT(tex);
     tex->SetImageInfo(target, level, width, height, internalformat, LOCAL_GL_UNSIGNED_BYTE,
                       WebGLImageDataStatus::InitializedImageData);
 }
 void
 WebGLContext::CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
                                       GLint yoffset, GLsizei width, GLsizei height,
                                       GLenum format, const ArrayBufferView& view)
 {
     if (IsContextLost())
         return;
     const WebGLTexImageFunc func = WebGLTexImageFunc::CompTexSubImage;
     if (!ValidateTexImage(2, target,
                           level, format,
                           xoffset, yoffset, 0,
                           width, height, 0,
 , format, LOCAL_GL_UNSIGNED_BYTE,
                           func))
     {
         return;
     }
     WebGLTexture *tex = activeBoundTextureForTarget(target);
     MOZ_ASSERT(tex);
     WebGLTexture::ImageInfo& levelInfo = tex->ImageInfoAt(target, level);
     view.ComputeLengthAndData();
     uint32_t byteLength = view.Length();
     if (!ValidateCompTexImageDataSize(target, format, width, height, byteLength, func))
         return;
     if (!ValidateCompTexImageSize(target, level, format,
                                   xoffset, yoffset,
                                   width, height,
                                   levelInfo.Width(), levelInfo.Height(),
                                   func))
     {
         return;
     }
     if (levelInfo.HasUninitializedImageData())
         tex->DoDeferredImageInitialization(target, level);
     MakeContextCurrent();
     gl->fCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, byteLength, view.Data());
 }
 JS::Value
 WebGLContext::GetShaderParameter(WebGLShader *shader, GLenum pname)
 {
     if (IsContextLost())
         return JS::NullValue();
     if (!ValidateObject("getShaderParameter: shader", shader))
         return JS::NullValue();
     GLuint shadername = shader->GLName();
     MakeContextCurrent();
     switch (pname) {
         case LOCAL_GL_SHADER_TYPE:
         {
             GLint i = 0;
             gl->fGetShaderiv(shadername, pname, &i);
             return JS::NumberValue(uint32_t(i));
         }
             break;
         case LOCAL_GL_DELETE_STATUS:
             return JS::BooleanValue(shader->IsDeleteRequested());
             break;
         case LOCAL_GL_COMPILE_STATUS:
         {
             GLint i = 0;
             gl->fGetShaderiv(shadername, pname, &i);
             return JS::BooleanValue(bool(i));
         }
             break;
         default:
             ErrorInvalidEnumInfo("getShaderParameter: parameter", pname);
     }
     return JS::NullValue();
 }
 void
 WebGLContext::GetShaderInfoLog(WebGLShader *shader, nsAString& retval)
 {
     nsAutoCString s;
     GetShaderInfoLog(shader, s);
     if (s.IsVoid())
         retval.SetIsVoid(true);
     else
         CopyASCIItoUTF16(s, retval);
 }
 void
 WebGLContext::GetShaderInfoLog(WebGLShader *shader, nsACString& retval)
 {
     if (IsContextLost())
     {
         retval.SetIsVoid(true);
         return;
     }
     if (!ValidateObject("getShaderInfoLog: shader", shader))
         return;
     retval = shader->TranslationLog();
     if (!retval.IsVoid()) {
         return;
     }
     MakeContextCurrent();
     GLuint shadername = shader->GLName();
     GLint k = -1;
     gl->fGetShaderiv(shadername, LOCAL_GL_INFO_LOG_LENGTH, &k);
     if (k == -1) {
         // XXX GL Error? should never happen.
         return;
     }
     if (k == 0) {
         retval.Truncate();
         return;
     }
     retval.SetCapacity(k);
     gl->fGetShaderInfoLog(shadername, k, &k, (char*) retval.BeginWriting());
     retval.SetLength(k);
 }
 already_AddRefed<WebGLShaderPrecisionFormat>
 WebGLContext::GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype)
 {
     if (IsContextLost())
         return nullptr;
     switch (shadertype) {
         case LOCAL_GL_FRAGMENT_SHADER:
         case LOCAL_GL_VERTEX_SHADER:
             break;
         default:
             ErrorInvalidEnumInfo("getShaderPrecisionFormat: shadertype", shadertype);
             return nullptr;
     }
     switch (precisiontype) {
         case LOCAL_GL_LOW_FLOAT:
         case LOCAL_GL_MEDIUM_FLOAT:
         case LOCAL_GL_HIGH_FLOAT:
         case LOCAL_GL_LOW_INT:
         case LOCAL_GL_MEDIUM_INT:
         case LOCAL_GL_HIGH_INT:
             break;
         default:
             ErrorInvalidEnumInfo("getShaderPrecisionFormat: precisiontype", precisiontype);
             return nullptr;
     }
     MakeContextCurrent();
     GLint range[2], precision;
     if (mDisableFragHighP &&
         shadertype == LOCAL_GL_FRAGMENT_SHADER &&
         (precisiontype == LOCAL_GL_HIGH_FLOAT ||
          precisiontype == LOCAL_GL_HIGH_INT))
     {
       precision = 0;
       range[0] = 0;
       range[1] = 0;
     } else {
       gl->fGetShaderPrecisionFormat(shadertype, precisiontype, range, &precision);
     }
     nsRefPtr<WebGLShaderPrecisionFormat> retShaderPrecisionFormat
         = new WebGLShaderPrecisionFormat(this, range[0], range[1], precision);
     return retShaderPrecisionFormat.forget();
 }
 void
 WebGLContext::GetShaderSource(WebGLShader *shader, nsAString& retval)
 {
     if (IsContextLost()) {
         retval.SetIsVoid(true);
         return;
     }
     if (!ValidateObject("getShaderSource: shader", shader))
         return;
     retval.Assign(shader->Source());
 }
 void
 WebGLContext::ShaderSource(WebGLShader *shader, const nsAString& source)
 {
     if (IsContextLost())
         return;
     if (!ValidateObject("shaderSource: shader", shader))
         return;
     // We're storing an actual instance of StripComments because, if we don't, the
     // cleanSource nsAString instance will be destroyed before the reference is
     // actually used.
     StripComments stripComments(source);
     const nsAString& cleanSource = Substring(stripComments.result().Elements(), stripComments.length());
     if (!ValidateGLSLString(cleanSource, "compileShader"))
         return;
     shader->SetSource(source);
     shader->SetNeedsTranslation();
 }
 void
 WebGLContext::GetShaderTranslatedSource(WebGLShader *shader, nsAString& retval)
 {
     if (IsContextLost()) {
         retval.SetIsVoid(true);
         return;
     }
     if (!ValidateObject("getShaderTranslatedSource: shader", shader))
         return;
     retval.Assign(shader->TranslatedSource());
 }
 GLenum WebGLContext::CheckedTexImage2D(GLenum target,
                                        GLint level,
                                        GLenum internalFormat,
                                        GLsizei width,
                                        GLsizei height,
                                        GLint border,
                                        GLenum format,
                                        GLenum type,
                                        const GLvoid *data)
 {
     MOZ_ASSERT(internalFormat == format);
     WebGLTexture *tex = activeBoundTextureForTarget(target);
     MOZ_ASSERT(tex != nullptr, "no texture bound");
     bool sizeMayChange = true;
     if (tex->HasImageInfoAt(target, level)) {
         const WebGLTexture::ImageInfo& imageInfo = tex->ImageInfoAt(target, level);
         sizeMayChange = width != imageInfo.Width() ||
                         height != imageInfo.Height() ||
                         format != imageInfo.WebGLFormat() ||
                         type != imageInfo.WebGLType();
     }
     // Convert to format and type required by OpenGL 'driver'.
     GLenum driverType = DriverTypeFromType(gl, type);
     GLenum driverInternalFormat = LOCAL_GL_NONE;
     GLenum driverFormat = LOCAL_GL_NONE;
     DriverFormatsFromFormatAndType(gl, format, type, &driverInternalFormat, &driverFormat);
     if (sizeMayChange) {
         GetAndFlushUnderlyingGLErrors();
     }
     gl->fTexImage2D(target, level, driverInternalFormat, width, height, border, driverFormat, driverType, data);
     GLenum error = LOCAL_GL_NO_ERROR;
     if (sizeMayChange) {
         error = GetAndFlushUnderlyingGLErrors();
     }
     return error;
 }
 void
 WebGLContext::TexImage2D_base(GLenum target, GLint level, GLenum internalformat,
                               GLsizei width, GLsizei height, GLsizei srcStrideOrZero,
                               GLint border,
                               GLenum format, GLenum type,
                               void* data, uint32_t byteLength,
                               int jsArrayType, // a TypedArray format enum, or -1 if not relevant
                               WebGLTexelFormat srcFormat, bool srcPremultiplied)
 {
     const WebGLTexImageFunc func = WebGLTexImageFunc::TexImage;
     if (!ValidateTexImage(2, target, level, internalformat,
 , 0, 0,
                           width, height, 0,
                           border, format, type, func))
     {
         return;
     }
     const bool isDepthTexture = format == LOCAL_GL_DEPTH_COMPONENT ||
                                 format == LOCAL_GL_DEPTH_STENCIL;
     if (isDepthTexture) {
         if (data != nullptr || level != 0)
             return ErrorInvalidOperation("texImage2D: "
                                          "with format of DEPTH_COMPONENT or DEPTH_STENCIL, "
                                          "data must be nullptr, "
                                          "level must be zero");
     }
     if (!ValidateTexInputData(type, jsArrayType, func))
         return;
     WebGLTexelFormat dstFormat = GetWebGLTexelFormat(format, type);
     WebGLTexelFormat actualSrcFormat = srcFormat == WebGLTexelFormat::Auto ? dstFormat : srcFormat;
     uint32_t srcTexelSize = WebGLTexelConversions::TexelBytesForFormat(actualSrcFormat);
     CheckedUint32 checked_neededByteLength =
         GetImageSize(height, width, srcTexelSize, mPixelStoreUnpackAlignment);
     CheckedUint32 checked_plainRowSize = CheckedUint32(width) * srcTexelSize;
     CheckedUint32 checked_alignedRowSize =
         RoundedToNextMultipleOf(checked_plainRowSize.value(), mPixelStoreUnpackAlignment);
     if (!checked_neededByteLength.isValid())
         return ErrorInvalidOperation("texImage2D: integer overflow computing the needed buffer size");
     uint32_t bytesNeeded = checked_neededByteLength.value();
     if (byteLength && byteLength < bytesNeeded)
         return ErrorInvalidOperation("texImage2D: not enough data for operation (need %d, have %d)",
                                  bytesNeeded, byteLength);
     WebGLTexture *tex = activeBoundTextureForTarget(target);
     if (!tex)
         return ErrorInvalidOperation("texImage2D: no texture is bound to this target");
     MakeContextCurrent();
     nsAutoArrayPtr<uint8_t> convertedData;
     void* pixels = nullptr;
     WebGLImageDataStatus imageInfoStatusIfSuccess = WebGLImageDataStatus::UninitializedImageData;
     if (byteLength) {
         size_t   srcStride = srcStrideOrZero ? srcStrideOrZero : checked_alignedRowSize.value();
         uint32_t dstTexelSize = GetBitsPerTexel(format, type) / 8;
         size_t   dstPlainRowSize = dstTexelSize * width;
         size_t   unpackAlignment = mPixelStoreUnpackAlignment;
         size_t   dstStride = ((dstPlainRowSize + unpackAlignment-1) / unpackAlignment) * unpackAlignment;
         if (actualSrcFormat == dstFormat &&
             srcPremultiplied == mPixelStorePremultiplyAlpha &&
             srcStride == dstStride &&
             !mPixelStoreFlipY)
         {
             // no conversion, no flipping, so we avoid copying anything and just pass the source pointer
             pixels = data;
         }
         else
         {
             size_t convertedDataSize = height * dstStride;
             convertedData = new uint8_t[convertedDataSize];
             ConvertImage(width, height, srcStride, dstStride,
                         static_cast<uint8_t*>(data), convertedData,
                         actualSrcFormat, srcPremultiplied,
                         dstFormat, mPixelStorePremultiplyAlpha, dstTexelSize);
             pixels = reinterpret_cast<void*>(convertedData.get());
         }
         imageInfoStatusIfSuccess = WebGLImageDataStatus::InitializedImageData;
     }
     GLenum error = CheckedTexImage2D(target, level, internalformat, width,
                                      height, border, format, type, pixels);
     if (error) {
         GenerateWarning("texImage2D generated error %s", ErrorName(error));
         return;
     }
     // in all of the code paths above, we should have either initialized data,
     // or allocated data and left it uninitialized, but in any case we shouldn't
     // have NoImageData at this point.
     MOZ_ASSERT(imageInfoStatusIfSuccess != WebGLImageDataStatus::NoImageData);
     tex->SetImageInfo(target, level, width, height, format, type, imageInfoStatusIfSuccess);
 }
 void
 WebGLContext::TexImage2D(GLenum target, GLint level,
                          GLenum internalformat, GLsizei width,
                          GLsizei height, GLint border, GLenum format,
                          GLenum type, const Nullable<ArrayBufferView> &pixels, ErrorResult& rv)
 {
     if (IsContextLost())
         return;
     void* data;
     uint32_t length;
     int jsArrayType;
     if (pixels.IsNull()) {
         data = nullptr;
         length = 0;
         jsArrayType = -1;
     } else {
         const ArrayBufferView& view = pixels.Value();
         view.ComputeLengthAndData();
         data = view.Data();
         length = view.Length();
         jsArrayType = int(JS_GetArrayBufferViewType(view.Obj()));
     }
     return TexImage2D_base(target, level, internalformat, width, height, 0, border, format, type,
                            data, length, jsArrayType,
                            WebGLTexelFormat::Auto, false);
 }
 void
 WebGLContext::TexImage2D(GLenum target, GLint level,
                          GLenum internalformat, GLenum format,
                          GLenum type, ImageData* pixels, ErrorResult& rv)
 {
     if (IsContextLost())
         return;
     if (!pixels) {
         // Spec says to generate an INVALID_VALUE error
         return ErrorInvalidValue("texImage2D: null ImageData");
     }
     Uint8ClampedArray arr(pixels->GetDataObject());
     arr.ComputeLengthAndData();
     return TexImage2D_base(target, level, internalformat, pixels->Width(),
                            pixels->Height(), 4*pixels->Width(), 0,
                            format, type, arr.Data(), arr.Length(), -1,
                            WebGLTexelFormat::RGBA8, false);
 }
 void
 WebGLContext::TexSubImage2D_base(GLenum target, GLint level,
                                  GLint xoffset, GLint yoffset,
                                  GLsizei width, GLsizei height, GLsizei srcStrideOrZero,
                                  GLenum format, GLenum type,
                                  void* data, uint32_t byteLength,
                                  int jsArrayType,
                                  WebGLTexelFormat srcFormat, bool srcPremultiplied)
 {
     const WebGLTexImageFunc func = WebGLTexImageFunc::TexSubImage;
     if (!ValidateTexImage(2, target, level, format,
                           xoffset, yoffset, 0,
                           width, height, 0,
 , format, type, func))
     {
         return;
     }
     if (!ValidateTexInputData(type, jsArrayType, func))
         return;
     WebGLTexelFormat dstFormat = GetWebGLTexelFormat(format, type);
     WebGLTexelFormat actualSrcFormat = srcFormat == WebGLTexelFormat::Auto ? dstFormat : srcFormat;
     uint32_t srcTexelSize = WebGLTexelConversions::TexelBytesForFormat(actualSrcFormat);
     if (width == 0 || height == 0)
         return; // ES 2.0 says it has no effect, we better return right now
     CheckedUint32 checked_neededByteLength =
         GetImageSize(height, width, srcTexelSize, mPixelStoreUnpackAlignment);
     CheckedUint32 checked_plainRowSize = CheckedUint32(width) * srcTexelSize;
     CheckedUint32 checked_alignedRowSize =
         RoundedToNextMultipleOf(checked_plainRowSize.value(), mPixelStoreUnpackAlignment);
     if (!checked_neededByteLength.isValid())
         return ErrorInvalidOperation("texSubImage2D: integer overflow computing the needed buffer size");
     uint32_t bytesNeeded = checked_neededByteLength.value();
     if (byteLength < bytesNeeded)
         return ErrorInvalidOperation("texSubImage2D: not enough data for operation (need %d, have %d)", bytesNeeded, byteLength);
     WebGLTexture *tex = activeBoundTextureForTarget(target);
     const WebGLTexture::ImageInfo &imageInfo = tex->ImageInfoAt(target, level);
     if (imageInfo.HasUninitializedImageData())
         tex->DoDeferredImageInitialization(target, level);
     MakeContextCurrent();
     size_t   srcStride = srcStrideOrZero ? srcStrideOrZero : checked_alignedRowSize.value();
     uint32_t dstTexelSize = GetBitsPerTexel(format, type) / 8;
     size_t   dstPlainRowSize = dstTexelSize * width;
     // There are checks above to ensure that this won't overflow.
     size_t   dstStride = RoundedToNextMultipleOf(dstPlainRowSize, mPixelStoreUnpackAlignment).value();
     void* pixels = data;
     nsAutoArrayPtr<uint8_t> convertedData;
     // no conversion, no flipping, so we avoid copying anything and just pass the source pointer
     bool noConversion = (actualSrcFormat == dstFormat &&
                          srcPremultiplied == mPixelStorePremultiplyAlpha &&
                          srcStride == dstStride &&
                          !mPixelStoreFlipY);
     if (!noConversion) {
         size_t convertedDataSize = height * dstStride;
         convertedData = new uint8_t[convertedDataSize];
         ConvertImage(width, height, srcStride, dstStride,
                     static_cast<const uint8_t*>(data), convertedData,
                     actualSrcFormat, srcPremultiplied,
                     dstFormat, mPixelStorePremultiplyAlpha, dstTexelSize);
         pixels = reinterpret_cast<void*>(convertedData.get());
     }
     GLenum driverType = DriverTypeFromType(gl, type);
     GLenum driverInternalFormat = LOCAL_GL_NONE;
     GLenum driverFormat = LOCAL_GL_NONE;
     DriverFormatsFromFormatAndType(gl, format, type, &driverInternalFormat, &driverFormat);
     gl->fTexSubImage2D(target, level, xoffset, yoffset, width, height, driverFormat, driverType, pixels);
 }
 void
 WebGLContext::TexSubImage2D(GLenum target, GLint level,
                             GLint xoffset, GLint yoffset,
                             GLsizei width, GLsizei height,
                             GLenum format, GLenum type,
                             const Nullable<ArrayBufferView> &pixels,
                             ErrorResult& rv)
 {
     if (IsContextLost())
         return;
     if (pixels.IsNull())
         return ErrorInvalidValue("texSubImage2D: pixels must not be null!");
     const ArrayBufferView& view = pixels.Value();
     view.ComputeLengthAndData();
     return TexSubImage2D_base(target, level, xoffset, yoffset,
                               width, height, 0, format, type,
                               view.Data(), view.Length(),
                               JS_GetArrayBufferViewType(view.Obj()),
                               WebGLTexelFormat::Auto, false);
 }
 void
 WebGLContext::TexSubImage2D(GLenum target, GLint level,
                             GLint xoffset, GLint yoffset,
                             GLenum format, GLenum type, ImageData* pixels,
                             ErrorResult& rv)
 {
     if (IsContextLost())
         return;
     if (!pixels)
         return ErrorInvalidValue("texSubImage2D: pixels must not be null!");
     Uint8ClampedArray arr(pixels->GetDataObject());
     arr.ComputeLengthAndData();
     return TexSubImage2D_base(target, level, xoffset, yoffset,
                               pixels->Width(), pixels->Height(),
 *pixels->Width(), format, type,
                               arr.Data(), arr.Length(),
                               -1,
                               WebGLTexelFormat::RGBA8, false);
 }
 bool
 WebGLContext::LoseContext()
 {
     if (IsContextLost())
         return false;
     ForceLoseContext();
     return true;
 }
 bool
 WebGLContext::RestoreContext()
 {
     if (!IsContextLost() || !mAllowRestore) {
         return false;
     }
     ForceRestoreContext();
     return true;
 }
 bool
 BaseTypeAndSizeFromUniformType(GLenum uType, GLenum *baseType, GLint *unitSize)
 {
     switch (uType) {
         case LOCAL_GL_INT:
         case LOCAL_GL_INT_VEC2:
         case LOCAL_GL_INT_VEC3:
         case LOCAL_GL_INT_VEC4:
         case LOCAL_GL_SAMPLER_2D:
         case LOCAL_GL_SAMPLER_CUBE:
             *baseType = LOCAL_GL_INT;
             break;
         case LOCAL_GL_FLOAT:
         case LOCAL_GL_FLOAT_VEC2:
         case LOCAL_GL_FLOAT_VEC3:
         case LOCAL_GL_FLOAT_VEC4:
         case LOCAL_GL_FLOAT_MAT2:
         case LOCAL_GL_FLOAT_MAT3:
         case LOCAL_GL_FLOAT_MAT4:
             *baseType = LOCAL_GL_FLOAT;
             break;
         case LOCAL_GL_BOOL:
         case LOCAL_GL_BOOL_VEC2:
         case LOCAL_GL_BOOL_VEC3:
         case LOCAL_GL_BOOL_VEC4:
             *baseType = LOCAL_GL_BOOL; // pretend these are int
             break;
         default:
             return false;
     }
     switch (uType) {
         case LOCAL_GL_INT:
         case LOCAL_GL_FLOAT:
         case LOCAL_GL_BOOL:
         case LOCAL_GL_SAMPLER_2D:
         case LOCAL_GL_SAMPLER_CUBE:
             *unitSize = 1;
             break;
         case LOCAL_GL_INT_VEC2:
         case LOCAL_GL_FLOAT_VEC2:
         case LOCAL_GL_BOOL_VEC2:
             *unitSize = 2;
             break;
         case LOCAL_GL_INT_VEC3:
         case LOCAL_GL_FLOAT_VEC3:
         case LOCAL_GL_BOOL_VEC3:
             *unitSize = 3;
             break;
         case LOCAL_GL_INT_VEC4:
         case LOCAL_GL_FLOAT_VEC4:
         case LOCAL_GL_BOOL_VEC4:
             *unitSize = 4;
             break;
         case LOCAL_GL_FLOAT_MAT2:
             *unitSize = 4;
             break;
         case LOCAL_GL_FLOAT_MAT3:
             *unitSize = 9;
             break;
         case LOCAL_GL_FLOAT_MAT4:
             *unitSize = 16;
             break;
         default:
             return false;
     }
     return true;
 }
 WebGLTexelFormat mozilla::GetWebGLTexelFormat(GLenum internalformat, GLenum type)
 {
     //
     // WEBGL_depth_texture
     if (internalformat == LOCAL_GL_DEPTH_COMPONENT) {
         switch (type) {
             case LOCAL_GL_UNSIGNED_SHORT:
                 return WebGLTexelFormat::D16;
             case LOCAL_GL_UNSIGNED_INT:
                 return WebGLTexelFormat::D32;
         }
         MOZ_CRASH("Invalid WebGL texture format/type?");
     }
     if (internalformat == LOCAL_GL_DEPTH_STENCIL) {
         switch (type) {
             case LOCAL_GL_UNSIGNED_INT_24_8_EXT:
                 return WebGLTexelFormat::D24S8;
         }
         MOZ_CRASH("Invalid WebGL texture format/type?");
     }
     if (internalformat == LOCAL_GL_DEPTH_COMPONENT16) {
         return WebGLTexelFormat::D16;
     }
     if (internalformat == LOCAL_GL_DEPTH_COMPONENT32) {
         return WebGLTexelFormat::D32;
     }
     if (internalformat == LOCAL_GL_DEPTH24_STENCIL8) {
         return WebGLTexelFormat::D24S8;
     }
     if (type == LOCAL_GL_UNSIGNED_BYTE) {
         switch (internalformat) {
             case LOCAL_GL_RGBA:
             case LOCAL_GL_SRGB_ALPHA_EXT:
                 return WebGLTexelFormat::RGBA8;
             case LOCAL_GL_RGB:
             case LOCAL_GL_SRGB_EXT:
                 return WebGLTexelFormat::RGB8;
             case LOCAL_GL_ALPHA:
                 return WebGLTexelFormat::A8;
             case LOCAL_GL_LUMINANCE:
                 return WebGLTexelFormat::R8;
             case LOCAL_GL_LUMINANCE_ALPHA:
                 return WebGLTexelFormat::RA8;
         }
         MOZ_CRASH("Invalid WebGL texture format/type?");
     }
     if (type == LOCAL_GL_FLOAT) {
         // OES_texture_float
         switch (internalformat) {
             case LOCAL_GL_RGBA:
             case LOCAL_GL_RGBA32F:
                 return WebGLTexelFormat::RGBA32F;
             case LOCAL_GL_RGB:
             case LOCAL_GL_RGB32F:
                 return WebGLTexelFormat::RGB32F;
             case LOCAL_GL_ALPHA:
             case LOCAL_GL_ALPHA32F_ARB:
                 return WebGLTexelFormat::A32F;
             case LOCAL_GL_LUMINANCE:
             case LOCAL_GL_LUMINANCE32F_ARB:
                 return WebGLTexelFormat::R32F;
             case LOCAL_GL_LUMINANCE_ALPHA:
             case LOCAL_GL_LUMINANCE_ALPHA32F_ARB:
                 return WebGLTexelFormat::RA32F;
         }
         MOZ_CRASH("Invalid WebGL texture format/type?");
     } else if (type == LOCAL_GL_HALF_FLOAT_OES) {
         // OES_texture_half_float
         switch (internalformat) {
             case LOCAL_GL_RGBA:
             case LOCAL_GL_RGBA16F:
                 return WebGLTexelFormat::RGBA16F;
             case LOCAL_GL_RGB:
             case LOCAL_GL_RGB16F:
                 return WebGLTexelFormat::RGB16F;
             case LOCAL_GL_ALPHA:
             case LOCAL_GL_ALPHA16F_ARB:
                 return WebGLTexelFormat::A16F;
             case LOCAL_GL_LUMINANCE:
             case LOCAL_GL_LUMINANCE16F_ARB:
                 return WebGLTexelFormat::R16F;
             case LOCAL_GL_LUMINANCE_ALPHA:
             case LOCAL_GL_LUMINANCE_ALPHA16F_ARB:
                 return WebGLTexelFormat::RA16F;
             default:
                 MOZ_ASSERT(false, "Coding mistake?! Should never reach this point.");
                 return WebGLTexelFormat::BadFormat;
         }
     }
     switch (type) {
         case LOCAL_GL_UNSIGNED_SHORT_4_4_4_4:
            return WebGLTexelFormat::RGBA4444;
         case LOCAL_GL_UNSIGNED_SHORT_5_5_5_1:
            return WebGLTexelFormat::RGBA5551;
         case LOCAL_GL_UNSIGNED_SHORT_5_6_5:
            return WebGLTexelFormat::RGB565;
         default:
             MOZ_ASSERT(false, "Coding mistake?! Should never reach this point.");
             return WebGLTexelFormat::BadFormat;
     }
     MOZ_CRASH("Invalid WebGL texture format/type?");
 }
 void
 WebGLContext::BlendColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a) {
     if (IsContextLost())
         return;
     MakeContextCurrent();
     gl->fBlendColor(r, g, b, a);
 }
 void
 WebGLContext::Flush() {
     if (IsContextLost())
         return;
     MakeContextCurrent();
     gl->fFlush();
 }
 void
 WebGLContext::Finish() {
     if (IsContextLost())
         return;
     MakeContextCurrent();
     gl->fFinish();
 }
 void
 WebGLContext::LineWidth(GLfloat width) {
     if (IsContextLost())
         return;
     MakeContextCurrent();
     gl->fLineWidth(width);
 }
 void
 WebGLContext::PolygonOffset(GLfloat factor, GLfloat units) {
     if (IsContextLost())
         return;
     MakeContextCurrent();
     gl->fPolygonOffset(factor, units);
 }
 void
 WebGLContext::SampleCoverage(GLclampf value, WebGLboolean invert) {
     if (IsContextLost())
         return;
     MakeContextCurrent();
     gl->fSampleCoverage(value, invert);
 }

The Tor Browser / annotate

content/canvas/src/WebGLContextGL.cpp@deefc01c0e14 (annotated)

content/canvas/src/WebGLContextGL.cpp