From c088d491476f69894747f2f3f3e408581b35e286 Mon Sep 17 00:00:00 2001 From: Sandor Molnar Date: Sat, 18 Dec 2021 01:09:45 +0200 Subject: [PATCH] Backed out changeset a7c322ebcfea (bug 1737682) for causing high frequency bc failures in browser_panelUINotifications_multiWindow. CLOSED TREE --- gfx/layers/NativeLayerCA.h | 69 ++--- gfx/layers/NativeLayerCA.mm | 251 +++++-------------- toolkit/components/telemetry/Histograms.json | 11 - 3 files changed, 80 insertions(+), 251 deletions(-) diff --git a/gfx/layers/NativeLayerCA.h b/gfx/layers/NativeLayerCA.h index f755ed2eeb44..e34a67bbefc9 100644 --- a/gfx/layers/NativeLayerCA.h +++ b/gfx/layers/NativeLayerCA.h @@ -42,31 +42,6 @@ namespace layers { class NativeLayerRootSnapshotterCA; class SurfacePoolHandleCA; -enum class SpecializeType { - // Order here is important. Later enums will dominate earlier enums. - // These are ordered so that we can start with None, then progress to a - // soft failure state indicating that no further processing is needed. - // Active is followed by increasingly interesting failure states. Any - // state that starts with "Fail" is a failure state. - // These must be kept synchronized with the telemetry histogram enums. - - None, // Never emitted as telemetry. A baseline value. - FailNotVideo, // Never emitted as telemetry. No video is visible. We - // treat this as a failure state to prevent further - // processing of the layers. - Active, // "Active" instead of "Success" to avoid name-collision - FailPref, // on Linux. - Fail10_13, - FailFullscreen, - FailIsoMouse, // "FailIso" series denote a failure of isolation. - FailIsoTopVideo, // Abbreviating these enums keeps them below the - FailIsoSize, // 20-character limit for telemetry enums, which we want - FailIsoCenter, // to match exactly. - FailIsoOneVideo, - FailSurface, - FailEnqueue, -}; - // NativeLayerRootCA is the CoreAnimation implementation of the NativeLayerRoot // interface. A NativeLayerRootCA is created by the widget around an existing // CALayer with a call to CreateForCALayer - this CALayer is the root of the @@ -154,16 +129,14 @@ class NativeLayerRootCA : public NativeLayerRoot { struct Representation { explicit Representation(CALayer* aRootCALayer); ~Representation(); - SpecializeType Commit(WhichRepresentation aRepresentation, - const nsTArray>& aSublayers, - bool aWindowIsFullscreen, bool aMouseMovedRecently); + void Commit(WhichRepresentation aRepresentation, + const nsTArray>& aSublayers, + bool aWindowIsFullscreen, bool aMouseMovedRecently); CALayer* FindVideoLayerToIsolate( WhichRepresentation aRepresentation, - const nsTArray>& aSublayers, - SpecializeType& aSpecialize // out param - ); + const nsTArray>& aSublayers); CALayer* mRootCALayer = nullptr; // strong - SpecializeType mIsIsolatingVideo = SpecializeType::FailNotVideo; + bool mIsIsolatingVideo = false; bool mMutatedLayerStructure = false; bool mMutatedMouseMovedRecently = false; }; @@ -202,12 +175,6 @@ class NativeLayerRootCA : public NativeLayerRoot { // Has the mouse recently moved? bool mMouseMovedRecently = false; - - // How many times have we committed since the last time we emitted - // telemetry? - unsigned int mTelemetryCommitCount = 0; - static const unsigned int TELEMETRY_COMMIT_PERIOD = - 600; // 10 seconds at 60fps }; class RenderSourceNLRS; @@ -316,8 +283,7 @@ class NativeLayerCA : public NativeLayer { UpdateType HasUpdate(WhichRepresentation aRepresentation); bool WillUpdateAffectLayers(WhichRepresentation aRepresentation); - SpecializeType ApplyChanges(WhichRepresentation aRepresentation, - UpdateType aUpdate); + bool ApplyChanges(WhichRepresentation aRepresentation, UpdateType aUpdate); void SetBackingScale(float aBackingScale); @@ -352,8 +318,7 @@ class NativeLayerCA : public NativeLayer { bool IsVideo(); bool IsVideoAndLocked(const MutexAutoLock& aProofOfLock); - - SpecializeType CanSpecializeVideo(const MutexAutoLock& aProofOfLock); + bool ShouldSpecializeVideo(const MutexAutoLock& aProofOfLock); // Wraps one CALayer representation of this NativeLayer. struct Representation { @@ -373,15 +338,15 @@ class NativeLayerCA : public NativeLayer { // a partial update, the return value will indicate if all the needed // changes were able to be applied under these restrictions. A false return // value indicates an All update is necessary. - SpecializeType ApplyChanges(UpdateType aUpdate, const gfx::IntSize& aSize, - bool aIsOpaque, const gfx::IntPoint& aPosition, - const gfx::Matrix4x4& aTransform, - const gfx::IntRect& aDisplayRect, - const Maybe& aClipRect, - float aBackingScale, bool aSurfaceIsFlipped, - gfx::SamplingFilter aSamplingFilter, - SpecializeType aSpecializeVideo, - CFTypeRefPtr aFrontSurface); + bool ApplyChanges(UpdateType aUpdate, const gfx::IntSize& aSize, + bool aIsOpaque, const gfx::IntPoint& aPosition, + const gfx::Matrix4x4& aTransform, + const gfx::IntRect& aDisplayRect, + const Maybe& aClipRect, float aBackingScale, + bool aSurfaceIsFlipped, + gfx::SamplingFilter aSamplingFilter, + bool aSpecializeVideo, + CFTypeRefPtr aFrontSurface); // Return whether any aspects of this layer representation have been mutated // since the last call to ApplyChanges, i.e. whether ApplyChanges needs to @@ -484,7 +449,7 @@ class NativeLayerCA : public NativeLayer { bool mSurfaceIsFlipped = false; const bool mIsOpaque = false; bool mRootWindowIsFullscreen = false; - SpecializeType mSpecializeVideo = SpecializeType::None; + bool mSpecializeVideo = false; }; } // namespace layers diff --git a/gfx/layers/NativeLayerCA.mm b/gfx/layers/NativeLayerCA.mm index 48f9a8064076..5a413e24367f 100644 --- a/gfx/layers/NativeLayerCA.mm +++ b/gfx/layers/NativeLayerCA.mm @@ -26,7 +26,6 @@ #include "mozilla/layers/ScreenshotGrabber.h" #include "mozilla/layers/SurfacePoolCA.h" #include "mozilla/StaticPrefs_gfx.h" -#include "mozilla/Telemetry.h" #include "mozilla/webrender/RenderMacIOSurfaceTextureHost.h" #include "nsCocoaFeatures.h" #include "ScopedGLHelpers.h" @@ -48,58 +47,6 @@ using gfx::SurfaceFormat; using gl::GLContext; using gl::GLContextCGL; -/* static */ bool IsSpecializeFail(SpecializeType aSpecialize) { - return (aSpecialize != SpecializeType::None && aSpecialize != SpecializeType::Active); -} - -/* static */ Maybe SpecializeTypeToTelemetryType( - SpecializeType aSpecialize) { - switch (aSpecialize) { - case SpecializeType::Active: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::Active); - - case SpecializeType::FailPref: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::FailPref); - - case SpecializeType::Fail10_13: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::Fail10_13); - - case SpecializeType::FailFullscreen: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::FailFullscreen); - - case SpecializeType::FailIsoMouse: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::FailIsoMouse); - - case SpecializeType::FailIsoTopVideo: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::FailIsoTopVideo); - - case SpecializeType::FailIsoSize: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::FailIsoSize); - - case SpecializeType::FailIsoCenter: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::FailIsoCenter); - - case SpecializeType::FailIsoOneVideo: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::FailIsoOneVideo); - - case SpecializeType::FailSurface: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::FailSurface); - - case SpecializeType::FailEnqueue: - return Some(Telemetry::LABELS_GFX_MACOS_VIDEO_LOW_POWER::FailEnqueue); - - default: - return Nothing(); - } -} - -/* static */ void EmitTelemetryForSpecialize(SpecializeType aSpecialize) { - auto telemetryValue = SpecializeTypeToTelemetryType(aSpecialize); - if (telemetryValue.isSome()) { - Telemetry::AccumulateCategorical(telemetryValue.value()); - } -} - // Utility classes for NativeLayerRootSnapshotter (NLRS) profiler screenshots. class RenderSourceNLRS : public profiler_screenshots::RenderSource { @@ -187,8 +134,9 @@ static CALayer* MakeOffscreenRootCALayer() { NativeLayerRootCA::NativeLayerRootCA(CALayer* aLayer) : mMutex("NativeLayerRootCA"), mOnscreenRepresentation(aLayer), - mOffscreenRepresentation(MakeOffscreenRootCALayer()), - mLastMouseMoveTime(TimeStamp::NowLoRes()) {} + mOffscreenRepresentation(MakeOffscreenRootCALayer()) { + mLastMouseMoveTime = TimeStamp::NowLoRes(); +} NativeLayerRootCA::~NativeLayerRootCA() { MOZ_RELEASE_ASSERT(mSublayers.IsEmpty(), @@ -293,14 +241,9 @@ bool NativeLayerRootCA::CommitToScreen() { } UpdateMouseMovedRecently(lock); - SpecializeType specialize = mOnscreenRepresentation.Commit( - WhichRepresentation::ONSCREEN, mSublayers, mWindowIsFullscreen, mMouseMovedRecently); + mOnscreenRepresentation.Commit(WhichRepresentation::ONSCREEN, mSublayers, mWindowIsFullscreen, + mMouseMovedRecently); - // Decide if we are going to emit telemetry about video specialization on this commit. - mTelemetryCommitCount = (mTelemetryCommitCount + 1) % TELEMETRY_COMMIT_PERIOD; - if (mTelemetryCommitCount == 0) { - EmitTelemetryForSpecialize(specialize); - } mCommitPending = false; } @@ -371,13 +314,11 @@ NativeLayerRootCA::Representation::~Representation() { [mRootCALayer release]; } -SpecializeType NativeLayerRootCA::Representation::Commit( - WhichRepresentation aRepresentation, const nsTArray>& aSublayers, - bool aWindowIsFullscreen, bool aMouseMovedRecently) { - SpecializeType specialize = SpecializeType::None; - +void NativeLayerRootCA::Representation::Commit(WhichRepresentation aRepresentation, + const nsTArray>& aSublayers, + bool aWindowIsFullscreen, bool aMouseMovedRecently) { bool mightIsolate = (aRepresentation == WhichRepresentation::ONSCREEN && - StaticPrefs::gfx_core_animation_specialize_video() && aWindowIsFullscreen); + StaticPrefs::gfx_core_animation_specialize_video()); bool mustRebuild = (mMutatedLayerStructure || (mightIsolate && mMutatedMouseMovedRecently)); if (!mustRebuild) { // Check which type of update we need to do, if any. @@ -393,23 +334,18 @@ SpecializeType NativeLayerRootCA::Representation::Commit( if (updateRequired == NativeLayerCA::UpdateType::None) { // Nothing more needed, so early exit. - return specialize; + return; } if (updateRequired == NativeLayerCA::UpdateType::OnlyVideo) { - for (auto layer : aSublayers) { - // Use the ordering of our SpecializeType enums to build a specialize - // state that succeeds as long as it doesn't fail. - specialize = std::max( - specialize, layer->ApplyChanges(aRepresentation, NativeLayerCA::UpdateType::OnlyVideo)); - } + bool allUpdatesSucceeded = std::all_of( + aSublayers.begin(), aSublayers.end(), [=](const RefPtr& layer) { + return layer->ApplyChanges(aRepresentation, NativeLayerCA::UpdateType::OnlyVideo); + }); - if (!IsSpecializeFail(specialize)) { - // Nothing more needed, so early exit. - // We've completed an OnlyVideo update, but we don't know if the layers have been - // isolated. We've stored the isolation state in mIsIsolatingVideo, so emit that as - // telemetry. - return mIsIsolatingVideo; + if (allUpdatesSucceeded) { + // Nothing more needed, so early exit; + return; } } } @@ -418,8 +354,7 @@ SpecializeType NativeLayerRootCA::Representation::Commit( AutoCATransaction transaction; for (auto layer : aSublayers) { mustRebuild |= layer->WillUpdateAffectLayers(aRepresentation); - specialize = - std::max(specialize, layer->ApplyChanges(aRepresentation, NativeLayerCA::UpdateType::All)); + layer->ApplyChanges(aRepresentation, NativeLayerCA::UpdateType::All); } if (mustRebuild) { @@ -469,46 +404,28 @@ SpecializeType NativeLayerRootCA::Representation::Commit( "The topmost layer must be a child of mRootCALayer."); bool didIsolate = false; - - // If we decided that there's no way we can isolate, then specialize should have - // been assigned a fail value. The logic is !mightIsolate => fail specialize. We - // assert that so the decision of whether or not we attempt isolation can be based - // purely on the specialize value. - MOZ_ASSERT(mightIsolate || IsSpecializeFail(specialize), - "If we know we can't isolate, specialize should be a failure."); - - // As long as specialize isn't failing, we can attempt to isolate. - if (!IsSpecializeFail(specialize)) { - CALayer* isolatedLayer = FindVideoLayerToIsolate(aRepresentation, aSublayers, specialize); + if (mightIsolate && aWindowIsFullscreen && !aMouseMovedRecently) { + CALayer* isolatedLayer = FindVideoLayerToIsolate(aRepresentation, aSublayers); if (isolatedLayer) { - MOZ_ASSERT(!IsSpecializeFail(specialize), - "We chose to isolate, so we shouldn't have a specialize fail."); + // No matter what happens next, we did choose to isolate. + didIsolate = true; - if (aMouseMovedRecently) { - // We aren't able to isolate this otherwise specializable video. - specialize = SpecializeType::FailIsoMouse; - } else { - // No matter what happens next, we did choose to isolate. - didIsolate = true; + // We only need to change our sublayers if we weren't already isolating, or + // if the isolatedLayer does not match our current top layer. + if (!mIsIsolatingVideo || isolatedLayer != mRootCALayer.sublayers.lastObject) { + // Create a full coverage black layer behind the isolated layer. + CGFloat rootWidth = mRootCALayer.bounds.size.width; + CGFloat rootHeight = mRootCALayer.bounds.size.height; - // We only need to change our sublayers if we weren't already isolating, or - // if the isolatedLayer does not match our current top layer. - if (IsSpecializeFail(mIsIsolatingVideo) || - isolatedLayer != mRootCALayer.sublayers.lastObject) { - // Create a full coverage black layer behind the isolated layer. - CGFloat rootWidth = mRootCALayer.bounds.size.width; - CGFloat rootHeight = mRootCALayer.bounds.size.height; + // Reaching the low-power mode requires that there is a single black layer + // covering the entire window behind the video layer. Create that layer. + CALayer* blackLayer = [CALayer layer]; + blackLayer.position = NSZeroPoint; + blackLayer.anchorPoint = NSZeroPoint; + blackLayer.bounds = CGRectMake(0, 0, rootWidth, rootHeight); + blackLayer.backgroundColor = [[NSColor blackColor] CGColor]; - // Reaching the low-power mode requires that there is a single black layer - // covering the entire window behind the video layer. Create that layer. - CALayer* blackLayer = [CALayer layer]; - blackLayer.position = NSZeroPoint; - blackLayer.anchorPoint = NSZeroPoint; - blackLayer.bounds = CGRectMake(0, 0, rootWidth, rootHeight); - blackLayer.backgroundColor = [[NSColor blackColor] CGColor]; - - mRootCALayer.sublayers = @[ blackLayer, isolatedLayer ]; - } + mRootCALayer.sublayers = @[ blackLayer, isolatedLayer ]; } } } @@ -518,25 +435,16 @@ SpecializeType NativeLayerRootCA::Representation::Commit( if (topLayerIsRooted && !didIsolate) { acceptProvidedSublayers(); } - } else if (aMouseMovedRecently && specialize == SpecializeType::Active) { - // We aren't able to isolate this otherwise specializable video. - specialize = SpecializeType::FailIsoMouse; + + mIsIsolatingVideo = didIsolate; } mMutatedLayerStructure = false; mMutatedMouseMovedRecently = false; - - // Store our specialize value to inform future Commits. We use this to determine if the - // layers were already successfully isolated during an OnlyVideo update, and to determine - // if we are already isolating when we identify an opportunity to do so. - mIsIsolatingVideo = specialize; - - return specialize; } CALayer* NativeLayerRootCA::Representation::FindVideoLayerToIsolate( - WhichRepresentation aRepresentation, const nsTArray>& aSublayers, - SpecializeType& aSpecialize) { + WhichRepresentation aRepresentation, const nsTArray>& aSublayers) { // Run a heuristic to determine if any one of aSublayers is a video layer that should be // isolated. These layers are ordered back-to-front. This function will return a candidate // CALayer if all of the following are true: @@ -553,7 +461,6 @@ CALayer* NativeLayerRootCA::Representation::FindVideoLayerToIsolate( auto topLayer = aSublayers.LastElement(); if (!topLayer || !topLayer->IsVideo()) { // FAIL Step 1: the topmost layer is not video. - aSpecialize = SpecializeType::FailIsoTopVideo; return nil; } @@ -573,7 +480,6 @@ CALayer* NativeLayerRootCA::Representation::FindVideoLayerToIsolate( CGFloat candidateArea = candidateBoundsInRoot.size.width * candidateBoundsInRoot.size.height; if (candidateArea < minimumRootArea) { // FAIL Step 2: the candidate layer is not big enough. - aSpecialize = SpecializeType::FailIsoSize; return nil; } @@ -588,7 +494,6 @@ CALayer* NativeLayerRootCA::Representation::FindVideoLayerToIsolate( candidateBoundsInRoot.origin.y + (candidateBoundsInRoot.size.height * 0.5)); if (!CGRectContainsPoint(centerZone, candidateCenterInRoot)) { // FAIL Step 3: the candidate layer is off-center. - aSpecialize = SpecializeType::FailIsoCenter; return nil; } @@ -596,7 +501,6 @@ CALayer* NativeLayerRootCA::Representation::FindVideoLayerToIsolate( for (auto layer : aSublayers) { if (layer->IsVideo() && layer != topLayer) { // FAIL Step 4: there are multiple video layers. - aSpecialize = SpecializeType::FailIsoOneVideo; return nil; } } @@ -854,8 +758,8 @@ void NativeLayerCA::AttachExternalImage(wr::RenderTextureHost* aExternalImage) { mDisplayRect = IntRect(IntPoint{}, mSize); - SpecializeType oldSpecializeVideo = mSpecializeVideo; - mSpecializeVideo = CanSpecializeVideo(lock); + bool oldSpecializeVideo = mSpecializeVideo; + mSpecializeVideo = ShouldSpecializeVideo(lock); bool changedSpecializeVideo = (mSpecializeVideo != oldSpecializeVideo); ForAllRepresentations([&](Representation& r) { @@ -876,24 +780,10 @@ bool NativeLayerCA::IsVideoAndLocked(const MutexAutoLock& aProofOfLock) { return mTextureHost; } -SpecializeType NativeLayerCA::CanSpecializeVideo(const MutexAutoLock& aProofOfLock) { - if (!IsVideoAndLocked(aProofOfLock)) { - return SpecializeType::FailNotVideo; - } - - if (!StaticPrefs::gfx_core_animation_specialize_video()) { - return SpecializeType::FailPref; - } - - if (!nsCocoaFeatures::OnHighSierraOrLater()) { - return SpecializeType::Fail10_13; - } - - if (!mRootWindowIsFullscreen) { - return SpecializeType::FailFullscreen; - } - - return SpecializeType::None; +bool NativeLayerCA::ShouldSpecializeVideo(const MutexAutoLock& aProofOfLock) { + return StaticPrefs::gfx_core_animation_specialize_video() && + nsCocoaFeatures::OnHighSierraOrLater() && mRootWindowIsFullscreen && + IsVideoAndLocked(aProofOfLock); } void NativeLayerCA::SetRootWindowIsFullscreen(bool aFullscreen) { @@ -901,8 +791,8 @@ void NativeLayerCA::SetRootWindowIsFullscreen(bool aFullscreen) { mRootWindowIsFullscreen = aFullscreen; - SpecializeType oldSpecializeVideo = mSpecializeVideo; - mSpecializeVideo = CanSpecializeVideo(lock); + bool oldSpecializeVideo = mSpecializeVideo; + mSpecializeVideo = ShouldSpecializeVideo(lock); if (mSpecializeVideo != oldSpecializeVideo) { ForAllRepresentations([&](Representation& r) { r.mMutatedSpecializeVideo = true; }); @@ -1314,8 +1204,8 @@ NativeLayerCA::UpdateType NativeLayerCA::HasUpdate(WhichRepresentation aRepresen return GetRepresentation(aRepresentation).HasUpdate(IsVideoAndLocked(lock)); } -SpecializeType NativeLayerCA::ApplyChanges(WhichRepresentation aRepresentation, - NativeLayerCA::UpdateType aUpdate) { +bool NativeLayerCA::ApplyChanges(WhichRepresentation aRepresentation, + NativeLayerCA::UpdateType aUpdate) { MutexAutoLock lock(mMutex); CFTypeRefPtr surface; if (mFrontSurface) { @@ -1384,44 +1274,38 @@ bool NativeLayerCA::Representation::EnqueueSurface(IOSurfaceRef aSurfaceRef) { return true; } -SpecializeType NativeLayerCA::Representation::ApplyChanges( +bool NativeLayerCA::Representation::ApplyChanges( NativeLayerCA::UpdateType aUpdate, const IntSize& aSize, bool aIsOpaque, const IntPoint& aPosition, const Matrix4x4& aTransform, const IntRect& aDisplayRect, const Maybe& aClipRect, float aBackingScale, bool aSurfaceIsFlipped, - gfx::SamplingFilter aSamplingFilter, SpecializeType aSpecializeVideo, + gfx::SamplingFilter aSamplingFilter, bool aSpecializeVideo, CFTypeRefPtr aFrontSurface) { - SpecializeType specialize = aSpecializeVideo; - bool tryToSpecialize = !IsSpecializeFail(aSpecializeVideo); - // If we have an OnlyVideo update, handle it and early exit. if (aUpdate == UpdateType::OnlyVideo) { // If we don't have any updates to do, exit early with success. This is // important to do so that the overall OnlyVideo pass will succeed as long // as the video layers are successful. if (HasUpdate(true) == UpdateType::None) { - return specialize; + return true; } MOZ_ASSERT(!mMutatedSpecializeVideo && mMutatedFrontSurface, "Shouldn't attempt a OnlyVideo update in this case."); - if (tryToSpecialize) { + bool updateSucceeded = false; + if (aSpecializeVideo) { IOSurfaceRef surface = aFrontSurface.get(); if (CanSpecializeSurface(surface)) { IOSurfaceRef surface = aFrontSurface.get(); - bool isEnqueued = EnqueueSurface(surface); - if (isEnqueued) { + updateSucceeded = EnqueueSurface(surface); + + if (updateSucceeded) { mMutatedFrontSurface = false; - specialize = SpecializeType::Active; - } else { - specialize = SpecializeType::FailEnqueue; } - } else { - specialize = SpecializeType::FailSurface; } } - return specialize; + return updateSucceeded; } MOZ_ASSERT(aUpdate == UpdateType::All); @@ -1445,7 +1329,7 @@ SpecializeType NativeLayerCA::Representation::ApplyChanges( mWrappingCALayer.anchorPoint = NSZeroPoint; mWrappingCALayer.contentsGravity = kCAGravityTopLeft; mWrappingCALayer.edgeAntialiasingMask = 0; - if (tryToSpecialize) { + if (aSpecializeVideo) { mContentCALayer = [[AVSampleBufferDisplayLayer layer] retain]; } else { mContentCALayer = [[CALayer layer] retain]; @@ -1566,18 +1450,9 @@ SpecializeType NativeLayerCA::Representation::ApplyChanges( if (mMutatedFrontSurface) { bool isEnqueued = false; IOSurfaceRef surface = aFrontSurface.get(); - if (tryToSpecialize) { - if (CanSpecializeSurface(surface)) { - // Attempt to enqueue this as a video frame. If we fail, we'll fall back to image case. - isEnqueued = EnqueueSurface(surface); - if (isEnqueued) { - specialize = SpecializeType::Active; - } else { - specialize = SpecializeType::FailEnqueue; - } - } else { - specialize = SpecializeType::FailSurface; - } + if (aSpecializeVideo && CanSpecializeSurface(surface)) { + // Attempt to enqueue this as a video frame. If we fail, we'll fall back to image case. + isEnqueued = EnqueueSurface(surface); } if (!isEnqueued) { @@ -1606,7 +1481,7 @@ SpecializeType NativeLayerCA::Representation::ApplyChanges( mMutatedSamplingFilter = false; mMutatedSpecializeVideo = false; - return specialize; + return true; } NativeLayerCA::UpdateType NativeLayerCA::Representation::HasUpdate(bool aIsVideo) { diff --git a/toolkit/components/telemetry/Histograms.json b/toolkit/components/telemetry/Histograms.json index 5e5a3b6cd34d..9f3afb363ce8 100644 --- a/toolkit/components/telemetry/Histograms.json +++ b/toolkit/components/telemetry/Histograms.json @@ -15965,17 +15965,6 @@ "description": "The amount of async paint tasks queued to the paint thread during a layer transaction.", "bug_numbers": [1483245] }, - "GFX_MACOS_VIDEO_LOW_POWER": { - "record_in_processes": ["main"], - "products": ["firefox"], - "alert_emails": ["bwerth@mozilla.com"], - "expires_in_version": "never", - "releaseChannelCollection": "opt-out", - "bug_numbers": [1737682], - "description": "MacOS video low power state achieved when enqueueing a video frame.", - "kind": "categorical", - "labels": ["None", "FailNotVideo", "Active", "FailPref", "Fail10_13", "FailFullscreen", "FailIsoMouse", "FailIsoTopVideo", "FailIsoSize", "FailIsoCenter", "FailIsoOneVideo", "FailSurface", "FailEnqueue"] - }, "PERMISSION_REQUEST_ORIGIN_SCHEME": { "record_in_processes": ["main"], "products": ["firefox", "fennec"],