Merge "Implement stop layers" into main

Author: Treehugger Robot

libs/gui/LayerState.cpp

@@ -919,6 +919,7 @@ uint64_t layer_state_t::diff(const layer_state_t& other) const {
     if (other.what & eLutsChanged) diff |= eLutsChanged;
     CHECK_DIFF(diff, ePictureProfileHandleChanged, other, pictureProfileHandle);
     CHECK_DIFF(diff, eAppContentPriorityChanged, other, appContentPriority);
+    if (other.what & eStopLayerChanged) diff |= eStopLayerChanged;
 
     return diff;
 }

libs/gui/include/gui/LayerState.h

@@ -254,6 +254,7 @@ struct layer_state_t {
         eClientDrawnCornerRadiusChanged = 0x200000'00000000,
         eBorderSettingsChanged = 0x400000'00000000,
         eBoxShadowSettingsChanged = 0x800000'00000000,
+        eStopLayerChanged = 0x1000000'00000000,
     };
 
     layer_state_t();

services/surfaceflinger/FrontEnd/LayerCreationArgs.h

@@ -61,6 +61,7 @@ struct LayerCreationArgs {
     ui::LayerStack layerStackToMirror = ui::UNASSIGNED_LAYER_STACK;
     uint32_t parentId = UNASSIGNED_LAYER_ID;
     uint32_t layerIdToMirror = UNASSIGNED_LAYER_ID;
+    uint32_t stopLayerId = UNASSIGNED_LAYER_ID;
     std::atomic<int32_t>* pendingBuffers = 0;
 };
 

services/surfaceflinger/FrontEnd/LayerSnapshotBuilder.cpp

@@ -450,11 +450,17 @@ void LayerSnapshotBuilder::updateSnapshots(const Args& args) {
         LayerHierarchy::TraversalPath childPath =
                 root.makeChild(args.root.getLayer()->id, LayerHierarchy::Variant::Attached);
         updateSnapshotsInHierarchy(args, args.root, childPath, rootSnapshot, /*depth=*/0);
+        if (FlagManager::getInstance().stop_layer()) {
+            applyStopLayers(args.root, childPath);
+        }
     } else {
         for (auto& [childHierarchy, variant] : args.root.mChildren) {
             LayerHierarchy::TraversalPath childPath =
                     root.makeChild(childHierarchy->getLayer()->id, variant);
             updateSnapshotsInHierarchy(args, *childHierarchy, childPath, rootSnapshot, /*depth=*/0);
+            if (FlagManager::getInstance().stop_layer()) {
+                applyStopLayers(*childHierarchy, childPath);
+            }
         }
     }
 
@@ -1397,4 +1403,98 @@ void LayerSnapshotBuilder::updateTouchableRegionCrop(const Args& args) {
     }
 }
 
