Name Description Size
CacheInvalidator.cpp 1295
CacheInvalidator.h 4077
CanvasGradient.cpp 507
CanvasGradient.h 1722
CanvasImageCache.cpp Used for images specific to this one canvas. Required due to CORS security. 11830
CanvasImageCache.h Notify that image element aImage was drawn to aCanvas element 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. 2314
CanvasPath.h CanvasPath_h 3523
CanvasPattern.cpp 851
CanvasPattern.h 1769
CanvasRenderingContext2D.cpp Memory reporter stuff 228526
CanvasRenderingContext2D.h CanvasRenderingContext2D 40673
CanvasRenderingContextHelper.cpp 11371
CanvasRenderingContextHelper.h Povides common RenderingContext functionality used by both OffscreenCanvas and HTMLCanvasElement. 3288
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. 17168
CanvasUtils.h Float validation stuff 6360
ClientWebGLContext.cpp 217176
ClientWebGLContext.h 84224
ClientWebGLExtensions.cpp 9705
ClientWebGLExtensions.h 15600
crashtests
DrawTargetWebgl.cpp 189834
DrawTargetWebgl.h 26736
DrawTargetWebglInternal.h 16677
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 5688
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. 26974
ImageBitmap.cpp This class observes shutdown notifications and sends that notification to the worker thread if the image bitmap is on a worker thread. 79635
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. 10209
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 6623
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. 1826
moz.build 6017
MurmurHash3.cpp 8458
MurmurHash3.h 843
nsICanvasRenderingContextInternal.cpp 3850
nsICanvasRenderingContextInternal.h 8094
OffscreenCanvas.cpp static 19242
OffscreenCanvas.h 7050
OffscreenCanvasDisplayHelper.cpp 17455
OffscreenCanvasDisplayHelper.h 3583
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. 5004
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) {...} }; 22703
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 9054
SourceSurfaceWebgl.cpp 5567
SourceSurfaceWebgl.h MOZILLA_GFX_SOURCESURFACEWEBGL_H_ 2510
test
TextMetrics.h 3221
TexUnpackBlob.cpp 33027
TexUnpackBlob.h 4923
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); } 5390
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); 6237
WebGL2ContextBuffers.cpp 5125
WebGL2ContextFramebuffers.cpp 7716
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 3784
WebGL2ContextSync.cpp 1934
WebGL2ContextTransformFeedback.cpp 2792
WebGL2ContextUniforms.cpp 3429
WebGLBuffer.cpp 13451
WebGLBuffer.h 2437
WebGLChild.cpp 5778
WebGLChild.h 1905
WebGLCommandQueue.h 8247
WebGLContext.cpp 79809
WebGLContext.h 48777
WebGLContextBuffers.cpp 7820
WebGLContextDraw.cpp 42255
WebGLContextExtensions.cpp 21646
WebGLContextFramebufferOperations.cpp 6356
WebGLContextGL.cpp 46211
WebGLContextLossHandler.cpp 1335
WebGLContextLossHandler.h 904
WebGLContextState.cpp 13729
WebGLContextTextures.cpp virtual 7528
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 32044
WebGLExtensions.h 8557
WebGLFormats.cpp 60006
WebGLFormats.h 10625
WebGLFramebuffer.cpp 54959
WebGLFramebuffer.h 7788
WebGLInternalFormatsTable.h 4646
WebGLIpdl.h 17753
WebGLMemoryTracker.cpp 4863
WebGLMemoryTracker.h 644
WebGLMethodDispatcher.h 6863
WebGLObjectModel.h 1860
WebGLParent.cpp 13772
WebGLParent.h 5144
WebGLProgram.cpp 37479
WebGLProgram.h 5471
WebGLQuery.cpp 3778
WebGLQuery.h 1255
WebGLQueueParamTraits.h 8669
WebGLRenderbuffer.cpp 8431
WebGLRenderbuffer.h 1755
WebGLSampler.cpp 3932
WebGLSampler.h 963
WebGLShader.cpp 5947
WebGLShader.h 1924
WebGLShaderValidator.cpp 14944
WebGLShaderValidator.h 2070
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 940
WebGLSync.h 930
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 36416
WebGLTexture.h 11107
WebGLTextureUpload.cpp 63306
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. 31435
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