Bug 1746795 - Make gfxPlatformFontList::CommonFontFallback honor a preference for emoji presentation when searching its font list, rather than just returning the first match for the codepoint. r=jwatt, a=RyanVM

Differential Revision: https://phabricator.services.mozilla.com/D136730

Bug 1734027 - Ensure we mark GLFeature::draw_buffers_indexed as unsupported if symbol load fails. r=jgilbert, a=RyanVM

When loading the symbols for draw_buffers_indexed, we marked it as for
draw_buffers. This would mean that if draw_buffers_indexed loading
failed, and we checked for the feature support, it would indicate it is
supported even though it is backed by nothing.

Differential Revision: https://phabricator.services.mozilla.com/D136381

It appears fGetString(LOCAL_GL_VERSION) can return a nullptr on Linux.
This causes a crash when we try to assign it to an std::string. This
appears to happen predominantly llvmpipe users (although generally that
should return a GL verison string as well). This patch ensures we
gracefully fail to init GL instead.

Differential Revision: https://phabricator.services.mozilla.com/D136412

Differential Revision: https://phabricator.services.mozilla.com/D136159

Bug 1750373 - Add support for x-flips in SetBufferTransformFlipped(), r=gfx-reviewers,mstange a=dmeehan

Before D132738 Webrender only allowed y-flips on surfaces so `NativeLayerWayland`
ended up not implementing x-flips. However, we checked for the y-flip
via `HasNegativeScaling()`, which also applies to x-flips.
A common user of x-flips are WebRTC video conferencing services like
jitsi, which use it to make the users own video behave like a mirror.

After D132738, users of these services now see their own video upside
down instead. Amusing for some, seriously confusing for others.

Differential Revision: https://phabricator.services.mozilla.com/D136062

Bug 1749103 - Avoid thrashing gfxDWriteFont's ScaledFonts between canvas and content. r=jfkthame a=dmeehan

This is essentially a partial revert of a cleanup done in bug 1742896. If canvas and content
are using the same underlying gfxDWriteFont and simultaneously retrieving a ScaledFont, this
may cause the ScaledFont to get repeatedly destroyed and re-instantiated every time we switch
from one context to the other. If this destruction happens at an inopportune time while WR
is still using a blob image with the font, it can potentially trigger undesirable assertions.

For now, duplicate the part of Bas' original patch from bug 1730722 that separatedly cached
the GDI and non-GDI versions of the ScaledFont. This way, both will exist for the lifetime
of the underlying gfxDWriteFont and thus avoid the thrashing.

Differential Revision: https://phabricator.services.mozilla.com/D135442

We need to include the parent snapping transform in the test for
whether a spatial node needs to be updated from scene -> frame.

Differential Revision: https://phabricator.services.mozilla.com/D135465

This was useful so may as well land it. Need to use mozilla::Side in the
header because otherwise it is ambiguous with mozilla::ipc::Side, yay
C++.

Depends on D135562

Differential Revision: https://phabricator.services.mozilla.com/D135563

This is a sufficient fix to handle this case, we should definitely
invalidate the dirty rect validity if the compositor surface count
has changed.

There are likely other cases where the surface count remains the same
but we also need to invalidate dirty rect validity (we can handle
these as follow ups and/or as we encounter other cases).

Differential Revision: https://phabricator.services.mozilla.com/D135462

Bug 1743273: Ensure gfxDWriteFont::sForceGDIClassicEnabled is set on initialization. r=lsalzman, a=dmeehan

Differential Revision: https://phabricator.services.mozilla.com/D135528

Bug 1742358 - Set default clear color to widget window background on expose, and reset it on first contentful paint. r=jrmuizel,stransky

Differential Revision: https://phabricator.services.mozilla.com/D135075

Differential Revision: https://phabricator.services.mozilla.com/D135406

Backed out changeset 00e8fe799b76 (bug 1749051) for causing failures at CompositorBridgeParent.cpp. CLOSED TREE

Differential Revision: https://phabricator.services.mozilla.com/D135406

This code was left unprotected when it landed. The prefs only exist in
Nightly, so they generated compile-time errors without these changes.

Differential Revision: https://phabricator.services.mozilla.com/D135395

Depends on D135328

Differential Revision: https://phabricator.services.mozilla.com/D135329

Add KillGPUProcessForTests, which kills the GPU process without
generating a crash dump (unlike the existing CrashGPUProcessForTests).

Additionally add EnsureGPUProcessReadyForTests, which returns a
promise that resolves to true when the GPU process is enabled and
ready, and false if it is disabled. If called while the GPU process is
being (re)started, it will not resolve until it has finished launching
(or was disabled due to error).

Finally, make GPUProcessHost::IsConnected check whether the process
handle is valid. This ensures it returns false immediately following a
call to KillProcess but prior to the GPUChild being destroyed. This
means tests can call EnsureGPUProcessReadyForTests immediately after
KillGPUProcessForTests or CrashGPUProcessForTests, and it will
reliably wait for the new process to launch, as intended.

Depends on D135207

Differential Revision: https://phabricator.services.mozilla.com/D135328

Following a GPU process restart ZoomConstraints do not currently get
set for the newly recreated APZCTreeManagers, meaning it is no longer
possible to asynchronously zoom pages.

To solve this, we make ZoomConstraintsClient observe a new
"compositor-reinitialized" topic. We send this notification in
GPUProcessManager::HandleProcessLost() to notify
ZoomConstraintsClients for parent process documents, and in
ContentChild::RecvReinitRendering() for documents in their respective
content processes. This must be performed after the compositor has
been reinitialized so that the APZCTreeManagerChild is able to send
the constraints to the APZCTreeManagerParent in the compositor
process.