+// Apply stop layers to the hierarchy.
+//
+// If layer X specifies stop layer Y, then any layer within X's subhierarchy that is z-ordered
+// above Y is hidden. The stop layer itself, layer Y, is also hidden.
+//
+// This works by traversing the hierarchy in z-order. When a layer that specifies a stop layer is
+// encountered, the specified stop layer is pushed to the stopLayer stack, the subhierarchy is
+// traversed, then the stop layer is popped from the stack. If a layer whose id is stored in the
+// stop layer stack is encountered during traversal, it is added to the activeStopLayers set. Any
+// layer visited while the activeStopLayer set is non-empty is hidden. When an element is popped
+// from the stopLayer stack, any active stop layers that are no longer in the stopLayer stack are
+// removed from the activeStopLayers set.
+void LayerSnapshotBuilder::applyStopLayers(const LayerHierarchy& hierarchy,
+                                           const LayerHierarchy::TraversalPath& traversalPath) {
+    ftl::SmallVector<uint32_t, 5> stopLayers;
+    ftl::SmallVector<uint32_t, 5> activeStopLayers;
+    applyStopLayersInternal(hierarchy, traversalPath, stopLayers, activeStopLayers);
+}
+
+void LayerSnapshotBuilder::applyStopLayersInternal(
+        const LayerHierarchy& hierarchy, const LayerHierarchy::TraversalPath& traversalPath,
+        ftl::SmallVector<uint32_t, 5>& stopLayers,
+        ftl::SmallVector<uint32_t, 5>& activeStopLayers) {
+    const RequestedLayerState* layer = hierarchy.getLayer();
+
+    // Push to the stopLayer stack.
+    if (layer->stopLayerId != UNASSIGNED_LAYER_ID) {
+        stopLayers.push_back(layer->stopLayerId);
+    }
+
+    // Hide this layer if the activeStopLayers set is non-empty.
+    if (!activeStopLayers.empty()) {
+        LayerSnapshot* snapshot = getSnapshot(traversalPath);
+        snapshot->isHiddenByPolicyFromParent = true;
+    }
+
+    // Traverse z-ordered below children before potentially activating this layer as a stop layer.
+    auto childIt = hierarchy.mChildren.begin();
+    while (childIt != hierarchy.mChildren.end()) {
+        auto& [childHierarchy, childVariant] = *childIt;
+        if (childHierarchy->getLayer()->z >= 0) {
+            break;
+        }
+        childIt++;
+
+        LayerHierarchy::TraversalPath childTraversalPath =
+                traversalPath.makeChild(childHierarchy->getLayer()->id, childVariant);
+        if (childTraversalPath.detached) {
+            continue;
+        }
+
+        applyStopLayersInternal(*childHierarchy, childTraversalPath, stopLayers, activeStopLayers);
+    }
+
+    // Activate this layer as a stop layer if it's in the stopLayers stack.
+    bool isStopLayer =
+            std::find(stopLayers.begin(), stopLayers.end(), layer->id) != stopLayers.end();
+    if (isStopLayer) {
+        activeStopLayers.push_back(layer->id);
+        LayerSnapshot* snapshot = getSnapshot(traversalPath);
+        snapshot->isHiddenByPolicyFromParent = true;
+    }
+
+    // Traverse z-ordered above children.
+    while (childIt != hierarchy.mChildren.end()) {
+        auto& [childHierarchy, childVariant] = *childIt++;
+
+        LayerHierarchy::TraversalPath childTraversalPath =
+                traversalPath.makeChild(childHierarchy->getLayer()->id, childVariant);
+        if (childTraversalPath.detached) {
+            continue;
+        }
+
+        applyStopLayersInternal(*childHierarchy, childTraversalPath, stopLayers, activeStopLayers);
+    }
+
+    // Pop from the stopLayer stack and remove active stop layers from the activeStopLayers set
+    // if necessary.
+    if (layer->stopLayerId != UNASSIGNED_LAYER_ID) {
+        stopLayers.pop_back();
+
+        auto it = activeStopLayers.begin();
+        while (it != activeStopLayers.end()) {
+            bool stopLayerNoLongerActive =
+                    std::find(stopLayers.begin(), stopLayers.end(), *it) == stopLayers.end();
+            if (stopLayerNoLongerActive) {
+                activeStopLayers.unstable_erase(it);
+            } else {
+                it++;
+            }
+        }
+    }
+}
+
 } // namespace android::surfaceflinger::frontend

services/surfaceflinger/FrontEnd/LayerSnapshotBuilder.h

@@ -139,6 +139,11 @@ class LayerSnapshotBuilder {
                                           const Args& args, bool* outChildHasValidFrameRate);
     void updateTouchableRegionCrop(const Args& args);
 
+    void applyStopLayers(const LayerHierarchy&, const LayerHierarchy::TraversalPath&);
+    void applyStopLayersInternal(const LayerHierarchy&, const LayerHierarchy::TraversalPath&,
+                                 ftl::SmallVector<uint32_t, 5>& stopLayers,
+                                 ftl::SmallVector<uint32_t, 5>& activeStopLayers);
+
     std::unordered_map<LayerHierarchy::TraversalPath, LayerSnapshot*,
                        LayerHierarchy::TraversalPathHash>
             mPathToSnapshot;

services/surfaceflinger/FrontEnd/RequestedLayerState.cpp

@@ -57,6 +57,7 @@ RequestedLayerState::RequestedLayerState(const LayerCreationArgs& args)
         ownerPid(args.ownerPid),
         parentId(args.parentId),
         layerIdToMirror(args.layerIdToMirror),
