--- a/gfx/layers/composite/ContainerLayerComposite.cpp
+++ b/gfx/layers/composite/ContainerLayerComposite.cpp
@@ -307,17 +307,16 @@ RenderMinimap(ContainerT* aContainer, La
const int horizontalPadding = 5;
gfx::Color backgroundColor(0.3f, 0.3f, 0.3f, 0.3f);
gfx::Color tileActiveColor(1, 1, 1, 0.4f);
gfx::Color tileBorderColor(0, 0, 0, 0.1f);
gfx::Color pageBorderColor(0, 0, 0);
gfx::Color criticalDisplayPortColor(1.f, 1.f, 0);
gfx::Color displayPortColor(0, 1.f, 0);
gfx::Color viewPortColor(0, 0, 1.f, 0.3f);
- gfx::Color visibilityColor(1.f, 0, 0);
// Rects
const FrameMetrics& fm = aLayer->GetFrameMetrics(0);
ParentLayerRect compositionBounds = fm.GetCompositionBounds();
LayerRect scrollRect = fm.GetScrollableRect() * fm.LayersPixelsPerCSSPixel();
LayerRect viewRect = ParentLayerRect(scrollOffset, compositionBounds.Size()) / LayerToParentLayerScale(1);
LayerRect dp = (fm.GetDisplayPort() + fm.GetScrollOffset()) * fm.LayersPixelsPerCSSPixel();
Maybe<LayerRect> cdp;
@@ -355,44 +354,16 @@ RenderMinimap(ContainerT* aContainer, La
Rect transformedScrollRect = transform.TransformBounds(scrollRect.ToUnknownRect());
IntRect clipRect = RoundedOut(aContainer->GetEffectiveTransform().TransformBounds(transformedScrollRect));
// Render the scrollable area.
compositor->FillRect(transformedScrollRect, backgroundColor, clipRect, aContainer->GetEffectiveTransform());
compositor->SlowDrawRect(transformedScrollRect, pageBorderColor, clipRect, aContainer->GetEffectiveTransform());
- // If enabled, render information about visibility.
- if (gfxPrefs::APZMinimapVisibilityEnabled()) {
- // Retrieve the APZC scrollable layer guid, which we'll use to get the
- // appropriate visibility information from the layer manager.
- AsyncPanZoomController* controller = aLayer->GetAsyncPanZoomController(0);
- MOZ_ASSERT(controller);
-
- ScrollableLayerGuid guid = controller->GetGuid();
-
- // Get the approximately visible region.
- static CSSIntRegion emptyRegion;
- CSSIntRegion* visibleRegion = aManager->GetApproximatelyVisibleRegion(guid);
- if (!visibleRegion) {
- visibleRegion = &emptyRegion;
- }
-
- // Iterate through and draw the rects in the region.
- for (CSSIntRegion::RectIterator iterator = visibleRegion->RectIter();
- !iterator.Done();
- iterator.Next())
- {
- CSSIntRect rect = iterator.Get();
- LayerRect scaledRect = rect * fm.LayersPixelsPerCSSPixel();
- Rect r = transform.TransformBounds(scaledRect.ToUnknownRect());
- compositor->FillRect(r, visibilityColor, clipRect, aContainer->GetEffectiveTransform());
- }
- }
-
// Render the displayport.
Rect r = transform.TransformBounds(dp.ToUnknownRect());
compositor->FillRect(r, tileActiveColor, clipRect, aContainer->GetEffectiveTransform());
compositor->SlowDrawRect(r, displayPortColor, clipRect, aContainer->GetEffectiveTransform());
// Render the critical displayport if there is one
if (cdp) {
r = transform.TransformBounds(cdp->ToUnknownRect());
--- a/gfx/layers/composite/LayerManagerComposite.h
+++ b/gfx/layers/composite/LayerManagerComposite.h
@@ -103,20 +103,16 @@ public:
virtual void GetBackendName(nsAString& name) override
{
MOZ_CRASH("GFX: Shouldn't be called for composited layer manager");
}
virtual void ForcePresent() = 0;
virtual void AddInvalidRegion(const nsIntRegion& aRegion) = 0;
- virtual void ClearApproximatelyVisibleRegions(uint64_t aLayersId,
- const Maybe<uint32_t>& aPresShellId) = 0;
- virtual void UpdateApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
- const CSSIntRegion& aRegion) = 0;
virtual void NotifyShadowTreeTransaction() {}
virtual void BeginTransactionWithDrawTarget(gfx::DrawTarget* aTarget,
const gfx::IntRect& aRect) = 0;
virtual Compositor* GetCompositor() const = 0;
virtual TextureSourceProvider* GetTextureSourceProvider() const = 0;
virtual void EndTransaction(const TimeStamp& aTimeStamp,
EndTransactionFlags aFlags = END_DEFAULT) = 0;
@@ -373,41 +369,16 @@ public:
static void PlatformSyncBeforeReplyUpdate();
void AddInvalidRegion(const nsIntRegion& aRegion) override
{
mInvalidRegion.Or(mInvalidRegion, aRegion);
}
- void ClearApproximatelyVisibleRegions(uint64_t aLayersId,
- const Maybe<uint32_t>& aPresShellId) override
- {
- for (auto iter = mVisibleRegions.Iter(); !iter.Done(); iter.Next()) {
- if (iter.Key().mLayersId == aLayersId &&
- (!aPresShellId || iter.Key().mPresShellId == *aPresShellId)) {
- iter.Remove();
- }
- }
- }
-
- void UpdateApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
- const CSSIntRegion& aRegion) override
- {
- CSSIntRegion* regionForScrollFrame = mVisibleRegions.LookupOrAdd(aGuid);
- MOZ_ASSERT(regionForScrollFrame);
-
- *regionForScrollFrame = aRegion;
- }
-
- CSSIntRegion* GetApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid)
- {
- return mVisibleRegions.Get(aGuid);
- }
-
Compositor* GetCompositor() const override {
return mCompositor;
}
TextureSourceProvider* GetTextureSourceProvider() const override {
return mCompositor;
}
void NotifyShadowTreeTransaction() override;
@@ -490,20 +461,16 @@ private:
/**
* Context target, nullptr when drawing directly to our swap chain.
*/
RefPtr<gfx::DrawTarget> mTarget;
gfx::IntRect mTargetBounds;
nsIntRegion mInvalidRegion;
- typedef nsClassHashtable<nsGenericHashKey<ScrollableLayerGuid>,
- CSSIntRegion> VisibleRegions;
- VisibleRegions mVisibleRegions;
-
bool mInTransaction;
bool mIsCompositorReady;
RefPtr<CompositingRenderTarget> mTwoPassTmpTarget;
RefPtr<TextRenderer> mTextRenderer;
#ifdef USE_SKIA
/**
--- a/gfx/layers/ipc/CompositorBridgeChild.cpp
+++ b/gfx/layers/ipc/CompositorBridgeChild.cpp
@@ -816,37 +816,16 @@ CompositorBridgeChild::SendRequestNotify
{
if (!mCanSend) {
return false;
}
return PCompositorBridgeChild::SendRequestNotifyAfterRemotePaint();
}
bool
-CompositorBridgeChild::SendClearApproximatelyVisibleRegions(uint64_t aLayersId,
- uint32_t aPresShellId)
-{
- if (!mCanSend) {
- return false;
- }
- return PCompositorBridgeChild::SendClearApproximatelyVisibleRegions(aLayersId,
- aPresShellId);
-}
-
-bool
-CompositorBridgeChild::SendNotifyApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
- const CSSIntRegion& aRegion)
-{
- if (!mCanSend) {
- return false;
- }
- return PCompositorBridgeChild::SendNotifyApproximatelyVisibleRegion(aGuid, aRegion);
-}
-
-bool
CompositorBridgeChild::SendAllPluginsCaptured()
{
if (!mCanSend) {
return false;
}
return PCompositorBridgeChild::SendAllPluginsCaptured();
}
--- a/gfx/layers/ipc/CompositorBridgeChild.h
+++ b/gfx/layers/ipc/CompositorBridgeChild.h
@@ -144,19 +144,16 @@ public:
bool SendAdoptChild(const uint64_t& id);
bool SendMakeSnapshot(const SurfaceDescriptor& inSnapshot, const gfx::IntRect& dirtyRect);
bool SendFlushRendering();
bool SendGetTileSize(int32_t* tileWidth, int32_t* tileHeight);
bool SendStartFrameTimeRecording(const int32_t& bufferSize, uint32_t* startIndex);
bool SendStopFrameTimeRecording(const uint32_t& startIndex, nsTArray<float>* intervals);
bool SendNotifyRegionInvalidated(const nsIntRegion& region);
bool SendRequestNotifyAfterRemotePaint();
- bool SendClearApproximatelyVisibleRegions(uint64_t aLayersId, uint32_t aPresShellId);
- bool SendNotifyApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
- const mozilla::CSSIntRegion& aRegion);
bool SendAllPluginsCaptured();
bool IsSameProcess() const override;
virtual bool IPCOpen() const override { return mCanSend; }
static void ShutDown();
void UpdateFwdTransactionId() { ++mFwdTransactionId; }
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -611,49 +611,16 @@ CompositorBridgeParent::RecvStopFrameTim
InfallibleTArray<float>* intervals)
{
if (mLayerManager) {
mLayerManager->StopFrameTimeRecording(aStartIndex, *intervals);
}
return IPC_OK();
}
-mozilla::ipc::IPCResult
-CompositorBridgeParent::RecvClearApproximatelyVisibleRegions(const uint64_t& aLayersId,
- const uint32_t& aPresShellId)
-{
- ClearApproximatelyVisibleRegions(aLayersId, Some(aPresShellId));
- return IPC_OK();
-}
-
-void
-CompositorBridgeParent::ClearApproximatelyVisibleRegions(const uint64_t& aLayersId,
- const Maybe<uint32_t>& aPresShellId)
-{
- if (mLayerManager) {
- mLayerManager->ClearApproximatelyVisibleRegions(aLayersId, aPresShellId);
-
- // We need to recomposite to update the minimap.
- ScheduleComposition();
- }
-}
-
-mozilla::ipc::IPCResult
-CompositorBridgeParent::RecvNotifyApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
- const CSSIntRegion& aRegion)
-{
- if (mLayerManager) {
- mLayerManager->UpdateApproximatelyVisibleRegion(aGuid, aRegion);
-
- // We need to recomposite to update the minimap.
- ScheduleComposition();
- }
- return IPC_OK();
-}
-
void
CompositorBridgeParent::ActorDestroy(ActorDestroyReason why)
{
mCanSend = false;
StopAndClearResources();
RemoveCompositor(mCompositorBridgeID);
@@ -1845,17 +1812,16 @@ void
EraseLayerState(uint64_t aId)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
auto iter = sIndirectLayerTrees.find(aId);
if (iter != sIndirectLayerTrees.end()) {
CompositorBridgeParent* parent = iter->second.mParent;
if (parent) {
- parent->ClearApproximatelyVisibleRegions(aId, Nothing());
if (RefPtr<APZSampler> apz = parent->GetAPZSampler()) {
apz->NotifyLayerTreeRemoved(aId);
}
}
sIndirectLayerTrees.erase(iter);
}
}
--- a/gfx/layers/ipc/CompositorBridgeParent.h
+++ b/gfx/layers/ipc/CompositorBridgeParent.h
@@ -228,23 +228,16 @@ public:
mozilla::ipc::IPCResult RecvStopFrameTimeRecording(const uint32_t& aStartIndex, InfallibleTArray<float>* intervals) override;
mozilla::ipc::IPCResult RecvCheckContentOnlyTDR(const uint32_t& sequenceNum, bool* isContentOnlyTDR) override { return IPC_OK(); }
// Unused for chrome <-> compositor communication (which this class does).
// @see CrossProcessCompositorBridgeParent::RecvRequestNotifyAfterRemotePaint
mozilla::ipc::IPCResult RecvRequestNotifyAfterRemotePaint() override { return IPC_OK(); };
- mozilla::ipc::IPCResult RecvClearApproximatelyVisibleRegions(const uint64_t& aLayersId,
- const uint32_t& aPresShellId) override;
- void ClearApproximatelyVisibleRegions(const uint64_t& aLayersId,
- const Maybe<uint32_t>& aPresShellId);
- mozilla::ipc::IPCResult RecvNotifyApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
- const CSSIntRegion& aRegion) override;
-
mozilla::ipc::IPCResult RecvAllPluginsCaptured() override;
void ActorDestroy(ActorDestroyReason why) override;
void ShadowLayersUpdated(LayerTransactionParent* aLayerTree,
const TransactionInfo& aInfo,
bool aHitTestUpdate) override;
void ScheduleComposite(LayerTransactionParent* aLayerTree) override;
--- a/gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
@@ -612,49 +612,16 @@ CrossProcessCompositorBridgeParent::Deal
}
bool
CrossProcessCompositorBridgeParent::IsSameProcess() const
{
return OtherPid() == base::GetCurrentProcId();
}
-mozilla::ipc::IPCResult
-CrossProcessCompositorBridgeParent::RecvClearApproximatelyVisibleRegions(const uint64_t& aLayersId,
- const uint32_t& aPresShellId)
-{
- CompositorBridgeParent* parent;
- { // scope lock
- MonitorAutoLock lock(*sIndirectLayerTreesLock);
- parent = sIndirectLayerTrees[aLayersId].mParent;
- }
- if (parent) {
- parent->ClearApproximatelyVisibleRegions(aLayersId, Some(aPresShellId));
- }
- return IPC_OK();
-}
-
-mozilla::ipc::IPCResult
-CrossProcessCompositorBridgeParent::RecvNotifyApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
- const CSSIntRegion& aRegion)
-{
- CompositorBridgeParent* parent;
- { // scope lock
- MonitorAutoLock lock(*sIndirectLayerTreesLock);
- parent = sIndirectLayerTrees[aGuid.mLayersId].mParent;
- }
- if (parent) {
- if (!parent->RecvNotifyApproximatelyVisibleRegion(aGuid, aRegion)) {
- return IPC_FAIL_NO_REASON(this);
- }
- return IPC_OK();;
- }
- return IPC_OK();
-}
-
void
CrossProcessCompositorBridgeParent::UpdatePaintTime(LayerTransactionParent* aLayerTree, const TimeDuration& aPaintTime)
{
uint64_t id = aLayerTree->GetId();
MOZ_ASSERT(id != 0);
CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(id);
--- a/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
+++ b/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
@@ -54,22 +54,16 @@ public:
mozilla::ipc::IPCResult RecvForcePresent() override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvWaitOnTransactionProcessed() override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvNotifyRegionInvalidated(const nsIntRegion& aRegion) override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvStartFrameTimeRecording(const int32_t& aBufferSize, uint32_t* aOutStartIndex) override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvStopFrameTimeRecording(const uint32_t& aStartIndex, InfallibleTArray<float>* intervals) override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvCheckContentOnlyTDR(const uint32_t& sequenceNum, bool* isContentOnlyTDR) override;
- mozilla::ipc::IPCResult RecvClearApproximatelyVisibleRegions(const uint64_t& aLayersId,
- const uint32_t& aPresShellId) override;
-
- mozilla::ipc::IPCResult RecvNotifyApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
- const CSSIntRegion& aRegion) override;
-
mozilla::ipc::IPCResult RecvAllPluginsCaptured() override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvGetFrameUniformity(FrameUniformityData* aOutData) override
{
// Don't support calculating frame uniformity on the child process and
// this is just a stub for now.
MOZ_ASSERT(false);
return IPC_OK();
--- a/gfx/layers/ipc/PCompositorBridge.ipdl
+++ b/gfx/layers/ipc/PCompositorBridge.ipdl
@@ -226,26 +226,16 @@ parent:
/**
* The child (content/chrome thread) requests that the parent inform it when
* the graphics objects are ready to display.
* @see PBrowser
* @see RemotePaintIsReady
*/
async RequestNotifyAfterRemotePaint();
- // The child clears the 'approximately visible' regions associated with the
- // provided layers ID and pres shell ID (i.e., the regions for all view IDs
- // associated with those IDs).
- async ClearApproximatelyVisibleRegions(uint64_t layersId, uint32_t presShellId);
-
- // The child sends a region containing rects associated with the provided
- // scrollable layer GUID that the child considers 'approximately visible'.
- // We visualize this information in the APZ minimap.
- async NotifyApproximatelyVisibleRegion(ScrollableLayerGuid guid, CSSIntRegion region);
-
/**
* Sent when the child has finished CaptureAllPlugins.
*/
async AllPluginsCaptured();
async PTexture(SurfaceDescriptor aSharedData, LayersBackend aBackend, TextureFlags aTextureFlags, uint64_t id, uint64_t aSerial, MaybeExternalImageId aExternalImageId);
sync SyncWithCompositor();
--- a/gfx/layers/mlgpu/LayerManagerMLGPU.h
+++ b/gfx/layers/mlgpu/LayerManagerMLGPU.h
@@ -51,20 +51,16 @@ public:
bool AreComponentAlphaLayersEnabled() override;
bool BlendingRequiresIntermediateSurface() override;
// HostLayerManager methods
void ForcePresent() override;
TextureFactoryIdentifier GetTextureFactoryIdentifier() override;
LayersBackend GetBackendType() override;
void AddInvalidRegion(const nsIntRegion& aRegion) override;
- void ClearApproximatelyVisibleRegions(uint64_t aLayersId,
- const Maybe<uint32_t>& aPresShellId) override {}
- void UpdateApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
- const CSSIntRegion& aRegion) override {}
void EndTransaction(const TimeStamp& aTimeStamp, EndTransactionFlags aFlags) override;
void EndTransaction(DrawPaintedLayerCallback aCallback,
void* aCallbackData,
EndTransactionFlags aFlags) override;
Compositor* GetCompositor() const override {
return nullptr;
}
bool IsCompositingToScreen() const override;
--- a/gfx/thebes/gfxPrefs.h
+++ b/gfx/thebes/gfxPrefs.h
@@ -320,17 +320,16 @@ private:
DECL_GFX_PREF(Live, "apz.fling_stopped_threshold", APZFlingStoppedThreshold, float, 0.01f);
DECL_GFX_PREF(Live, "apz.frame_delay.enabled", APZFrameDelayEnabled, bool, false);
DECL_GFX_PREF(Once, "apz.keyboard.enabled", APZKeyboardEnabled, bool, false);
DECL_GFX_PREF(Live, "apz.keyboard.passive-listeners", APZKeyboardPassiveListeners, bool, false);
DECL_GFX_PREF(Live, "apz.max_velocity_inches_per_ms", APZMaxVelocity, float, -1.0f);
DECL_GFX_PREF(Once, "apz.max_velocity_queue_size", APZMaxVelocityQueueSize, uint32_t, 5);
DECL_GFX_PREF(Live, "apz.min_skate_speed", APZMinSkateSpeed, float, 1.0f);
DECL_GFX_PREF(Live, "apz.minimap.enabled", APZMinimap, bool, false);
- DECL_GFX_PREF(Live, "apz.minimap.visibility.enabled", APZMinimapVisibilityEnabled, bool, false);
DECL_GFX_PREF(Live, "apz.one_touch_pinch.enabled", APZOneTouchPinchEnabled, bool, true);
DECL_GFX_PREF(Live, "apz.overscroll.enabled", APZOverscrollEnabled, bool, false);
DECL_GFX_PREF(Live, "apz.overscroll.min_pan_distance_ratio", APZMinPanDistanceRatio, float, 1.0f);
DECL_GFX_PREF(Live, "apz.overscroll.spring_stiffness", APZOverscrollSpringStiffness, float, 0.001f);
DECL_GFX_PREF(Live, "apz.overscroll.stop_distance_threshold", APZOverscrollStopDistanceThreshold, float, 5.0f);
DECL_GFX_PREF(Live, "apz.paint_skipping.enabled", APZPaintSkipping, bool, true);
DECL_GFX_PREF(Live, "apz.peek_messages.enabled", APZPeekMessages, bool, true);
DECL_GFX_PREF(Live, "apz.pinch_lock.mode", APZPinchLockMode, int32_t, 1);
--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -5674,75 +5674,23 @@ PresShell::ProcessSynthMouseMoveEvent(bo
shell->DispatchSynthMouseMove(&event, !aFromScroll);
}
if (!aFromScroll) {
mSynthMouseMoveEvent.Forget();
}
}
-static void
-AddFrameToVisibleRegions(nsIFrame* aFrame,
- nsViewManager* aViewManager,
- Maybe<VisibleRegions>& aVisibleRegions)
-{
- if (!aVisibleRegions) {
- return;
- }
-
- MOZ_ASSERT(aFrame);
- MOZ_ASSERT(aViewManager);
-
- // Retrieve the view ID for this frame (which we obtain from the enclosing
- // scrollable frame).
- nsIScrollableFrame* scrollableFrame =
- nsLayoutUtils::GetNearestScrollableFrame(aFrame,
- nsLayoutUtils::SCROLLABLE_ONLY_ASYNC_SCROLLABLE |
- nsLayoutUtils::SCROLLABLE_ALWAYS_MATCH_ROOT);
- if (!scrollableFrame) {
- return;
- }
-
- nsIFrame* scrollableFrameAsFrame = do_QueryFrame(scrollableFrame);
- MOZ_ASSERT(scrollableFrameAsFrame);
-
- nsIContent* scrollableFrameContent = scrollableFrameAsFrame->GetContent();
- if (!scrollableFrameContent) {
- return;
- }
-
- ViewID viewID;
- if (!nsLayoutUtils::FindIDFor(scrollableFrameContent, &viewID)) {
- return ;
- }
-
- // Update the visible region for the appropriate view ID.
- nsRect frameRectInScrolledFrameSpace = aFrame->GetVisualOverflowRect();
- nsLayoutUtils::TransformResult result =
- nsLayoutUtils::TransformRect(aFrame,
- scrollableFrame->GetScrolledFrame(),
- frameRectInScrolledFrameSpace);
- if (result != nsLayoutUtils::TransformResult::TRANSFORM_SUCCEEDED) {
- return;
- }
-
- CSSIntRegion* regionForView = aVisibleRegions->LookupOrAdd(viewID);
- MOZ_ASSERT(regionForView);
-
- regionForView->OrWith(CSSPixel::FromAppUnitsRounded(frameRectInScrolledFrameSpace));
-}
-
/* static */ void
-PresShell::MarkFramesInListApproximatelyVisible(const nsDisplayList& aList,
- Maybe<VisibleRegions>& aVisibleRegions)
+PresShell::MarkFramesInListApproximatelyVisible(const nsDisplayList& aList)
{
for (nsDisplayItem* item = aList.GetBottom(); item; item = item->GetAbove()) {
nsDisplayList* sublist = item->GetChildren();
if (sublist) {
- MarkFramesInListApproximatelyVisible(*sublist, aVisibleRegions);
+ MarkFramesInListApproximatelyVisible(*sublist);
continue;
}
nsIFrame* frame = item->Frame();
MOZ_ASSERT(frame);
if (!frame->TrackingVisibility()) {
continue;
@@ -5750,68 +5698,16 @@ PresShell::MarkFramesInListApproximately
// Use the presshell containing the frame.
auto* presShell = static_cast<PresShell*>(frame->PresShell());
MOZ_ASSERT(!presShell->AssumeAllFramesVisible());
if (presShell->mApproximatelyVisibleFrames.EnsureInserted(frame)) {
// The frame was added to mApproximatelyVisibleFrames, so increment its visible count.
frame->IncApproximateVisibleCount();
}
-
- AddFrameToVisibleRegions(frame, presShell->mViewManager, aVisibleRegions);
- }
-}
-
-static void
-NotifyCompositorOfVisibleRegionsChange(PresShell* aPresShell,
- const Maybe<VisibleRegions>& aRegions)
-{
- if (!aRegions) {
- return;
- }
-
- MOZ_ASSERT(aPresShell);
-
- // Retrieve the layers ID and pres shell ID.
- TabChild* tabChild = TabChild::GetFrom(aPresShell);
- if (!tabChild) {
- return;
- }
-
- const uint64_t layersId = tabChild->LayersId();
- const uint32_t presShellId = aPresShell->GetPresShellId();
-
- // Retrieve the CompositorBridgeChild.
- LayerManager* layerManager = aPresShell->GetLayerManager();
- if (!layerManager) {
- return;
- }
-
- ClientLayerManager* clientLayerManager = layerManager->AsClientLayerManager();
- if (!clientLayerManager) {
- return;
- }
-
- CompositorBridgeChild* compositorChild = clientLayerManager->GetCompositorBridgeChild();
- if (!compositorChild) {
- return;
- }
-
- // Clear the old approximately visible regions associated with this document.
- compositorChild->SendClearApproximatelyVisibleRegions(layersId, presShellId);
-
- // Send the new approximately visible regions to the compositor.
- for (auto iter = aRegions->ConstIter(); !iter.Done(); iter.Next()) {
- const ViewID viewId = iter.Key();
- const CSSIntRegion* region = iter.UserData();
- MOZ_ASSERT(region);
-
- const ScrollableLayerGuid guid(layersId, presShellId, viewId);
-
- compositorChild->SendNotifyApproximatelyVisibleRegion(guid, *region);
}
}
/* static */ void
PresShell::DecApproximateVisibleCount(VisibleFrames& aFrames,
const Maybe<OnNonvisible>& aNonvisibleAction
/* = Nothing() */)
{
@@ -5832,30 +5728,19 @@ PresShell::RebuildApproximateFrameVisibi
MOZ_ASSERT(!mApproximateFrameVisibilityVisited, "already visited?");
mApproximateFrameVisibilityVisited = true;
// Remove the entries of the mApproximatelyVisibleFrames hashtable and put
// them in oldApproxVisibleFrames.
VisibleFrames oldApproximatelyVisibleFrames;
mApproximatelyVisibleFrames.SwapElements(oldApproximatelyVisibleFrames);
- // If we're visualizing visible regions, create a VisibleRegions object to
- // store information about them. The functions we call will populate this
- // object and send it to the compositor only if it's Some(), so we don't
- // need to check the prefs everywhere.
- Maybe<VisibleRegions> visibleRegions;
- if (gfxPrefs::APZMinimap() && gfxPrefs::APZMinimapVisibilityEnabled()) {
- visibleRegions.emplace();
- }
-
- MarkFramesInListApproximatelyVisible(aList, visibleRegions);
+ MarkFramesInListApproximatelyVisible(aList);
DecApproximateVisibleCount(oldApproximatelyVisibleFrames);
-
- NotifyCompositorOfVisibleRegionsChange(this, visibleRegions);
}
/* static */ void
PresShell::ClearApproximateFrameVisibilityVisited(nsView* aView, bool aClear)
{
nsViewManager* vm = aView->GetViewManager();
if (aClear) {
PresShell* presShell = static_cast<PresShell*>(vm->GetPresShell());
@@ -5875,31 +5760,28 @@ PresShell::ClearApproximatelyVisibleFram
{
DecApproximateVisibleCount(mApproximatelyVisibleFrames, aNonvisibleAction);
mApproximatelyVisibleFrames.Clear();
}
void
PresShell::MarkFramesInSubtreeApproximatelyVisible(nsIFrame* aFrame,
const nsRect& aRect,
- Maybe<VisibleRegions>& aVisibleRegions,
bool aRemoveOnly /* = false */)
{
MOZ_ASSERT(aFrame->PresShell() == this, "wrong presshell");
if (aFrame->TrackingVisibility() &&
aFrame->StyleVisibility()->IsVisible() &&
(!aRemoveOnly || aFrame->GetVisibility() == Visibility::APPROXIMATELY_VISIBLE)) {
MOZ_ASSERT(!AssumeAllFramesVisible());
if (mApproximatelyVisibleFrames.EnsureInserted(aFrame)) {
// The frame was added to mApproximatelyVisibleFrames, so increment its visible count.
aFrame->IncApproximateVisibleCount();
}
-
- AddFrameToVisibleRegions(aFrame, mViewManager, aVisibleRegions);
}
nsSubDocumentFrame* subdocFrame = do_QueryFrame(aFrame);
if (subdocFrame) {
nsIPresShell* presShell = subdocFrame->GetSubdocumentPresShellForPainting(
nsSubDocumentFrame::IGNORE_PAINT_SUPPRESSION);
if (presShell && !presShell->AssumeAllFramesVisible()) {
nsRect rect = aRect;
@@ -5978,17 +5860,17 @@ PresShell::MarkFramesInSubtreeApproximat
nsRect out;
if (nsDisplayTransform::UntransformRect(r, overflow, child, &out)) {
r = out;
} else {
r.SetEmpty();
}
}
}
- MarkFramesInSubtreeApproximatelyVisible(child, r, aVisibleRegions);
+ MarkFramesInSubtreeApproximatelyVisible(child, r);
}
}
}
void
PresShell::RebuildApproximateFrameVisibility(nsRect* aRect,
bool aRemoveOnly /* = false */)
{
@@ -6000,35 +5882,24 @@ PresShell::RebuildApproximateFrameVisibi
return;
}
// Remove the entries of the mApproximatelyVisibleFrames hashtable and put
// them in oldApproximatelyVisibleFrames.
VisibleFrames oldApproximatelyVisibleFrames;
mApproximatelyVisibleFrames.SwapElements(oldApproximatelyVisibleFrames);
- // If we're visualizing visible regions, create a VisibleRegions object to
- // store information about them. The functions we call will populate this
- // object and send it to the compositor only if it's Some(), so we don't
- // need to check the prefs everywhere.
- Maybe<VisibleRegions> visibleRegions;
- if (gfxPrefs::APZMinimap() && gfxPrefs::APZMinimapVisibilityEnabled()) {
- visibleRegions.emplace();
- }
-
nsRect vis(nsPoint(0, 0), rootFrame->GetSize());
if (aRect) {
vis = *aRect;
}
- MarkFramesInSubtreeApproximatelyVisible(rootFrame, vis, visibleRegions, aRemoveOnly);
+ MarkFramesInSubtreeApproximatelyVisible(rootFrame, vis, aRemoveOnly);
DecApproximateVisibleCount(oldApproximatelyVisibleFrames);
-
- NotifyCompositorOfVisibleRegionsChange(this, visibleRegions);
}
void
PresShell::UpdateApproximateFrameVisibility()
{
DoUpdateApproximateFrameVisibility(/* aRemoveOnly = */ false);
}
--- a/layout/base/PresShell.h
+++ b/layout/base/PresShell.h
@@ -52,21 +52,16 @@ class Selection;
} // namespace dom
class EventDispatchingCallback;
// A set type for tracking visible frames, for use by the visibility code in
// PresShell. The set contains nsIFrame* pointers.
typedef nsTHashtable<nsPtrHashKey<nsIFrame>> VisibleFrames;
-// A hash table type for tracking visible regions, for use by the visibility
-// code in PresShell. The mapping is from view IDs to regions in the
-// coordinate system of that view's scrolled frame.
-typedef nsClassHashtable<nsUint64HashKey, CSSIntRegion> VisibleRegions;
-
// This is actually pref-controlled, but we use this value if we fail
// to get the pref for any reason.
#ifdef MOZ_WIDGET_ANDROID
#define PAINTLOCK_EVENT_DELAY 250
#else
#define PAINTLOCK_EVENT_DELAY 5
#endif
@@ -742,21 +737,19 @@ private:
//////////////////////////////////////////////////////////////////////////////
void UpdateApproximateFrameVisibility();
void DoUpdateApproximateFrameVisibility(bool aRemoveOnly);
void ClearApproximatelyVisibleFramesList(const Maybe<OnNonvisible>& aNonvisibleAction
= Nothing());
static void ClearApproximateFrameVisibilityVisited(nsView* aView, bool aClear);
- static void MarkFramesInListApproximatelyVisible(const nsDisplayList& aList,
- Maybe<VisibleRegions>& aVisibleRegions);
+ static void MarkFramesInListApproximatelyVisible(const nsDisplayList& aList);
void MarkFramesInSubtreeApproximatelyVisible(nsIFrame* aFrame,
const nsRect& aRect,
- Maybe<VisibleRegions>& aVisibleRegions,
bool aRemoveOnly = false);
void DecApproximateVisibleCount(VisibleFrames& aFrames,
const Maybe<OnNonvisible>& aNonvisibleAction = Nothing());
nsRevocableEventPtr<nsRunnableMethod<PresShell>> mUpdateApproximateFrameVisibilityEvent;
// A set of frames that were visible or could be visible soon at the time
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -734,17 +734,16 @@ pref("apz.keyboard.passive-listeners", t
#else
pref("apz.keyboard.enabled", false);
pref("apz.keyboard.passive-listeners", false);
#endif
pref("apz.max_velocity_inches_per_ms", "-1.0");
pref("apz.max_velocity_queue_size", 5);
pref("apz.min_skate_speed", "1.0");
pref("apz.minimap.enabled", false);
-pref("apz.minimap.visibility.enabled", false);
pref("apz.one_touch_pinch.enabled", true);
pref("apz.overscroll.enabled", false);
pref("apz.overscroll.min_pan_distance_ratio", "1.0");
pref("apz.overscroll.spring_friction", "0.015");
pref("apz.overscroll.spring_stiffness", "0.0018");
pref("apz.overscroll.stop_distance_threshold", "5.0");
pref("apz.overscroll.stop_velocity_threshold", "0.01");
pref("apz.overscroll.stretch_factor", "0.35");