Name Description Size
CacheInvalidator.cpp 1295
CacheInvalidator.h 4336
CanvasGradient.cpp 507
CanvasGradient.h 1722
CanvasImageCache.cpp Used for images specific to this one canvas. Required due to CORS security. 12305
CanvasImageCache.h Notify that image element aImage was drawn to aContext canvas using the first frame of aRequest's image. The data for the surface is in aSurface, and the image size is in aSize. aIntrinsicSize is the size the surface is intended to be rendered at. 2475
CanvasPath.h CanvasPath_h 3481
CanvasPattern.cpp 851
CanvasPattern.h 1769
CanvasRenderingContext2D.cpp Memory reporter stuff 236489
CanvasRenderingContext2D.h CanvasRenderingContext2D 41863
CanvasRenderingContextHelper.cpp 11382
CanvasRenderingContextHelper.h Povides common RenderingContext functionality used by both OffscreenCanvas and HTMLCanvasElement. 3289
CanvasUtils.cpp There are three RFPTargets that change the behavior here, and they can be in any combination - CanvasImageExtractionPrompt - whether or not to prompt the user for canvas extraction. If enabled, before canvas is extracted we will ensure the user has granted permission. - CanvasExtractionBeforeUserInputIsBlocked - if enabled, canvas extraction before user input has occurred is always blocked, regardless of any other Target behavior - CanvasExtractionFromThirdPartiesIsBlocked - if enabled, canvas extraction by third parties is always blocked, regardless of any other Target behavior There are two odd cases: 1) When CanvasImageExtractionPrompt=false but CanvasExtractionBeforeUserInputIsBlocked=true Conceptually this is "Always allow canvas extraction in response to user input, and never allow it otherwise" That's fine as a concept, but it might be a little confusing, so we still want to show the permission icon in the address bar, but never the permission doorhanger. 2) When CanvasExtractionFromThirdPartiesIsBlocked=false - we will prompt the user for permission _for the frame_ (maybe with the doorhanger, maybe not). The prompt shows the frame's origin, but it's easy to mistake that for the origin of the top-level page and grant it when you don't mean to. This combination isn't likely to be used by anyone except those opting in, so that's alright. 17090
CanvasUtils.h Float validation stuff 6360
ClientWebGLContext.cpp 219339
ClientWebGLContext.h 86053
ClientWebGLExtensions.cpp 10152
ClientWebGLExtensions.h 15842
crashtests
DmdStdContainers.h 2329
DrawTargetWebgl.cpp 187223
DrawTargetWebgl.h 26938
DrawTargetWebglInternal.h 15598
GeneratePlaceholderCanvasData.h When privacy.resistFingerprinting.randomDataOnCanvasExtract is true, tries to generate random data for placeholder canvas by sampling RANDOM_BYTES_TO_SAMPLE bytes and then returning it. If this fails or if privacy.resistFingerprinting.randomDataOnCanvasExtract is false, returns nullptr. @return uint8_t* output buffer 3480
gtest
HostWebGLContext.cpp static 6010
HostWebGLContext.h Host endpoint of a WebGLContext. HostWebGLContext owns a WebGLContext that it uses to execute commands sent from its ClientWebGLContext. A HostWebGLContext continuously issues a Task to the Compositor thread that causes it to drain its queue of commands. It also maintains a map of WebGL objects (e.g. ObjectIdMap<WebGLShader>) that it uses associate them with their cross-process IDs. This class is not an implementation of the nsICanvasRenderingContextInternal DOM class. That is the ClientWebGLContext. 27325
ImageBitmap.cpp This class observes shutdown notifications and sends that notification to the worker thread if the image bitmap is on a worker thread. 80431
ImageBitmap.h ImageBitmap is an opaque handler to several kinds of image-like objects from HTMLImageElement, HTMLVideoElement, HTMLCanvasElement, ImageData to CanvasRenderingContext2D and Image Blob. An ImageBitmap could be painted to a canvas element. Generally, an ImageBitmap only keeps a reference to its source object's buffer, but if the source object is an ImageData, an Blob or a HTMLCanvasElement with WebGL rendering context, the ImageBitmap copy the source object's buffer. 10341
ImageBitmapRenderingContext.cpp 9418
ImageBitmapRenderingContext.h The purpose of ImageBitmapRenderingContext is to provide a faster and efficient way to display ImageBitmap. Simply call TransferFromImageBitmap() then we'll transfer the surface of ImageBitmap to this context and then to use it to display. See more details in spec: https://wiki.whatwg.org/wiki/OffscreenCanvas 3935
ImageBitmapSource.h 882
ImageData.cpp 4623
ImageData.h 2620
ImageUtils.cpp 6686
ImageUtils.h ImageUtils is a wrapper around layers::Image. It provides three unified methods to all sub-classes of layers::Image, which are: (1) GetFormat() converts the image's format into ImageBitmapFormat enum. (2) GetBufferLength() returns the number of bytes that are used to store the image's underlying raw data. In theory, the functionalities of this class could be merged into the interface of layers::Image. However, this is designed as a isolated wrapper because we don't want to pollute the layers::Image's interface with methods that are only meaningful to the ImageBitmap. 1869
moz.build 6069
MurmurHash3.cpp 8458
MurmurHash3.h 843
nsICanvasRenderingContextInternal.cpp 4862
nsICanvasRenderingContextInternal.h 8504
OffscreenCanvas.cpp static 20153
OffscreenCanvas.h 7072
OffscreenCanvasDisplayHelper.cpp 19384
OffscreenCanvasDisplayHelper.h 3666
OffscreenCanvasRenderingContext2D.cpp 4145
OffscreenCanvasRenderingContext2D.h 1783
PWebGL.ipdl Represents the connection between a WebGLChild actor that issues WebGL command from the content process, and a WebGLParent in the compositor process that runs the commands. 5392
QueueParamTraits.h QueueParamTraits provide the user with a way to implement PCQ argument (de)serialization. It uses a PcqView, which permits the system to abandon all changes to the underlying PCQ if any operation fails. The transactional nature of PCQ operations make the ideal behavior a bit complex. Since the PCQ has a fixed amount of memory available to it, TryInsert operations operations are expected to sometimes fail and be re-issued later. We want these failures to be inexpensive. The same goes for TryRemove, which fails when there isn't enough data in the queue yet for them to complete. Their expected interface is: template<> struct QueueParamTraits<typename RemoveCVR<Arg>::Type> { // Write data from aArg into the PCQ. static QueueStatus Write(ProducerView& aProducerView, const Arg& aArg) {...}; // Read data from the PCQ into aArg, or just skip the data if aArg is null. static QueueStatus Read(ConsumerView& aConsumerView, Arg* aArg) {...} }; 22588
SanitizeRenderer.cpp Narrow renderer string space down to representative replacements. E.g. "GeForce RTX 3090" => "GeForce GTX 980" For example strings: https://hackmd.io/Ductv3pQTMej74gbveD4yw 9919
SourceSurfaceWebgl.cpp 5619
SourceSurfaceWebgl.h MOZILLA_GFX_SOURCESURFACEWEBGL_H_ 2504
test
TextMetrics.h 3221
TexUnpackBlob.cpp 35018
TexUnpackBlob.h 5050
TiedFields.h TiedFields(T&) -> std::tuple<Fields&...> TiedFields(const T&) -> std::tuple<const Fields&...> You can also overload TiedFields without adding T::MutTiedFields: template<> inline auto TiedFields<gfx::IntSize>(gfx::IntSize& a) { return std::tie(a.width, a.height); } 7625
TupleUtils.h 1926
WebGL2Context.cpp virtual 5272
WebGL2Context.h Implemented in WebGLContext void VertexAttribDivisor(GLuint index, GLuint divisor); void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount); void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, WebGLintptr offset, GLsizei instanceCount); 6113
WebGL2ContextBuffers.cpp 5125
WebGL2ContextFramebuffers.cpp 7734
WebGL2ContextMRTs.cpp 4453
WebGL2ContextQueries.cpp We fake ANY_SAMPLES_PASSED and ANY_SAMPLES_PASSED_CONSERVATIVE with SAMPLES_PASSED on desktop. OpenGL ES 3.0 spec 4.1.6: If the target of the query is ANY_SAMPLES_PASSED_CONSERVATIVE, an implementation may choose to use a less precise version of the test which can additionally set the samples-boolean state to TRUE in some other implementation-dependent cases. 3295
WebGL2ContextRenderbuffers.cpp 2254
WebGL2ContextSamplers.cpp 2989
WebGL2ContextState.cpp GLboolean 3668
WebGL2ContextSync.cpp 3210
WebGL2ContextTransformFeedback.cpp 2792
WebGL2ContextUniforms.cpp 3429
WebGLBuffer.cpp 13550
WebGLBuffer.h 2488
WebGLChild.cpp 6301
WebGLChild.h 1992
WebGLCommandQueue.h 8102
WebGLContext.cpp 85953
WebGLContext.h 50630
WebGLContextBuffers.cpp 8257
WebGLContextDraw.cpp 42255
WebGLContextExtensions.cpp 22016
WebGLContextFramebufferOperations.cpp 6356
WebGLContextGL.cpp 46475
WebGLContextLossHandler.cpp 1335
WebGLContextLossHandler.h 904
WebGLContextState.cpp 12916
WebGLContextTextures.cpp virtual 7535
WebGLContextUtils.cpp static 18364
WebGLContextUtils.h Return the displayable name for the texture function that is the source for validation. 1835
WebGLContextValidate.cpp 21124
WebGLContextVertexArray.cpp 1132
WebGLContextVertices.cpp 8715
WebGLExtensions.cpp 35009
WebGLExtensions.h 8689
WebGLFormats.cpp 60006
WebGLFormats.h 10625
WebGLFramebuffer.cpp 55144
WebGLFramebuffer.h 7788
WebGLInternalFormatsTable.h 4646
WebGLIpdl.h 19227
WebGLMemoryTracker.cpp 5366
WebGLMemoryTracker.h 679
WebGLMethodDispatcher.h 6965
WebGLObjectModel.h 1860
WebGLParent.cpp 14379
WebGLParent.h 5332
WebGLProgram.cpp 37479
WebGLProgram.h 5471
WebGLQuery.cpp 3778
WebGLQuery.h 1255
WebGLQueueParamTraits.h 7983
WebGLRenderbuffer.cpp 8431
WebGLRenderbuffer.h 1755
WebGLSampler.cpp 3932
WebGLSampler.h 963
WebGLShader.cpp 5947
WebGLShader.h 1924
WebGLShaderValidator.cpp 15633
WebGLShaderValidator.h 2079
WebGLStrongTypes.h Usage: =========== To create a new type from a set of GLenums do the following: STRONG_GLENUM_BEGIN(TypeName) STRONG_GLENUM_VALUE(ENUM1), STRONG_GLENUM_VALUE(ENUM2), ... STRONG_GLENUM_END() where TypeName is the name you want to give the type. Now simply use TypeName instead of GLenum. The enum values must be given without GL_ prefix. ~~~~~~~~~~~~~~~~ Important Notes: ~~~~~~~~~~~~~~~~ Boolean operators (==, !=) are provided in an effort to prevent some mistakes when using constants. For example we want to make sure that GL_ENUM_X is a valid value for the type in code like: if (myNewType == STRONG_GLENUM_VALUE(SOME_ENUM)) ... The operators will assert that STRONG_GLENUM_VALUE(SOME_ENUM) is a value that myNewType can have. ---- A get() method is provided to allow access to the underlying GLenum. This method should ideally only be called when passing parameters to the gl->fXXXX functions, and be used very minimally everywhere else. Definitely XXX - DO NOT DO - XXX: if (myNewType.get() == STRONG_GLENUM_VALUE(SOME_ENUM)) ... As that undermines the debug checks that were implemented in the ==, and != operators. If you see code like this it should be treated with suspicion. Background: =========== This macro is the first step in an effort to make the WebGL code safer. Many of the different functions take GLenum as their parameter which leads to bugs because of subtle differences in the enums purpose. For example there are two types of 'texture targets'. One is the texture binding locations: GL_TEXTURE_2D GL_TEXTURE_CUBE_MAP Yet, this is not the same as texture image targets: GL_TEXTURE_2D GL_TEXTURE_CUBE_MAP_POSITIVE_X GL_TEXTURE_CUBE_MAP_NEGATIVE_X GL_TEXTURE_CUBE_MAP_POSITIVE_Y ... This subtle distinction has already led to many bugs in the texture code because of invalid assumptions about what type goes where. The macro below is an attempt at fixing this by providing a small wrapper around GLenum that validates its values. Comparison between STRONG_GLENUM's vs. enum classes =================================================== The present STRONG_GLENUM's differ from ordinary enum classes in that they assert at runtime that their values are legal, and in that they allow implicit conversion from integers to STRONG_GLENUM's but disallow implicit conversion from STRONG_GLENUM's to integers (enum classes are the opposite). When to use GLenum's vs. STRONG_GLENUM's vs. enum classes ========================================================= Rule of thumb: * For unchecked GLenum constants, such as WebGL method parameters that haven't been validated yet, use GLenum. * For already-validated GLenum constants, use STRONG_GLENUM's. * For custom constants that aren't GL enum values, use enum classes. 16201
WebGLSync.cpp 2019
WebGLSync.h 1902
WebGLTexelConversions.cpp @class WebGLImageConverter This class is just a helper to implement WebGLContext::ConvertImage below. Design comments: WebGLContext::ConvertImage has to handle hundreds of format conversion paths. It is important to minimize executable code size here. Instead of passing around a large number of function parameters hundreds of times, we create a WebGLImageConverter object once, storing these parameters, and then we call the run() method on it. 16921
WebGLTexelConversions.h Copyright (C) 2010 Apple Inc. All rights reserved. Copyright (C) 2010 Google Inc. All rights reserved. Copyright (C) 2010 Mozilla Corporation. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 47592
WebGLTexture.cpp static 36388
WebGLTexture.h 11401
WebGLTextureUpload.cpp 62444
WebGLTextureUpload.h 1873
WebGLTransformFeedback.cpp 4612
WebGLTransformFeedback.h 1925
WebGLTypes.h Implementing WebGL (or OpenGL ES 2.0) on top of desktop OpenGL requires emulating the vertex attrib 0 array when it's not enabled. Indeed, OpenGL ES 2.0 allows drawing without vertex attrib 0 array enabled, but desktop OpenGL does not allow that. 34530
WebGLValidateStrings.cpp GLSL ES 3.00 p17: - Comments are delimited by / * and * /, or by // and a newline. - '//' style comments include the initial '//' marker and continue up to, but not including, the terminating newline. - '/ * ... * /' comments include both the start and end marker. - The begin comment delimiters (/ * or //) are not recognized as comment delimiters inside of a comment, hence comments cannot be nested. - Comments are treated syntactically as a single space. 4848
WebGLValidateStrings.h Copyright (C) 2011 Apple Inc. All rights reserved. Copyright (C) 2011 Mozilla Corporation. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 1885
WebGLVertexArray.cpp 2139
WebGLVertexArray.h 3704
WebGLVertexArrayFake.cpp 2187
WebGLVertexArrayFake.h 690
WebGLVertexArrayGL.cpp 902
WebGLVertexArrayGL.h 693
XRWebGLLayer.cpp static 9168
XRWebGLLayer.h 2894