+        stopLayerId(args.stopLayerId),
         pendingBuffers(args.pendingBuffers) {
     layerId = static_cast<int32_t>(args.sequence);
     changes |= RequestedLayerState::Changes::Created;
@@ -359,6 +360,11 @@ void RequestedLayerState::merge(const ResolvedComposerState& resolvedComposerSta
         changes |= RequestedLayerState::Changes::Geometry;
     }
 
+    if (clientState.what & layer_state_t::eStopLayerChanged) {
+        stopLayerId = resolvedComposerState.stopLayerId;
+        changes |= RequestedLayerState::Changes::Visibility;
+    }
+
     // We can't just check requestedTransform here because LayerSnapshotBuilder uses
     // getTransform which reads destinationFrame or buffer dimensions.
     // Display rotation does not affect validity so just use ROT_0.

services/surfaceflinger/FrontEnd/RequestedLayerState.h

@@ -128,6 +128,7 @@ struct RequestedLayerState : layer_state_t {
     uint32_t parentId = UNASSIGNED_LAYER_ID;
     uint32_t relativeParentId = UNASSIGNED_LAYER_ID;
     uint32_t layerIdToMirror = UNASSIGNED_LAYER_ID;
+    uint32_t stopLayerId = UNASSIGNED_LAYER_ID;
     ui::LayerStack layerStackToMirror = ui::UNASSIGNED_LAYER_STACK;
     uint32_t touchCropId = UNASSIGNED_LAYER_ID;
     uint32_t bgColorLayerId = UNASSIGNED_LAYER_ID;

services/surfaceflinger/QueuedTransactionState.h

@@ -46,6 +46,7 @@ class ResolvedComposerState : public ComposerState {
     uint32_t parentId = UNASSIGNED_LAYER_ID;
     uint32_t relativeParentId = UNASSIGNED_LAYER_ID;
     uint32_t touchCropId = UNASSIGNED_LAYER_ID;
+    uint32_t stopLayerId = UNASSIGNED_LAYER_ID;
 };
 
 struct QueuedTransactionState {

services/surfaceflinger/tests/common/LayerLifecycleManagerHelper.h

@@ -45,12 +45,13 @@ class LayerLifecycleManagerHelper {
         return args;
     }
 
-    static LayerCreationArgs createDisplayMirrorArgs(uint32_t id,
-                                                     ui::LayerStack layerStackToMirror) {
+    static LayerCreationArgs createDisplayMirrorArgs(uint32_t id, ui::LayerStack layerStackToMirror,
+                                                     uint32_t stopLayerId = UNASSIGNED_LAYER_ID) {
         LayerCreationArgs args(std::make_optional(id));
         args.name = "testlayer";
         args.addToRoot = true;
         args.layerStackToMirror = layerStackToMirror;
+        args.stopLayerId = stopLayerId;
         return args;
     }
 
@@ -94,10 +95,11 @@ class LayerLifecycleManagerHelper {
         mLifecycleManager.addLayers(std::move(layers));
     }
 
-    void createDisplayMirrorLayer(uint32_t id, ui::LayerStack layerStack) {
+    void createDisplayMirrorLayer(uint32_t id, ui::LayerStack layerStack,
+                                  uint32_t stopLayerId = UNASSIGNED_LAYER_ID) {
         std::vector<std::unique_ptr<RequestedLayerState>> layers;
         layers.emplace_back(std::make_unique<RequestedLayerState>(
-                createDisplayMirrorArgs(/*id=*/id, layerStack)));
+                createDisplayMirrorArgs(/*id=*/id, layerStack, stopLayerId)));
         mLifecycleManager.addLayers(std::move(layers));
     }
 
@@ -577,6 +579,16 @@ class LayerLifecycleManagerHelper {
         mLifecycleManager.applyTransactions(transactions);
     }
 
+    void setStopLayer(uint32_t id, uint32_t stopLayerId) {
+        std::vector<QueuedTransactionState> transactions;
+        transactions.emplace_back();
+        transactions.back().states.emplace_back();
+        transactions.back().states.back().layerId = id;
+        transactions.back().states.back().state.what = layer_state_t::eStopLayerChanged;
+        transactions.back().states.back().stopLayerId = stopLayerId;
+        mLifecycleManager.applyTransactions(transactions);
+    }
+
 private:
     LayerLifecycleManager& mLifecycleManager;
 };

services/surfaceflinger/tests/unittests/LayerSnapshotTest.cpp

@@ -2189,4 +2189,138 @@ TEST_F(LayerSnapshotTest, shouldUpdatePictureProfilePriorityFromAppContentPriori
     }
 }
 
+// Test that child layers of the stop layer are hidden.
+TEST_F(LayerSnapshotTest, stopLayer_hidesChildren) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    setStopLayer(1, 122);
+
+    std::vector<uint32_t> expected = {1, 11, 111, 12, 121, 2};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
+// Test that if a layer specifies itself as a stop layer, then it is hidden.
+TEST_F(LayerSnapshotTest, stopLayer_hidesSelf) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    setStopLayer(122, 122);
+
+    std::vector<uint32_t> expected = {1, 11, 111, 12, 121, 13, 2};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
+// Test that siblings z-ordered above a stop layer are hidden.
+TEST_F(LayerSnapshotTest, stopLayer_hidesSiblings) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    setStopLayer(1, 121);
+
+    std::vector<uint32_t> expected = {1, 11, 111, 12, 2};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
+// Test that children z-ordered below the stop layer aren't hidden.
+TEST_F(LayerSnapshotTest, stopLayer_doesntHideZOrderedBelowChildren) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    setZ(121, -1);
+    setStopLayer(1, 12);
+
+    std::vector<uint32_t> expected = {1, 11, 111, 121, 2};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
+// Test that relative children are hidden by the stop layer.
+TEST_F(LayerSnapshotTest, stopLayer_hidesRelativeChild) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    reparentRelativeLayer(111, 12);
+    setStopLayer(1, 12);
+
+    std::vector<uint32_t> expected = {1, 11, 2};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
+// Test that detached children aren't hidden by the stop layer.
+TEST_F(LayerSnapshotTest, stopLayer_doesntHideDetachedChildren) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    reparentRelativeLayer(121, 11);
+    setStopLayer(1, 12);
+
+    std::vector<uint32_t> expected = {1, 11, 111, 121, 2};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
+// Test that stop layers work on hierarchies with a single root layer.
+TEST_F(LayerSnapshotTest, stopLayer_singleRoot) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    setStopLayer(1, 11);
+
+    LayerHierarchy root = mHierarchyBuilder.getPartialHierarchy(1, /*childrenOnly=*/false);
+    LayerSnapshotBuilder::Args args{.root = root,
+                                    .layerLifecycleManager = mLifecycleManager,
+                                    .includeMetadata = false,
+                                    .displays = mFrontEndDisplayInfos,
+                                    .displayChanges = false,
+                                    .globalShadowSettings = globalShadowSettings,
+                                    .supportsBlur = true,
+                                    .supportedLayerGenericMetadata = {},
+                                    .genericLayerMetadataKeyMap = {}};
+    mSnapshotBuilder.update(args);
+
+    std::vector<uint32_t> expectedVisibleLayers = {1};
+    std::vector<uint32_t> actualVisibleLayers;
+    mSnapshotBuilder.forEachVisibleSnapshot([&actualVisibleLayers](const LayerSnapshot& snapshot) {
+        actualVisibleLayers.push_back(snapshot.path.id);
+    });
+    EXPECT_EQ(expectedVisibleLayers, actualVisibleLayers);
+}
+
+// Test two stop layers where there's no interaction between the two stop layers.
+TEST_F(LayerSnapshotTest, stopLayer_multipleStopLayers_parentAfterChild) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    setStopLayer(1, 13);
+    setStopLayer(11, 111);
+
+    std::vector<uint32_t> expected = {1, 11, 12, 121, 122, 1221, 2};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
+// Test two stop layers where the hierarchy containing the second stop layer is hidden.
+TEST_F(LayerSnapshotTest, stopLayer_multipleStopLayers_childHidden) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    setStopLayer(1, 12);
+    setStopLayer(12, 122);
+
+    std::vector<uint32_t> expected = {1, 11, 111, 2};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
+// Test two stop layers where the stop layer specified lower in the hierarchy overrides
+// the stop layer specified higher in the hierarchy.
+TEST_F(LayerSnapshotTest, stopLayer_multipleStopLayers_childStopLayerOverridden) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    setStopLayer(1, 121);
+    setStopLayer(12, 122);
+
+    std::vector<uint32_t> expected = {1, 11, 111, 12, 2};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
+// Test two stop layers where the stop layer specified higher in the hierarchy applies because
+// it appears before the stop layer applied lower in the hierarchy.
+TEST_F(LayerSnapshotTest, stopLayer_multipleStopLayers_childApplied) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    setStopLayer(1, 13);
+    setStopLayer(11, 111);
+
+    std::vector<uint32_t> expected = {1, 11, 12, 121, 122, 1221, 2};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
+// Test that the stop layer works on mirrored hierarchies.
+TEST_F(LayerSnapshotTest, stopLayer_mirrorHierarchy) {
+    SET_FLAG_FOR_TEST(com::android::graphics::surfaceflinger::flags::stop_layer, true);
+    createDisplayMirrorLayer(3, ui::LayerStack::fromValue(0), 121);
+    setLayerStack(3, 1);
+
+    std::vector<uint32_t> expected = {1, 11, 111, 12, 121, 122, 1221, 13, 2, 3, 1, 11, 111, 12};
+    UPDATE_AND_VERIFY(mSnapshotBuilder, expected);
+}
+
 } // namespace android::surfaceflinger::frontend