| 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.
|
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 |
233709 |
| CanvasRenderingContext2D.h |
CanvasRenderingContext2D
|
41699 |
| 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.
|
17090 |
| CanvasUtils.h |
Float validation stuff |
6360 |
| ClientWebGLContext.cpp |
|
218667 |
| ClientWebGLContext.h |
|
85776 |
| ClientWebGLExtensions.cpp |
|
9705 |
| ClientWebGLExtensions.h |
|
15600 |
| crashtests |
|
|
| DmdStdContainers.h |
|
2329 |
| DrawTargetWebgl.cpp |
|
191840 |
| DrawTargetWebgl.h |
|
26938 |
| DrawTargetWebglInternal.h |
|
16837 |
| 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.
|
27195 |
| ImageBitmap.cpp |
This class observes shutdown notifications and sends that notification
to the worker thread if the image bitmap is on a worker thread.
|
79867 |
| 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 |
|
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 |
|
7084 |
| OffscreenCanvasDisplayHelper.cpp |
|
19300 |
| 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 |
|
82414 |
| WebGLContext.h |
|
49495 |
| WebGLContextBuffers.cpp |
|
8257 |
| WebGLContextDraw.cpp |
|
42255 |
| WebGLContextExtensions.cpp |
|
21646 |
| WebGLContextFramebufferOperations.cpp |
|
6356 |
| WebGLContextGL.cpp |
|
46161 |
| WebGLContextLossHandler.cpp |
|
1335 |
| WebGLContextLossHandler.h |
|
904 |
| WebGLContextState.cpp |
|
13114 |
| 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 |
|
55144 |
| WebGLFramebuffer.h |
|
7788 |
| WebGLInternalFormatsTable.h |
|
4646 |
| WebGLIpdl.h |
|
18690 |
| WebGLMemoryTracker.cpp |
|
5366 |
| WebGLMemoryTracker.h |
|
679 |
| WebGLMethodDispatcher.h |
|
6906 |
| WebGLObjectModel.h |
|
1860 |
| WebGLParent.cpp |
|
14379 |
| WebGLParent.h |
|
5332 |
| WebGLProgram.cpp |
|
37479 |
| WebGLProgram.h |
|
5471 |
| WebGLQuery.cpp |
|
3778 |
| WebGLQuery.h |
|
1255 |
| WebGLQueueParamTraits.h |
|
8102 |
| WebGLRenderbuffer.cpp |
|
8431 |
| WebGLRenderbuffer.h |
|
1755 |
| WebGLSampler.cpp |
|
3932 |
| WebGLSampler.h |
|
963 |
| WebGLShader.cpp |
|
5947 |
| WebGLShader.h |
|
1924 |
| WebGLShaderValidator.cpp |
|
14944 |
| 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.
|
34586 |
| 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 |