Before P1, GetCurrentThreadSerialEventTarget would have always returned the same data as NS_GetCurrentThread, making the comment incorrect Now it will properly return the running TaskQueue if any.
This change of name more clearly exposes what they are doing, as we aren't always dealing with threads directly; but a nsISerialEventTarget
Differential Revision: https://phabricator.services.mozilla.com/D80354
We are here, always actually dealing with the compositor thread, with the exception of VRDisplayPresentation which is passing the main thread.
Depends on D80422
Differential Revision: https://phabricator.services.mozilla.com/D80423
This change attempts to parse the incoming SPIR-V shader modules with
Naga SPIR-V front-end. It's not complete, but it returns an Error if it's unable to parse,
in which case we just continue without the validation (for now).
If it succeeds, we extract the reflection information from it, and use it for the pipeline.
This is just a start. More states would need to be validated, and SPIR-V front-end needs more work.
Differential Revision: https://phabricator.services.mozilla.com/D77170
This avoids arbitrary precision loss when computing REM units and so on,
which is particularly important if we ever change the base of our app
units (but useful regardless).
Differential Revision: https://phabricator.services.mozilla.com/D79928
This moves the clipping responsibility into the layer. It also brings back
assertions that make sure that no invalid content reaches the screen.
On the layer side I'm renaming validRect to displayRect, because at the time
NextSurface* is called, that rect is not yet valid.
This implementation also allows having valid content outside of the display
rect. So, for example, if you grow and shrink the display rect multiple times
but most of the outer parts are transparent, in theory this allows you to paint
the transparent pixels only once rather than every time the display rect
expands.
Differential Revision: https://phabricator.services.mozilla.com/D79842
This avoids arbitrary precision loss when computing REM units and so on,
which is particularly important if we ever change the base of our app
units (but useful regardless).
Differential Revision: https://phabricator.services.mozilla.com/D79928
This helps get sccache hits across source directories.
The previous presentation guaranteed the version of `ftlcdfil.h` in
the tree, while this unorthodox presentation only ensures that the
`freetype2` directory has parent `modules`. This is at least unlikely
to occur in random `/usr/include` directories.
If this turns out to be an issue it would be possible to copy
`ftlcdfil.h` into the object directory, potentially with a unique
name, and then reference that (with a relative path).
Differential Revision: https://phabricator.services.mozilla.com/D73759
Now CompositorAnimationStorage::GetAnimatedValue() and SetAnimatedValue()s
are called on the sampler thread in case of WebRender, are called on the
compositor thread in case of non WebRender, so we drop assertions of
IsInCompositorThread check there. A mLock.AssertCurrentThreadOwns call in
each function should make sure the function gets called on the
sampler/compositor thread with acquiring the lock.
One caveat in this change is that in case we try to get an animation value via
nsIDOMWindowUtils.getOMTAStyle(), we do sample animations on the _compositor_
thread and we never call UpdateDynamicProperties, which means if it gets called
in testing refresh driver mode, visual results will differ from what the value
returned by the getOMTAStyle should look like. But it should be fine because we
disallow using any chrome priviledge APIs in reftests and also we will never use
the testing refresh driver mode in the reftest harness. Also in mochitests the
visual results' differences might make people confusing if the person can notice
it, but in principal getOMTAStyle() is designed to get computed animating values
so that it doesn't matter what the visual result is.
Differential Revision: https://phabricator.services.mozilla.com/D79982
The code to support collapsing a picture with a single primitive
and an opacity filter into a primitive + opacity binding is
no longer an important optimization, due to picture caching.
Removing this old optimization also reduces complexity during
scene building, and slightly simplifies batching and picture
cache dependency tracking.
Differential Revision: https://phabricator.services.mozilla.com/D79975
- Enable WebGL SwapChain pooling on Android. Creating and releasing Android Surfaces every frame causes a big performance hit due to AndroidSurface slow destructors bug.
- Add a separate SwapChain for WebVR. We are already using separate SwapChains for WebXR (WebGLFramebuffer::mOpaqueSwapChain) but not for WebVR (it uses the canvas backbuffer).
Differential Revision: https://phabricator.services.mozilla.com/D79840
An alternative patch to take only if we don't land https://phabricator.services.mozilla.com/D79545
The main observations here are:
- In the vast majority of times we find a compatible bacth or intersect an incompatible one within 3 iterations when looking for batch candidates.
- In addition, most of the time we don't need to iterate per-item rects thanks to a fast path kleveraging per-batch bounding rects, making it reasonably cheap to iterate over more batches.
This gives us room to allow ourselves to visit a lot more batches without a large impact on CPU time (under the assumption that removing a handful of draw calls will more than make up for the extra iterations).
Depends on D79479
Differential Revision: https://phabricator.services.mozilla.com/D79794
Recycling caused rendering problem on a MacOS PC with OpenGL compositor. TextureHost reuse with OpenGL compositor seemed to have a problem.
Adds pref layers.recycle-allocator-rdd for disable/enable the RecycleAllocator.
Differential Revision: https://phabricator.services.mozilla.com/D79639
This code was assuming that the only non-opaque parts of compositor rendering would be the
parts of the window that had vibrancy. But now that the default window background is transparent,
we can have non-vibrant parts where we render into transparency. Dialog windows such as sheet
windows are an example of this.
So instead of using the non-vibrant region of the window as its opaque region, we now use
the region that is covered by opaque Gecko layers. This region is a lot more conservative:
For example, the main browser chrome is now entirely transparent, because the chrome's opaque
parts share a layer with its transparent parts.
As a result, this change slightly affects the CALayer partitioning in the main browser window:
The entire browser chrome is now transparent, not just the tab bar.
The web content area is still opaque.
I think this will be fine. The thing I'm most concerned about is that scrolling inside web
content might cause invalidations of pixels from the chrome, because then we'd recomposite
the CALayers that cover the vibrant tab bar. This doesn't seem to happen most of the time
though, from what I can tell.
Differential Revision: https://phabricator.services.mozilla.com/D51466
Now that there is no Gecko-contributed background color in the window any more,
there's nothing that needs to be cleared away. This simplifies things.
Differential Revision: https://phabricator.services.mozilla.com/D51464
Tested this on a few pages and it lets us avoid allocating per-item rects for roughly a quarter to a third of the batches. For batches that end up allocating per item rects we get to allocate fewer of them. It also further reduces the amount of times we need to test all item rects against intersections.
Differential Revision: https://phabricator.services.mozilla.com/D79479
In the sampling methods, we do basically sample an animation value for each
CSS property other than transform-like properties.
Differential Revision: https://phabricator.services.mozilla.com/D79749
> /builds/worker/checkouts/gecko/gfx/gl/SharedSurface.cpp:141:1: error: control reaches end of non-void function [-Werror=return-type]
Old compilers don't realize the switch being exhaustive means the
function always returns, which we workaround here.
Differential Revision: https://phabricator.services.mozilla.com/D78837
* Majorly simplity CanvasRenderer
* Replace GLScreenBuffer with trivial GLSwapChain
* Use descriptor structs so that future SharedSurface changes aren't so painful
to propagate
* Mortgage/strip out more OffscreenCanvas code for now
Differential Revision: https://phabricator.services.mozilla.com/D75055
These vectors are rebuilt once per frame. we can't recycle them because they are sent to the renderer. On a 4k screen for most sites the element counts are low enough that we can get away with preallocation from a pessimistic estimate, but high enough that reallocation happens a few times per frame and takes a small but visible portion of the profile.
Differential Revision: https://phabricator.services.mozilla.com/D79457
When Tab is moved to another window, all async ImageHosts need to update CompositorBridgeID. It is used for calling ScheduleComposition().
Differential Revision: https://phabricator.services.mozilla.com/D79068
This is an attempt to improve our relationship with the drivers.
Currently, we work with the instance buffer limit dictated by the macOS drivers.
We can consider lowering it, since it will only make the driver work eaiser.
Differential Revision: https://phabricator.services.mozilla.com/D78164
When a transform depends on the layout size of an element, one can see
visual distortions caused by the difference between the unsnapped size
used in the transform, and the snapped size calculated during scene
building. Ideally we could compute the transform after we snap, rather
than before. This patch adds support for a computed reference frame
which takes parameters to calculate the ideal transform dynamically.
In a future patch, we should make videos take advantage of this same
mechanism to avoid similar problems. This requires support for mirroring
and rotations.
Differential Revision: https://phabricator.services.mozilla.com/D77956
We can perform the same function as RecyclingSourceSurface by checking
the ref count of the underlying surface directly. We need to ensure
WebRender is explicitly aware that it is a recycled surface, but that is
easily achieved by changing the type of the surface. This avoids
unnecessary heap allocations, particularly in the case where many
elements on the same page refer to the same animation (and thus
duplicating RecyclingSourceSurface objects).
Differential Revision: https://phabricator.services.mozilla.com/D77513
The MVM is needed for both handling of meta-viewport tags and APZ zooming.
However, the set of functionality needed in the two modes are not the same.
This patch adds a mechanism to create an MVM with a flag that lets it know
which mode it is operating in. Eventually we may want to split this into two
or more classes but for now this seems like a reasonable way forward.
The flag is currently set on the MVM on creation based on whether or not the
meta-viewport support is needed. There's no code that meaningfully *uses* the
flag yet, so this patch should have no functional change. The bulk of the
patch is ensuring that we appropriately destroy and re-create the MVM if the
flag required changes.
Differential Revision: https://phabricator.services.mozilla.com/D79224
The main idea here is lifting the storages of batches, instances, and instance rects,higher up. Currently, to the level of the alpha/opaque batcher.
In the short term, this would result in less heap allocations on frame building.
For example, we no longer have a Vec<InstanceRect> per batch, stored in a separate Vec,
and we don't have a separate Vec<InstanceData> per batch.
There is also a matter of code refactor and cleanup that could make our life better.
In the longer term, once Angle is updated, we'll be able to lift the VBO updates up
accordingly, and use baseInstance drawing with them.
Sub-commits:
- Minor refactor of the batch intersection logic
- Instance stacks for transparent alpha batches
- Use instance stacks for opaque batches as well
- Implement and re-enable batch list merging
- Encapsulate instance stack LRU indexing into a class
- Internal BatchList type, bumped StackIndex size.
- Adjust the tests
- Test the stack count of 4
Differential Revision: https://phabricator.services.mozilla.com/D76715
In the first-paint case, we are accepting the incoming scroll metadata
wholesale, so most of the consequences of this code block will happen
anyways -- except for the extra repaint, which is not actually needed
and in fact undesirable in the first-paint case.
Differential Revision: https://phabricator.services.mozilla.com/D79195
Simple implementation of skipping SyncObjectD3D11Host::Synchronize(). More optimization could be done in Bug 1635629.
Differential Revision: https://phabricator.services.mozilla.com/D75781
> /builds/worker/checkouts/gecko/gfx/gl/SharedSurface.cpp:141:1: error: control reaches end of non-void function [-Werror=return-type]
Old compilers don't realize the switch being exhaustive means the
function always returns, which we workaround here.
Differential Revision: https://phabricator.services.mozilla.com/D78837
* Majorly simplity CanvasRenderer
* Replace GLScreenBuffer with trivial GLSwapChain
* Use descriptor structs so that future SharedSurface changes aren't so painful
to propagate
* Mortgage/strip out more OffscreenCanvas code for now
Differential Revision: https://phabricator.services.mozilla.com/D75055
> /builds/worker/checkouts/gecko/gfx/gl/SharedSurface.cpp:141:1: error: control reaches end of non-void function [-Werror=return-type]
Old compilers don't realize the switch being exhaustive means the
function always returns, which we workaround here.
Differential Revision: https://phabricator.services.mozilla.com/D78837
* Majorly simplity CanvasRenderer
* Replace GLScreenBuffer with trivial GLSwapChain
* Use descriptor structs so that future SharedSurface changes aren't so painful
to propagate
* Mortgage/strip out more OffscreenCanvas code for now
Differential Revision: https://phabricator.services.mozilla.com/D75055
Using `SimpleTest.is` directly instead of the "global" `is` installed by
runSubtestsSeriallyInFreshWindows means that the helper test filename doesn't
get emitted in the assertions, which is a nice thing to have. (Ditto for `ok`
and friends).
Problematic tests identified using:
for helper in helper_*.html; do
if [[ $(grep "$helper" test_group*) ]]; then
echo $helper;
grep -e 'SimpleTest.\(is\|ok\)' "$helper";
fi;
done
While it would be nice to catch this sort of thing directly in the code, it's
a bit tricky to do because SimpleTest.(ok|is) do get used legitimately by helper
methods that are used by group subtests and top-level tests.
Depends on D79171
Differential Revision: https://phabricator.services.mozilla.com/D79172
The flag is not required for SharedSurface_SurfaceTexture, as
GeckoSurfaceTexture is reference counted. When the GeckoSurface is
disposed on the client side it simply decrements the refcount of the
GeckoSurfaceTexture on the host side, which will remain alive until
the TextureHost's reference is also dropped.
Differential Revision: https://phabricator.services.mozilla.com/D79073
Previously, when we decided to evict elements from the texture cache,
a very simple scheme was used. All elements would be scanned, and
any element that was older than a given threshold would be freed.
This is not ideal for a number of reasons:
- When an eviction takes place, a large number of elements must be scanned.
- When we do evict elements, we often evict a large number of elements in
a single frame, causing CPU spikes.
- We often evict more items than necessary, resulting in redundant
uploads of the same elements again on subsequent frames.
This patch introduces a new LRU cache collection, which is used to
manage the lifetime of most texture cache entries [1].
With this change, we can now:
- Efficiently evict items from oldest to newest, without scanning the entire list.
- Efficiently evict only a small number of items per frame, reducing the
chance of CPU frame spikes.
- Evict only enough elements to reduce memory under a specific threshold,
which reduces the number of redundant evictions / re-uploads required.
[1] Picture cache tiles and manual eviction elements are stored inside
the new cache for efficiency, but the lifetime of them is managed
separately by the texture cache.
Differential Revision: https://phabricator.services.mozilla.com/D78216
The `reset_state` method being called after locking external textures
was resetting the cached state, but not actually forcing the GL
state to match.
This could result in cached state getting out of sync with GL. In
this case, we'd end up trying to composite to the external texture
FBO rather than the main framebuffer.
Differential Revision: https://phabricator.services.mozilla.com/D78851
* Majorly simplity CanvasRenderer
* Replace GLScreenBuffer with trivial GLSwapChain
* Use descriptor structs so that future SharedSurface changes aren't so painful
to propagate
* Mortgage/strip out more OffscreenCanvas code for now
Differential Revision: https://phabricator.services.mozilla.com/D75055
Ensure that even if an entire picture cache slice is opaque, if it
has intersecting compositor surfaces we respect the draw order of
those tiles, to ensure correct z-buffer ordering.
Differential Revision: https://phabricator.services.mozilla.com/D78628
Instead of using the default TreePrinter implementation which sends output
to stdout, collect it into a Vec<u8> and use the debug! macro to log it,
which sends it to a more useful destination (logcat) on Android.
Depends on D78536
Differential Revision: https://phabricator.services.mozilla.com/D78537
This uses "None" instead of "NotSpecified" as the value for
mLastSmoothScrollOrigin when there is no smooth scroll in progress.
Depends on D78439
Differential Revision: https://phabricator.services.mozilla.com/D78469
This patch is a fairly mechanical conversion. The old `nullptr` gets converted
to ScrollOrigin::NotSpecified, and all the other possible values get corresponding
values in the new ScrollOrigin enum. A few switch statements are introduced to
clean up big if statements, but other than that, additional cleanups will happen
in later patches.
Differential Revision: https://phabricator.services.mozilla.com/D78438
When DWM is disabled, each window does not have own back buffer. They would paint directly to a buffer that was to be displayed by the video card. WM_PAINT via SendInvalidRegion() requests necessary re-paint. With it, RenderCompositorANGLE does not need to disable partial present.
Differential Revision: https://phabricator.services.mozilla.com/D77989
* Maintain a running total of bytes allocated in both standalone and
shared cache regions. This is used as a threshold to know when to
force a mid-frame eviction. Previously, as soon as the currently
allocated set of shared textures were full, we'd force an eviction.
This means that in typical use cases, we were forcing an eviction
as soon as the texture cache is > 16 MB, which is inefficient.
* Separate out picture cache eviction from the normal cache eviction
path. This will be important in the next patch which will change
the eviction algorithm for all shared / standalone entries.
* Remove Eviction::Eager as a policy option for shared and standalone
textures. As part of this, switch render task cache entries to use
Eviction::Auto. This is a better option anyway, there is no real
benefit to evicting render tasks as soon as possible - they should
be expired based on usage, just as for normal cache entries.
Differential Revision: https://phabricator.services.mozilla.com/D77983
When handling mix-blend readbacks, we need to calculate the origin of the source picture in the backdrop's space.
Before this patch, this was done by scaling the source picture origin by the backdrop's device pixel scale.
However, this is the incorrect scaling; We really want the relative scale between source and backdrop instead.
This patch computes the relative scaling from the device pixel scale of both the source and backdrop pictures.
This bug likely went unnoticed because the device pixel scale used to be 1 in most cases, but now we sometimes
increase the device pixel scale for raster roots.
Differential Revision: https://phabricator.services.mozilla.com/D78217
This patch:
* extracts family name matching logic from FontFamilyList::Contains into FontFamilyName::IsNamedFamily
* simplifies the loop around StretchEnumContext::EnumCallback using a range-based loop with a break
* inverts the meaning of StretchEnumContext::EnumCallback’s return value
These changes were first reviewed in D73833, but we’re separating them to help us investigate some test regressions.
Differential Revision: https://phabricator.services.mozilla.com/D77067
* Maintain a running total of bytes allocated in both standalone and
shared cache regions. This is used as a threshold to know when to
force a mid-frame eviction. Previously, as soon as the currently
allocated set of shared textures were full, we'd force an eviction.
This means that in typical use cases, we were forcing an eviction
as soon as the texture cache is > 16 MB, which is inefficient.
* Separate out picture cache eviction from the normal cache eviction
path. This will be important in the next patch which will change
the eviction algorithm for all shared / standalone entries.
* Remove Eviction::Eager as a policy option for shared and standalone
textures. As part of this, switch render task cache entries to use
Eviction::Auto. This is a better option anyway, there is no real
benefit to evicting render tasks as soon as possible - they should
be expired based on usage, just as for normal cache entries.
Differential Revision: https://phabricator.services.mozilla.com/D77983
WR font sanitization appears relatively stable now, and we passed the 79
cutoff, so let WR font sanitization ride the trains.
Differential Revision: https://phabricator.services.mozilla.com/D78147
Previously, we would wait until the following frame (for uncertain reasons
that date back to B2G), but this meant the layout and visual viewports would
be out of sync for a frame, causing APZ to misbehave.
Differential Revision: https://phabricator.services.mozilla.com/D61286
Activating pinch locking means we are locked into a two-finger pan
(no scaling), which can trigger a fling animation at the end. We
track velocity via UpdateWithTouchAtDevicePoint() while pinch locked.
We need to call StartTouch() when we start tracking velocity.
Differential Revision: https://phabricator.services.mozilla.com/D77980
When document splitting was supported, there was some complexity
when texture cache was cleared, where a frame build could be
required to ensure other documents would render correctly.
Since this is no longer used, we can remove the per-document state
here, which will simplify some future changes to how the cache
eviction policy works.
Differential Revision: https://phabricator.services.mozilla.com/D77745
Do full render with WebRender when Dwn is disabled. It could be done by RenderCompositorANGLE::RequestFullRender().
Back out Bug 1638469. It disables WebRender during starting if Dwm is disabled. But Dwm is enabled/disabled dynamically. And we do not want to disable WebRender in this case.
Differential Revision: https://phabricator.services.mozilla.com/D77221
The logic for expanding the drop shadow clip rect was calling the
`map_vector` method in the `ScaleOffset` struct.
This method was incorrect (it was mapping the value as a point,
including the offset). This is fixed by modifying the `map_vector`
method to exclude the offset.
However, the text run snapping code was also calling map_vector
but expecting it to treat the value there as a point, so also
introduce a `map_point` method and switch the text run code
to use that.
Differential Revision: https://phabricator.services.mozilla.com/D77397
This patch removes two of the existing paths for evicting textures.
One is no longer useful, and the other is over-zealous, and causes
frame stalls.
When the shared texture cache made use of variable layer counts, the
`maybe_reclaim_shared_memory` method would look at the space in free
layers, and if large enough, would clear the entire cache and rely on
it being rebuilt implicitly as new requests occur. However, since we
no longer resize the number of slices, this doesn't serve a useful
purpose (the texture cache already frees any empty texture cache units
at the end of each frame).
The other method applies a conservative, periodic GC that occurs if no
other GCs have run for five seconds. However, this is a very aggressive
eviction that often evicts most of the shared cache, and was being run
whenever the size of the texture cache was > 16 MB. The effect of this
is that if you pause scrolling for a few seconds, and then scroll again,
most of the cache gets evicted. Instead, completely remove this concept,
relying on empty texture cache pages being freed and memory pressure
events, and general cache eviction during frames.
Differential Revision: https://phabricator.services.mozilla.com/D77402
Adds an |aChromeOnlyDispatch| flag to DispatchCustomEvent to decide whether
to call DispatchTrustEvent or DispatchEventOnlyToChrome.
The following chrome-only events are dispatched with DispatchCustomEvent and now
make use of the flag:
- DOMWindowClose
- fullscreen / willenterfullscreen / willexitfullscreen
- occlusionstatechange
- resolutionchange
- XULAlertClose
and the following were previously dispatched with DispatchTrustedEvent and now
use DispatchEventOnlyToChrome:
- MozBeforeInitialXULLayout
- MozMouseScrollFailed / MozMouseScrollTransactionTimeout
- MozPaintWait / MozPaintWaitFinished
- MozPerformDelayedBlur
- all events fired by APZCCallbackHelper::NotifyMozMouseScrollEvent
Differential Revision: https://phabricator.services.mozilla.com/D76723
Bug 1635406 made it so that webrender snaps the offsets of animated
transforms before accumulating them in to the reference frame
transform. Unfortunately, however, this causes jittery animations. The
original intention was just to snap the visual viewport offset when
scrolling, to avoid excessive picture cache invalidation.
To avoid this, make it so that we only snap for reference frames of
kind ReferenceFrameKind::Zoom. This will mean that most animations are
unaffected. There may however still be some jitter when zooming, but
this is outweighed by the benefit of not invalidating picture cache
tiles every frame when scrolling.
Differential Revision: https://phabricator.services.mozilla.com/D77679
We create sub images from larger images by using a stride that matches
the original and adjusting the offset. This creates a situation where
the last row will only have stride - offset bytes. This stops us
from lying to CGDataProvider.
Differential Revision: https://phabricator.services.mozilla.com/D77476
VAAPIFrameHolder was moved to FFmpegVideoDecoder class and we use WaylandDMABufSurface global lock to keep
surface reference until it's used.
Differential Revision: https://phabricator.services.mozilla.com/D76691
This patch implements:
- Global surface UID for better tracking/debugging. The UID is passes acros all processes so we can track
surface usage.
- WaylandAllocateShmMemory() function which uses shm_open() instead of files at tmp for Shm memory creation.
- DMABufRefcount() class based on eventfd() which is used as a global surface reference count.
Differential Revision: https://phabricator.services.mozilla.com/D76689