Differential Revision: https://phabricator.services.mozilla.com/D135207

Bug 1747116 - Guard against null native window in AndroidCompositorWidget r=gfx-reviewers,geckoview-reviewers,aosmond,m_kato

If AndroidCompositorWidget's surface reference points to a surface
that has been destroyed, we can end up with a null ANativeWindow
pointer. This can result in crashes when using it to query the window
size.

This patch makes it so that we use the native window to query the size
only when the surface has changed rather than for every call to
GetClientSize(). This allows us to guard against a null pointer in a
single place. If we have a null pointer then return false from
OnCompositorSurfaceChanged(). CompositorBridgeParent::ResumeComposition()
will handle that by not resuming the compositor, like it already does
if WebRenderBridgeParent::Resume() fails.

Additonally, when we receive a pause event from GeckoView ensure that
we always set the mCompositorPaused flag to true, even if the
UiCompositorController is null. This avoids a possible cause of the
situation described above - if we receive a pause event (eg the app is
minimised) during compositor reinitialization (while the
UiCompositorController is temporarily null) we would not set that flag
to true, and would therefore resume compositing in to an invalid
surface.

Depends on D135117

Differential Revision: https://phabricator.services.mozilla.com/D135118

Bug 1746711 Part 3: Log property keys of video surfaces, buffers, and formats. r=gfx-reviewers,mstange

This will help determine if the surfaces we get from DRM video are different
from the ones we get from non-DRM video.

Differential Revision: https://phabricator.services.mozilla.com/D135170

All of the IOSurfaces that come from AppleVTDecoder should have a color space
specified. This checks that the color space is still defined for any surface
sent to EnqueueSurface.

Differential Revision: https://phabricator.services.mozilla.com/D135089

Bug 1746711 Part 1: Change method of presenting recreated samples to spoof timing. r=gfx-reviewers,mstange

This change removes the usage of kCMSampleAttachmentKey_DisplayImmediately and
instead spoofs a timestamp for the current time.

Differential Revision: https://phabricator.services.mozilla.com/D134981

Bug 1748077 - Escape any backslashes in the URL when creating PDF links via cairo. r=gfx-reviewers,jrmuizel

Differential Revision: https://phabricator.services.mozilla.com/D135227

Differential Revision: https://phabricator.services.mozilla.com/D135140

Bug 1737313: Document what is needed to generate a preloaded depot_tools zip r=firefox-build-system-reviewers,glandium

Depends on D132591

Differential Revision: https://phabricator.services.mozilla.com/D132592

Depends on D129536

Differential Revision: https://phabricator.services.mozilla.com/D132591

Depends on D129435

Differential Revision: https://phabricator.services.mozilla.com/D129536

This will set up all of the env vars that are needed for running
update-angle, and also grab the angle repo, set it up and run the
update

Differential Revision: https://phabricator.services.mozilla.com/D129435

CLOSED TREE

This function computes squares of values, but the results are the same magnitude than the source components.
In fact, they can't be larger than the biggest component. Therefore, by doubling the precision of computation we can guarantee that the result will be finite if the source data is finite.

An alternative approach would be to figure out a different computation path that would preserve the precision as it goes. Looks to not be necessary here.

Differential Revision: https://phabricator.services.mozilla.com/D135140

Bug 1747116 - Ensure that RenderCompositorOGLSWGL destroys its EGL surface on Android. r=gfx-reviewers,nical

Due to a typo in a preprocessor condition, the RenderCompositorOGLSWGL
destructor was not destroying its EGL surface on Android. This meant
that subsequent RenderCompositorOGLSWGL instances were unable to
initialize, as the underlying window surface was still in use. After
attempting to reinitialize the compositor in response to an error, this
resulted in an endless loop of trying and failing to initialize.

After fixing this typo, RenderCompositorOGLSWGL correctly cleans up
after itself and subsequent instances are able to initialize.

Differential Revision: https://phabricator.services.mozilla.com/D135117

It's been enabled by default since ~forever.

Differential Revision: https://phabricator.services.mozilla.com/D134935

Differential Revision: https://phabricator.services.mozilla.com/D134639

The compiler might already be smart enough to not generate code in an
if-statement that guarantees to be `false` at compile time. However it's no harm
to make it explicit by using `if constexpr`.

Differential Revision: https://phabricator.services.mozilla.com/D135017

Differential Revision: https://phabricator.services.mozilla.com/D134986

Bug 1748216 - Ensure that we invalidate previously decoded images without a surface ready. r=jrmuizel

Part of how invalidation works with WebRender is that we assume frames
with a WebRenderUserData object attached to them are in view. This means
for images that we must ensure we create an empty
WebRenderImageProviderData object even when we have no provider or
surface for display. This will allow us to invalidate properly when we
get the FRAME_COMPLETE notification from imagelib indicating that the
redecode has completed.

Differential Revision: https://phabricator.services.mozilla.com/D135077

Backed out changeset 01217db0e1fc (bug 1748395) for causing build bustages on gfxFont.cpp. CLOSED TREE

The compiler might already be smart enough to not generate code in an
if-statement that guarantees to be `false` at compile time. However it's no harm
to make it explicit by using `if constexpr`.

Differential Revision: https://phabricator.services.mozilla.com/D135017

This shouldn't change behavior but makes following the code a bit
easier. There's no point in using callbacks for touch-action as:

 * We return the computed flags anyways.
 * Each caller wants to do something different.
 * (more importantly) The callback gets called synchronously.

So move the relevant code to TouchActionHelper and make the callers deal
with the flags as they please. I've preserved the behavior of only doing
the thing if the flags array is non-empty.

Differential Revision: https://phabricator.services.mozilla.com/D134933