Merge "end2end: Implement a fake IComposerClient [4/N]" into main

Author: Treehugger Robot

services/surfaceflinger/tests/end2end/Android.bp

@@ -32,11 +32,10 @@ cc_test {
     ],
     srcs: [
         "main.cpp",
-
         "test_framework/core/EdidBuilder.cpp",
         "test_framework/core/TestService.cpp",
-        "test_framework/fake_hwc3/Hwc3Composer.cpp",
-        "test_framework/fake_hwc3/Hwc3Controller.cpp",
+        "test_framework/hwc3/FakeComposer.cpp",
+        "test_framework/hwc3/Hwc3Controller.cpp",
         "test_framework/surfaceflinger/SFController.cpp",
 
         // Internal tests

services/surfaceflinger/tests/end2end/test_framework/core/GuardedSharedState.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <type_traits>
+
+namespace android::surfaceflinger::tests::end2end::test_framework::core {
+
+// Ensures all access to a state structure `SharedState` is done while holding an appropriate
+// `std::shared_mutex` lock.
+//
+// This works around limitations with Clang thread safety analysis when using `std::shared_lock`, as
+// there will be a compiler diagnostic despite acquiring the lock.
+template <typename SharedState>
+class GuardedSharedState final {
+  public:
+    // Allows shared read-only access to the state. The lambda is invoked with a `const
+    // SharedState&` first argument referencing the state.
+    template <typename F>
+    auto withSharedLock(F&& continuation) const -> std::invoke_result_t<F, const SharedState&> {
+        const std::shared_lock lock(mMutex);
+        return std::invoke(std::forward<F>(continuation), mState);
+    }
+
+    // Allows exclusive read/write access to the state. The lambda is invoked with a `SharedState&`
+    // first argument referencing the state.
+    template <typename F>
+    auto withExclusiveLock(F&& continuation) -> std::invoke_result_t<F, SharedState&> {
+        const std::lock_guard lock(mMutex);
+        return std::invoke(std::forward<F>(continuation), mState);
+    }
+
+  private:
+    mutable std::shared_mutex mMutex;
+    SharedState mState;
+};
+
+}  // namespace android::surfaceflinger::tests::end2end::test_framework::core

services/surfaceflinger/tests/end2end/test_framework/core/TestService.cpp

@@ -25,7 +25,7 @@
 
 #include "test_framework/core/DisplayConfiguration.h"
 #include "test_framework/core/TestService.h"
-#include "test_framework/fake_hwc3/Hwc3Controller.h"
+#include "test_framework/hwc3/Hwc3Controller.h"
 #include "test_framework/surfaceflinger/SFController.h"
 
 namespace android::surfaceflinger::tests::end2end::test_framework::core {
@@ -56,7 +56,7 @@ auto TestService::init(std::span<const DisplayConfiguration> displays)
         -> base::expected<void, std::string> {
     using namespace std::string_literals;
 
-    auto hwcResult = fake_hwc3::Hwc3Controller::make(displays);
+    auto hwcResult = hwc3::Hwc3Controller::make(displays);
     if (!hwcResult) {
         return base::unexpected(std::move(hwcResult).error());
     }
@@ -68,7 +68,7 @@ auto TestService::init(std::span<const DisplayConfiguration> displays)
     }
     auto flinger = *std::move(flingerResult);
 
-    surfaceflinger::SFController::useHwcService(fake_hwc3::Hwc3Controller::getServiceName());
+    surfaceflinger::SFController::useHwcService(hwc3::Hwc3Controller::getServiceName());
 
     if (auto result = flinger->startAndConnect(); !result) {
         return base::unexpected(std::move(result).error());

services/surfaceflinger/tests/end2end/test_framework/core/TestService.h

@@ -34,11 +34,11 @@ class SFController;
 
 }  // namespace surfaceflinger
 
-namespace fake_hwc3 {
+namespace hwc3 {
 
 class Hwc3Controller;
 
-}  // namespace fake_hwc3
+}  // namespace hwc3
 
 namespace core {
 
@@ -53,7 +53,7 @@ class TestService final {
     explicit TestService(Passkey passkey);
 
     // Obtains the HWC3 back-end controller
-    [[nodiscard]] auto hwc() -> fake_hwc3::Hwc3Controller& {
+    [[nodiscard]] auto hwc() -> hwc3::Hwc3Controller& {
         CHECK(mHwc);
         return *mHwc;
     }
@@ -68,7 +68,7 @@ class TestService final {
     [[nodiscard]] auto init(std::span<const DisplayConfiguration> displays)
             -> base::expected<void, std::string>;
 
-    std::shared_ptr<fake_hwc3::Hwc3Controller> mHwc;
+    std::shared_ptr<hwc3::Hwc3Controller> mHwc;
     std::shared_ptr<surfaceflinger::SFController> mFlinger;
 };