Revert "Use std::unique_ptr instead of ScopeGuard"

Revert submission 2780893

Reason for revert: breaking boot tests

Bug: 308214260

Reverted changes: /q/submissionid:2780893

Change-Id: I7a4ee9a45583a8a1d4a33447de55c63e6ce9d42a

10 files changed, 21 insertions, 88 deletions

diff --git a/libs/binder/FdTrigger.cpp b/libs/binder/FdTrigger.cpp
index 49a0cee7b6..8ee6cb0615 100644
--- a/libs/binder/FdTrigger.cpp
+++ b/libs/binder/FdTrigger.cpp
@@ -22,13 +22,11 @@
 #include <poll.h>
 
 #include <android-base/macros.h>
-#include <binder/Functional.h>
+#include <android-base/scopeguard.h>
 
 #include "RpcState.h"
 namespace android {
 
-using namespace android::binder::impl;
-
 std::unique_ptr<FdTrigger> FdTrigger::make() {
     auto ret = std::make_unique<FdTrigger>();
 #ifndef BINDER_RPC_SINGLE_THREADED
@@ -76,7 +74,8 @@ status_t FdTrigger::triggerablePoll(const android::RpcTransportFd& transportFd,
                         "Only one thread should be polling on Fd!");
 
     transportFd.setPollingState(true);
-    auto pollingStateGuard = make_scope_guard([&]() { transportFd.setPollingState(false); });
+    auto pollingStateGuard =
+            android::base::make_scope_guard([&]() { transportFd.setPollingState(false); });
 
     int ret = TEMP_FAILURE_RETRY(poll(pfd, arraysize(pfd), -1));
     if (ret < 0) {
diff --git a/libs/binder/Parcel.cpp b/libs/binder/Parcel.cpp
index 0ff29b53ce..17bdc455be 100644
--- a/libs/binder/Parcel.cpp
+++ b/libs/binder/Parcel.cpp
@@ -32,7 +32,6 @@
 
 #include <binder/Binder.h>
 #include <binder/BpBinder.h>
-#include <binder/Functional.h>
 #include <binder/IPCThreadState.h>
 #include <binder/Parcel.h>
 #include <binder/ProcessState.h>
@@ -40,6 +39,7 @@
 #include <binder/Status.h>
 #include <binder/TextOutput.h>
 
+#include <android-base/scopeguard.h>
 #ifndef BINDER_DISABLE_BLOB
 #include <cutils/ashmem.h>
 #endif
@@ -94,8 +94,6 @@ static size_t pad_size(size_t s) {
 
 namespace android {
 
-using namespace android::binder::impl;
-
 // many things compile this into prebuilts on the stack
 #ifdef __LP64__
 static_assert(sizeof(Parcel) == 120);
@@ -588,7 +586,7 @@ status_t Parcel::appendFrom(const Parcel* parcel, size_t offset, size_t len) {
         }
 
         const size_t savedDataPos = mDataPos;
-        auto scopeGuard = make_scope_guard([&]() { mDataPos = savedDataPos; });
+        base::ScopeGuard scopeGuard = [&]() { mDataPos = savedDataPos; };
 
         rpcFields->mObjectPositions.reserve(otherRpcFields->mObjectPositions.size());
         if (otherRpcFields->mFds != nullptr) {
diff --git a/libs/binder/ProcessState.cpp b/libs/binder/ProcessState.cpp
index ff8aa83070..8ec4af9945 100644
--- a/libs/binder/ProcessState.cpp
+++ b/libs/binder/ProcessState.cpp
@@ -19,9 +19,9 @@
 #include <binder/ProcessState.h>
 
 #include <android-base/result.h>
+#include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 #include <binder/BpBinder.h>
-#include <binder/Functional.h>
 #include <binder/IPCThreadState.h>
 #include <binder/IServiceManager.h>
 #include <binder/Stability.h>
@@ -60,8 +60,6 @@ const char* kDefaultDriver = "/dev/binder";
 
 namespace android {
 
-using namespace android::binder::impl;
-
 class PoolThread : public Thread
 {
 public:
@@ -432,7 +430,7 @@ status_t ProcessState::setThreadPoolMaxThreadCount(size_t maxThreads) {
 
 size_t ProcessState::getThreadPoolMaxTotalThreadCount() const {
     pthread_mutex_lock(&mThreadCountLock);
-    auto detachGuard = make_scope_guard([&]() { pthread_mutex_unlock(&mThreadCountLock); });
+    base::ScopeGuard detachGuard = [&]() { pthread_mutex_unlock(&mThreadCountLock); };
 
     if (mThreadPoolStarted) {
         LOG_ALWAYS_FATAL_IF(mKernelStartedThreads > mMaxThreads + 1,
diff --git a/libs/binder/RecordedTransaction.cpp b/libs/binder/RecordedTransaction.cpp
index cedd3af289..324670633f 100644
--- a/libs/binder/RecordedTransaction.cpp
+++ b/libs/binder/RecordedTransaction.cpp
@@ -16,13 +16,12 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/scopeguard.h>
 #include <android-base/unique_fd.h>
-#include <binder/Functional.h>
 #include <binder/RecordedTransaction.h>
 #include <sys/mman.h>
 #include <algorithm>
 
-using namespace android::binder::impl;
 using android::Parcel;
 using android::base::borrowed_fd;
 using android::base::unique_fd;
@@ -219,7 +218,7 @@ std::optional<RecordedTransaction> RecordedTransaction::fromFile(const unique_fd
         size_t memoryMappedSize = chunkPayloadSize + mmapPayloadStartOffset;
         void* mappedMemory =
                 mmap(NULL, memoryMappedSize, PROT_READ, MAP_SHARED, fd.get(), mmapPageAlignedStart);
-        auto mmap_guard = make_scope_guard(
+        auto mmap_guard = android::base::make_scope_guard(
                 [mappedMemory, memoryMappedSize] { munmap(mappedMemory, memoryMappedSize); });
 
         transaction_checksum_t* payloadMap =
diff --git a/libs/binder/RpcServer.cpp b/libs/binder/RpcServer.cpp
index ffdcb15ba8..07ab093992 100644
--- a/libs/binder/RpcServer.cpp
+++ b/libs/binder/RpcServer.cpp
@@ -25,7 +25,7 @@
 #include <thread>
 #include <vector>
 
-#include <binder/Functional.h>
+#include <android-base/scopeguard.h>
 #include <binder/Parcel.h>
 #include <binder/RpcServer.h>
 #include <binder/RpcTransportRaw.h>
@@ -45,7 +45,7 @@ namespace android {
 
 constexpr size_t kSessionIdBytes = 32;
 
-using namespace android::binder::impl;
+using base::ScopeGuard;
 using base::unique_fd;
 
 RpcServer::RpcServer(std::unique_ptr<RpcTransportCtx> ctx) : mCtx(std::move(ctx)) {}
@@ -458,12 +458,11 @@ void RpcServer::establishConnection(
         LOG_ALWAYS_FATAL_IF(threadId == server->mConnectingThreads.end(),
                             "Must establish connection on owned thread");
         thisThread = std::move(threadId->second);
-        auto detachGuardLambda = [&]() {
+        ScopeGuard detachGuard = [&]() {
             thisThread.detach();
             _l.unlock();
             server->mShutdownCv.notify_all();
         };
-        auto detachGuard = make_scope_guard(std::ref(detachGuardLambda));
         server->mConnectingThreads.erase(threadId);
 
         if (status != OK || server->mShutdownTrigger->isTriggered()) {
@@ -549,7 +548,7 @@ void RpcServer::establishConnection(
             return;
         }
 
-        detachGuard.release();
+        detachGuard.Disable();
         session->preJoinThreadOwnership(std::move(thisThread));
     }
 
diff --git a/libs/binder/RpcSession.cpp b/libs/binder/RpcSession.cpp
index 524b54c31c..fa8f2b51ac 100644
--- a/libs/binder/RpcSession.cpp
+++ b/libs/binder/RpcSession.cpp
@@ -27,8 +27,8 @@
 #include <string_view>
 
 #include <android-base/macros.h>
+#include <android-base/scopeguard.h>
 #include <binder/BpBinder.h>
-#include <binder/Functional.h>
 #include <binder/Parcel.h>
 #include <binder/RpcServer.h>
 #include <binder/RpcTransportRaw.h>
@@ -52,7 +52,6 @@ extern "C" JavaVM* AndroidRuntimeGetJavaVM();
 
 namespace android {
 
-using namespace android::binder::impl;
 using base::unique_fd;
 
 RpcSession::RpcSession(std::unique_ptr<RpcTransportCtx> ctx) : mCtx(std::move(ctx)) {
@@ -498,7 +497,7 @@ status_t RpcSession::setupClient(const std::function<status_t(const std::vector<
     if (auto status = initShutdownTrigger(); status != OK) return status;
 
     auto oldProtocolVersion = mProtocolVersion;
-    auto cleanup = make_scope_guard([&] {
+    auto cleanup = base::ScopeGuard([&] {
         // if any threads are started, shut them down
         (void)shutdownAndWait(true);
 
@@ -578,7 +577,7 @@ status_t RpcSession::setupClient(const std::function<status_t(const std::vector<
         if (status_t status = connectAndInit(mId, true /*incoming*/); status != OK) return status;
     }
 
-    cleanup.release();
+    cleanup.Disable();
 
     return OK;
 }
diff --git a/libs/binder/RpcState.cpp b/libs/binder/RpcState.cpp
index aa26b91274..26a2f4fa39 100644
--- a/libs/binder/RpcState.cpp
+++ b/libs/binder/RpcState.cpp
@@ -19,8 +19,8 @@
 #include "RpcState.h"
 
 #include <android-base/macros.h>
+#include <android-base/scopeguard.h>
 #include <binder/BpBinder.h>
-#include <binder/Functional.h>
 #include <binder/IPCThreadState.h>
 #include <binder/RpcServer.h>
 
@@ -39,8 +39,6 @@
 
 namespace android {
 
-using namespace android::binder::impl;
-
 #if RPC_FLAKE_PRONE
 void rpcMaybeWaitToFlake() {
     [[clang::no_destroy]] static std::random_device r;
@@ -813,11 +811,11 @@ status_t RpcState::processCommand(
         origGuard = kernelBinderState->pushGetCallingSpGuard(&spGuard);
     }
 
-    auto guardUnguard = make_scope_guard([&]() {
+    base::ScopeGuard guardUnguard = [&]() {
         if (kernelBinderState != nullptr) {
             kernelBinderState->restoreGetCallingSpGuard(origGuard);
         }
-    });
+    };
 #endif // BINDER_WITH_KERNEL_IPC
 
     switch (command.command) {
diff --git a/libs/binder/include/binder/Functional.h b/libs/binder/include/binder/Functional.h
deleted file mode 100644
index 058f8339c9..0000000000
--- a/libs/binder/include/binder/Functional.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2023 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 <memory>
-
-namespace android::binder::impl {
-
-template <typename F>
-constexpr void assert_small_callable() {
-    // While this buffer (std::function::__func::__buf_) is an implementation detail generally not
-    // accessible to users, it's a good bet to assume its size to be around 3 pointers.
-    constexpr size_t kFunctionBufferSize = 3 * sizeof(void*);
-
-    static_assert(sizeof(F) <= kFunctionBufferSize,
-                  "Supplied callable is larger than std::function optimization buffer. "
-                  "Try using std::ref, but make sure lambda lives long enough to be called.");
-}
-
-template <typename F>
-std::unique_ptr<void, std::function<void(void*)>> make_scope_guard(F&& f) {
-    assert_small_callable<decltype(std::bind(f))>();
-    return {reinterpret_cast<void*>(true), std::bind(f)};
-}
-
-} // namespace android::binder::impl
diff --git a/libs/binder/tests/binderAllocationLimits.cpp b/libs/binder/tests/binderAllocationLimits.cpp
index 7e0b59463a..6712c9cece 100644
--- a/libs/binder/tests/binderAllocationLimits.cpp
+++ b/libs/binder/tests/binderAllocationLimits.cpp
@@ -16,7 +16,6 @@
 
 #include <android-base/logging.h>
 #include <binder/Binder.h>
-#include <binder/Functional.h>
 #include <binder/IServiceManager.h>
 #include <binder/Parcel.h>
 #include <binder/RpcServer.h>
@@ -29,8 +28,6 @@
 #include <functional>
 #include <vector>
 
-using namespace android::binder::impl;
-
 static android::String8 gEmpty(""); // make sure first allocation from optimization runs
 
 struct DestructionAction {
@@ -175,18 +172,6 @@ TEST(BinderAllocation, PingTransaction) {
     a_binder->pingBinder();
 }
 
-TEST(BinderAllocation, MakeScopeGuard) {
-    const auto m = ScopeDisallowMalloc();
-    {
-        auto guard1 = make_scope_guard([] {});
-        guard1.release();
-
-        auto guard2 = make_scope_guard([&guard1, ptr = imaginary_use] {
-            if (ptr == nullptr) guard1.release();
-        });
-    }
-}
-
 TEST(BinderAllocation, InterfaceDescriptorTransaction) {
     sp<IBinder> a_binder = GetRemoteBinder();
 
diff --git a/libs/binder/tests/binderLibTest.cpp b/libs/binder/tests/binderLibTest.cpp
index eaf426d5a7..341e9ce5ec 100644
--- a/libs/binder/tests/binderLibTest.cpp
+++ b/libs/binder/tests/binderLibTest.cpp
@@ -30,11 +30,11 @@
 #include <android-base/properties.h>
 #include <android-base/result-gmock.h>
 #include <android-base/result.h>
+#include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <binder/Binder.h>
 #include <binder/BpBinder.h>
-#include <binder/Functional.h>
 #include <binder/IBinder.h>
 #include <binder/IPCThreadState.h>
 #include <binder/IServiceManager.h>
@@ -52,7 +52,6 @@
 #define ARRAY_SIZE(array) (sizeof array / sizeof array[0])
 
 using namespace android;
-using namespace android::binder::impl;
 using namespace std::string_literals;
 using namespace std::chrono_literals;
 using android::base::testing::HasValue;
@@ -1326,7 +1325,7 @@ TEST_F(BinderLibTest, TooManyFdsFlattenable) {
     ASSERT_EQ(0, ret);
 
     // Restore the original file limits when the test finishes
-    auto guardUnguard = make_scope_guard([&]() { setrlimit(RLIMIT_NOFILE, &origNofile); });
+    base::ScopeGuard guardUnguard([&]() { setrlimit(RLIMIT_NOFILE, &origNofile); });
 
     rlimit testNofile = {1024, 1024};
     ret = setrlimit(RLIMIT_NOFILE, &testNofile);