Call libgui's SurfaceControl directly in hwui

HWUI is no longer pursuing becoming a mainline module, so this is not
needed. Moreover, dlopening ASurfaceControl symbols hits an internal
lock, which makes this code susceptible to lock contention during app
startup.

Bug: 374342597
Flag: EXEMPT refactor
Test: builds, boots
Test: gmail
Change-Id: I56ac9220dc669b8ca7c83a07268b910576aa96e5

12 files changed, 116 insertions, 176 deletions

diff --git a/libs/hwui/Android.bp b/libs/hwui/Android.bp
index a892e887bd43..ab1be7e6128d 100644
--- a/libs/hwui/Android.bp
+++ b/libs/hwui/Android.bp
@@ -139,6 +139,7 @@ cc_defaults {
                 "libandroidfw",
                 "libcrypto",
                 "libsync",
+                "libgui",
                 "libui",
                 "aconfig_text_flags_c_lib",
                 "aconfig_view_accessibility_flags_c_lib",
diff --git a/libs/hwui/WebViewFunctorManager.cpp b/libs/hwui/WebViewFunctorManager.cpp
index 9d16ee86739e..7e1eb70ca02b 100644
--- a/libs/hwui/WebViewFunctorManager.cpp
+++ b/libs/hwui/WebViewFunctorManager.cpp
@@ -16,6 +16,7 @@
 
 #include "WebViewFunctorManager.h"
 
+#include <gui/SurfaceComposerClient.h>
 #include <log/log.h>
 #include <private/hwui/WebViewFunctor.h>
 #include <utils/Trace.h>
@@ -43,7 +44,7 @@ public:
 
     static ASurfaceControl* getSurfaceControl() {
         ALOG_ASSERT(sCurrentFunctor);
-        return sCurrentFunctor->getSurfaceControl();
+        return reinterpret_cast<ASurfaceControl*>(sCurrentFunctor->getSurfaceControl());
     }
     static void mergeTransaction(ASurfaceTransaction* transaction) {
         ALOG_ASSERT(sCurrentFunctor);
@@ -129,12 +130,12 @@ bool WebViewFunctor::prepareRootSurfaceControl() {
     renderthread::CanvasContext* activeContext = renderthread::CanvasContext::getActiveContext();
     if (!activeContext) return false;
 
-    ASurfaceControl* rootSurfaceControl = activeContext->getSurfaceControl();
+    sp<SurfaceControl> rootSurfaceControl = activeContext->getSurfaceControl();
     if (!rootSurfaceControl) return false;
 
     int32_t rgid = activeContext->getSurfaceControlGenerationId();
     if (mParentSurfaceControlGenerationId != rgid) {
-        reparentSurfaceControl(rootSurfaceControl);
+        reparentSurfaceControl(reinterpret_cast<ASurfaceControl*>(rootSurfaceControl.get()));
         mParentSurfaceControlGenerationId = rgid;
     }
 
@@ -210,33 +211,35 @@ void WebViewFunctor::removeOverlays() {
     mCallbacks.removeOverlays(mFunctor, mData, currentFunctor.mergeTransaction);
     if (mSurfaceControl) {
         reparentSurfaceControl(nullptr);
-        auto funcs = renderthread::RenderThread::getInstance().getASurfaceControlFunctions();
-        funcs.releaseFunc(mSurfaceControl);
         mSurfaceControl = nullptr;
     }
 }
 
 ASurfaceControl* WebViewFunctor::getSurfaceControl() {
     ATRACE_NAME("WebViewFunctor::getSurfaceControl");
-    if (mSurfaceControl != nullptr) return mSurfaceControl;
+    if (mSurfaceControl != nullptr) {
+        return reinterpret_cast<ASurfaceControl*>(mSurfaceControl.get());
+    }
 
     renderthread::CanvasContext* activeContext = renderthread::CanvasContext::getActiveContext();
     LOG_ALWAYS_FATAL_IF(activeContext == nullptr, "Null active canvas context!");
 
-    ASurfaceControl* rootSurfaceControl = activeContext->getSurfaceControl();
+    sp<SurfaceControl> rootSurfaceControl = activeContext->getSurfaceControl();
     LOG_ALWAYS_FATAL_IF(rootSurfaceControl == nullptr, "Null root surface control!");
 
-    auto funcs = renderthread::RenderThread::getInstance().getASurfaceControlFunctions();
     mParentSurfaceControlGenerationId = activeContext->getSurfaceControlGenerationId();
-    mSurfaceControl = funcs.createFunc(rootSurfaceControl, "Webview Overlay SurfaceControl");
-    ASurfaceTransaction* transaction = funcs.transactionCreateFunc();
+
+    SurfaceComposerClient* client = rootSurfaceControl->getClient().get();
+    mSurfaceControl = client->createSurface(
+            String8("Webview Overlay SurfaceControl"), 0 /* width */, 0 /* height */,
+            // Format is only relevant for buffer queue layers.
+            PIXEL_FORMAT_UNKNOWN /* format */, ISurfaceComposerClient::eFXSurfaceBufferState,
+            rootSurfaceControl->getHandle());
+
     activeContext->prepareSurfaceControlForWebview();
-    funcs.transactionSetZOrderFunc(transaction, mSurfaceControl, -1);
-    funcs.transactionSetVisibilityFunc(transaction, mSurfaceControl,
-                                       ASURFACE_TRANSACTION_VISIBILITY_SHOW);
-    funcs.transactionApplyFunc(transaction);
-    funcs.transactionDeleteFunc(transaction);
-    return mSurfaceControl;
+    SurfaceComposerClient::Transaction transaction;
+    transaction.setLayer(mSurfaceControl, -1).show(mSurfaceControl).apply();
+    return reinterpret_cast<ASurfaceControl*>(mSurfaceControl.get());
 }
 
 void WebViewFunctor::mergeTransaction(ASurfaceTransaction* transaction) {
@@ -249,8 +252,7 @@ void WebViewFunctor::mergeTransaction(ASurfaceTransaction* transaction) {
         done = activeContext->mergeTransaction(transaction, mSurfaceControl);
     }
     if (!done) {
-        auto funcs = renderthread::RenderThread::getInstance().getASurfaceControlFunctions();
-        funcs.transactionApplyFunc(transaction);
+        reinterpret_cast<SurfaceComposerClient::Transaction*>(transaction)->apply();
     }
 }
 
@@ -258,11 +260,10 @@ void WebViewFunctor::reparentSurfaceControl(ASurfaceControl* parent) {
     ATRACE_NAME("WebViewFunctor::reparentSurfaceControl");
     if (mSurfaceControl == nullptr) return;
 
-    auto funcs = renderthread::RenderThread::getInstance().getASurfaceControlFunctions();
-    ASurfaceTransaction* transaction = funcs.transactionCreateFunc();
-    funcs.transactionReparentFunc(transaction, mSurfaceControl, parent);
-    mergeTransaction(transaction);
-    funcs.transactionDeleteFunc(transaction);
+    SurfaceComposerClient::Transaction transaction;
+    transaction.reparent(mSurfaceControl, sp<SurfaceControl>::fromExisting(
+                                                  reinterpret_cast<SurfaceControl*>(parent)));
+    mergeTransaction(reinterpret_cast<ASurfaceTransaction*>(&transaction));
 }
 
 void WebViewFunctor::reportRenderingThreads(const pid_t* thread_ids, size_t size) {
diff --git a/libs/hwui/WebViewFunctorManager.h b/libs/hwui/WebViewFunctorManager.h
index ec17640f9b5e..ac16f9138384 100644
--- a/libs/hwui/WebViewFunctorManager.h
+++ b/libs/hwui/WebViewFunctorManager.h
@@ -25,7 +25,11 @@
 #include <mutex>
 #include <vector>
 
-namespace android::uirenderer {
+namespace android {
+
+class SurfaceControl;
+
+namespace uirenderer {
 
 class WebViewFunctorManager;
 
@@ -100,7 +104,9 @@ private:
     bool mHasContext = false;
     bool mCreatedHandle = false;
     int32_t mParentSurfaceControlGenerationId = 0;
-    ASurfaceControl* mSurfaceControl = nullptr;
+#ifdef __ANDROID__
+    sp<SurfaceControl> mSurfaceControl = nullptr;
+#endif
     std::vector<pid_t> mRenderingThreads;
 };
 
@@ -126,4 +132,5 @@ private:
     std::vector<sp<WebViewFunctor::Handle>> mActiveFunctors;
 };
 
-}  // namespace android::uirenderer
+}  // namespace uirenderer
+}  // namespace android
diff --git a/libs/hwui/jni/android_graphics_HardwareRenderer.cpp b/libs/hwui/jni/android_graphics_HardwareRenderer.cpp
index cfec24b17cd4..009974b3c8de 100644
--- a/libs/hwui/jni/android_graphics_HardwareRenderer.cpp
+++ b/libs/hwui/jni/android_graphics_HardwareRenderer.cpp
@@ -53,6 +53,7 @@
 #include <src/image/SkImage_Base.h>
 #include <thread/CommonPool.h>
 #ifdef __ANDROID__
+#include <gui/SurfaceControl.h>
 #include <ui/GraphicBufferAllocator.h>
 #endif
 #include <utils/Color.h>
@@ -217,9 +218,11 @@ static void android_view_ThreadedRenderer_setSurface(JNIEnv* env, jobject clazz,
 
 static void android_view_ThreadedRenderer_setSurfaceControl(JNIEnv* env, jobject clazz,
         jlong proxyPtr, jlong surfaceControlPtr) {
+#ifdef __ANDROID__
     RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
-    ASurfaceControl* surfaceControl = reinterpret_cast<ASurfaceControl*>(surfaceControlPtr);
-    proxy->setSurfaceControl(surfaceControl);
+    SurfaceControl* surfaceControl = reinterpret_cast<SurfaceControl*>(surfaceControlPtr);
+    proxy->setSurfaceControl(sp<SurfaceControl>::fromExisting(surfaceControl));
+#endif
 }
 
 static jboolean android_view_ThreadedRenderer_pause(JNIEnv* env, jobject clazz,
@@ -684,7 +687,7 @@ static void android_view_ThreadedRenderer_setFrameCompleteCallback(JNIEnv* env,
 
 class CopyRequestAdapter : public CopyRequest {
 public:
-    CopyRequestAdapter(JavaVM* vm, jobject jCopyRequest, Rect srcRect)
+    CopyRequestAdapter(JavaVM* vm, jobject jCopyRequest, ::android::uirenderer::Rect srcRect)
             : CopyRequest(srcRect), mRefHolder(vm, jCopyRequest) {}
 
     virtual SkBitmap getDestinationBitmap(int srcWidth, int srcHeight) override {
@@ -710,8 +713,9 @@ static void android_view_ThreadedRenderer_copySurfaceInto(JNIEnv* env, jobject c
                                                           jobject jCopyRequest) {
     JavaVM* vm = nullptr;
     LOG_ALWAYS_FATAL_IF(env->GetJavaVM(&vm) != JNI_OK, "Unable to get Java VM");
-    auto copyRequest = std::make_shared<CopyRequestAdapter>(vm, env->NewGlobalRef(jCopyRequest),
-                                                            Rect(left, top, right, bottom));
+    auto copyRequest = std::make_shared<CopyRequestAdapter>(
+            vm, env->NewGlobalRef(jCopyRequest),
+            ::android::uirenderer::Rect(left, top, right, bottom));
     ANativeWindow* window = fromSurface(env, jsurface);
     RenderProxy::copySurfaceInto(window, std::move(copyRequest));
     ANativeWindow_release(window);
diff --git a/libs/hwui/platform/host/WebViewFunctorManager.cpp b/libs/hwui/platform/host/WebViewFunctorManager.cpp
index 4ba206b41b39..66646b2da2ef 100644
--- a/libs/hwui/platform/host/WebViewFunctorManager.cpp
+++ b/libs/hwui/platform/host/WebViewFunctorManager.cpp
@@ -45,7 +45,7 @@ void WebViewFunctor::destroyContext() {}
 void WebViewFunctor::removeOverlays() {}
 
 ASurfaceControl* WebViewFunctor::getSurfaceControl() {
-    return mSurfaceControl;
+    return nullptr;
 }
 
 void WebViewFunctor::mergeTransaction(ASurfaceTransaction* transaction) {}
diff --git a/libs/hwui/platform/host/renderthread/RenderThread.cpp b/libs/hwui/platform/host/renderthread/RenderThread.cpp
index f9d0f4704e08..ece45304e6d5 100644
--- a/libs/hwui/platform/host/renderthread/RenderThread.cpp
+++ b/libs/hwui/platform/host/renderthread/RenderThread.cpp
@@ -27,8 +27,6 @@ namespace renderthread {
 static bool gHasRenderThreadInstance = false;
 static JVMAttachHook gOnStartHook = nullptr;
 
-ASurfaceControlFunctions::ASurfaceControlFunctions() {}
-
 bool RenderThread::hasInstance() {
     return gHasRenderThreadInstance;
 }
diff --git a/libs/hwui/renderthread/CanvasContext.cpp b/libs/hwui/renderthread/CanvasContext.cpp
index b248c4bc9ade..d5ac99389d87 100644
--- a/libs/hwui/renderthread/CanvasContext.cpp
+++ b/libs/hwui/renderthread/CanvasContext.cpp
@@ -18,6 +18,12 @@
 
 #include <apex/window.h>
 #include <fcntl.h>
+
+#ifdef __ANDROID__
+#include <gui/ITransactionCompletedListener.h>
+#include <gui/SurfaceComposerClient.h>
+#endif
+
 #include <gui/TraceUtils.h>
 #include <strings.h>
 #include <sys/stat.h>
@@ -165,7 +171,9 @@ void CanvasContext::destroy() {
     stopDrawing();
     setHardwareBuffer(nullptr);
     setSurface(nullptr);
+#ifdef __ANDROID__
     setSurfaceControl(nullptr);
+#endif
     freePrefetchedLayers();
     destroyHardwareResources();
     mAnimationContext->destroy();
@@ -220,10 +228,15 @@ void CanvasContext::setSurface(ANativeWindow* window, bool enableTimeout) {
     setupPipelineSurface();
 }
 
-void CanvasContext::setSurfaceControl(ASurfaceControl* surfaceControl) {
-    if (surfaceControl == mSurfaceControl) return;
+#ifdef __ANDROID__
+sp<SurfaceControl> CanvasContext::getSurfaceControl() const {
+    return mSurfaceControl;
+}
+#endif
 
-    auto funcs = mRenderThread.getASurfaceControlFunctions();
+void CanvasContext::setSurfaceControl(sp<SurfaceControl> surfaceControl) {
+#ifdef __ANDROID__
+    if (surfaceControl == mSurfaceControl) return;
 
     if (surfaceControl == nullptr) {
         setASurfaceTransactionCallback(nullptr);
@@ -231,17 +244,23 @@ void CanvasContext::setSurfaceControl(ASurfaceControl* surfaceControl) {
     }
 
     if (mSurfaceControl != nullptr) {
-        funcs.unregisterListenerFunc(this, &onSurfaceStatsAvailable);
-        funcs.releaseFunc(mSurfaceControl);
+        TransactionCompletedListener::getInstance()->removeSurfaceStatsListener(
+                this, reinterpret_cast<void*>(onSurfaceStatsAvailable));
     }
-    mSurfaceControl = surfaceControl;
+
+    mSurfaceControl = std::move(surfaceControl);
     mSurfaceControlGenerationId++;
-    mExpectSurfaceStats = surfaceControl != nullptr;
+    mExpectSurfaceStats = mSurfaceControl != nullptr;
     if (mExpectSurfaceStats) {
-        funcs.acquireFunc(mSurfaceControl);
-        funcs.registerListenerFunc(surfaceControl, mSurfaceControlGenerationId, this,
-                                   &onSurfaceStatsAvailable);
+        SurfaceStatsCallback callback = [generationId = mSurfaceControlGenerationId](
+                                                void* callback_context, nsecs_t, const sp<Fence>&,
+                                                const SurfaceStats& surfaceStats) {
+            onSurfaceStatsAvailable(callback_context, generationId, surfaceStats);
+        };
+        TransactionCompletedListener::getInstance()->addSurfaceStatsListener(
+                this, reinterpret_cast<void*>(onSurfaceStatsAvailable), mSurfaceControl, callback);
     }
+#endif
 }
 
 void CanvasContext::setupPipelineSurface() {
@@ -896,17 +915,26 @@ FrameInfo* CanvasContext::getFrameInfoFromLastFew(uint64_t frameNumber, uint32_t
 }
 
 void CanvasContext::onSurfaceStatsAvailable(void* context, int32_t surfaceControlId,
-                                            ASurfaceControlStats* stats) {
+                                            const SurfaceStats& stats) {
+#ifdef __ANDROID__
     auto* instance = static_cast<CanvasContext*>(context);
 
-    const ASurfaceControlFunctions& functions =
-            instance->mRenderThread.getASurfaceControlFunctions();
+    nsecs_t gpuCompleteTime = -1L;
+    if (const auto* fence = std::get_if<sp<Fence>>(&stats.acquireTimeOrFence)) {
+        // We got a fence instead of the acquire time due to latching unsignaled.
+        // Ideally the client could just get the acquire time directly from
+        // the fence instead of calling this function which needs to block.
+        (*fence)->waitForever("acquireFence");
+        gpuCompleteTime = (*fence)->getSignalTime();
+    } else {
+        gpuCompleteTime = std::get<int64_t>(stats.acquireTimeOrFence);
+    }
 
-    nsecs_t gpuCompleteTime = functions.getAcquireTimeFunc(stats);
     if (gpuCompleteTime == Fence::SIGNAL_TIME_PENDING) {
         gpuCompleteTime = -1;
     }
-    uint64_t frameNumber = functions.getFrameNumberFunc(stats);
+
+    uint64_t frameNumber = stats.eventStats.frameNumber;
 
     FrameInfo* frameInfo = instance->getFrameInfoFromLastFew(frameNumber, surfaceControlId);
 
@@ -919,6 +947,7 @@ void CanvasContext::onSurfaceStatsAvailable(void* context, int32_t surfaceContro
         instance->mJankTracker.finishFrame(*frameInfo, instance->mFrameMetricsReporter, frameNumber,
                                            surfaceControlId);
     }
+#endif
 }
 
 // Called by choreographer to do an RT-driven animation
@@ -1140,10 +1169,11 @@ CanvasContext* CanvasContext::getActiveContext() {
     return ScopedActiveContext::getActiveContext();
 }
 
-bool CanvasContext::mergeTransaction(ASurfaceTransaction* transaction, ASurfaceControl* control) {
+bool CanvasContext::mergeTransaction(ASurfaceTransaction* transaction,
+                                     const sp<SurfaceControl>& control) {
     if (!mASurfaceTransactionCallback) return false;
     return std::invoke(mASurfaceTransactionCallback, reinterpret_cast<int64_t>(transaction),
-                       reinterpret_cast<int64_t>(control), getFrameNumber());
+                       reinterpret_cast<int64_t>(control.get()), getFrameNumber());
 }
 
 void CanvasContext::prepareSurfaceControlForWebview() {
diff --git a/libs/hwui/renderthread/CanvasContext.h b/libs/hwui/renderthread/CanvasContext.h
index 3de8e0516070..655aebada954 100644
--- a/libs/hwui/renderthread/CanvasContext.h
+++ b/libs/hwui/renderthread/CanvasContext.h
@@ -50,6 +50,9 @@
 #include "utils/RingBuffer.h"
 
 namespace android {
+
+class SurfaceStats;
+
 namespace uirenderer {
 
 class AnimationContext;
@@ -121,7 +124,9 @@ public:
      */
     GrDirectContext* getGrContext() const { return mRenderThread.getGrContext(); }
 
-    ASurfaceControl* getSurfaceControl() const { return mSurfaceControl; }
+#ifdef __ANDROID__
+    sp<SurfaceControl> getSurfaceControl() const;
+#endif
     int32_t getSurfaceControlGenerationId() const { return mSurfaceControlGenerationId; }
 
     // Won't take effect until next EGLSurface creation
@@ -129,7 +134,7 @@ public:
 
     void setHardwareBuffer(AHardwareBuffer* buffer);
     void setSurface(ANativeWindow* window, bool enableTimeout = true);
-    void setSurfaceControl(ASurfaceControl* surfaceControl);
+    void setSurfaceControl(sp<SurfaceControl> surfaceControl);
     bool pauseSurface();
     void setStopped(bool stopped);
     bool isStopped() { return mStopped || !hasOutputTarget(); }
@@ -207,7 +212,7 @@ public:
 
     // Called when SurfaceStats are available.
     static void onSurfaceStatsAvailable(void* context, int32_t surfaceControlId,
-                                        ASurfaceControlStats* stats);
+                                        const SurfaceStats& stats);
 
     void setASurfaceTransactionCallback(
             const std::function<bool(int64_t, int64_t, int64_t)>& callback) {
@@ -218,7 +223,7 @@ public:
         mBufferParams = params;
     }
 
-    bool mergeTransaction(ASurfaceTransaction* transaction, ASurfaceControl* control);
+    bool mergeTransaction(ASurfaceTransaction* transaction, const sp<SurfaceControl>& control);
 
     void setPrepareSurfaceControlForWebviewCallback(const std::function<void()>& callback) {
         mPrepareSurfaceControlForWebviewCallback = callback;
@@ -286,7 +291,9 @@ private:
     std::unique_ptr<ReliableSurface> mNativeSurface;
     // The SurfaceControl reference is passed from ViewRootImpl, can be set to
     // NULL to remove the reference
-    ASurfaceControl* mSurfaceControl = nullptr;
+#ifdef __ANDROID__
+    sp<SurfaceControl> mSurfaceControl = nullptr;
+#endif
     // id to track surface control changes and WebViewFunctor uses it to determine
     // whether reparenting is needed also used by FrameMetricsReporter to determine
     // if a frame is from an "old" surface (i.e. one that existed before the
diff --git a/libs/hwui/renderthread/RenderProxy.cpp b/libs/hwui/renderthread/RenderProxy.cpp
index ebfd8fde91f6..e4be5fa8d39e 100644
--- a/libs/hwui/renderthread/RenderProxy.cpp
+++ b/libs/hwui/renderthread/RenderProxy.cpp
@@ -21,6 +21,11 @@
 #include <SkPicture.h>
 #include <gui/TraceUtils.h>
 #include <pthread.h>
+
+#ifdef __ANDROID__
+#include <gui/SurfaceControl.h>
+#endif
+
 #include <ui/GraphicBufferAllocator.h>
 
 #include "DeferredLayerUpdater.h"
@@ -115,17 +120,12 @@ void RenderProxy::setSurface(ANativeWindow* window, bool enableTimeout) {
     });
 }
 
-void RenderProxy::setSurfaceControl(ASurfaceControl* surfaceControl) {
-    auto funcs = mRenderThread.getASurfaceControlFunctions();
-    if (surfaceControl) {
-        funcs.acquireFunc(surfaceControl);
-    }
-    mRenderThread.queue().post([this, control = surfaceControl, funcs]() mutable {
-        mContext->setSurfaceControl(control);
-        if (control) {
-            funcs.releaseFunc(control);
-        }
+void RenderProxy::setSurfaceControl(sp<SurfaceControl> surfaceControl) {
+#ifdef __ANDROID__
+    mRenderThread.queue().post([this, control = std::move(surfaceControl)]() mutable {
+        mContext->setSurfaceControl(std::move(control));
     });
+#endif
 }
 
 void RenderProxy::allocateBuffers() {
diff --git a/libs/hwui/renderthread/RenderProxy.h b/libs/hwui/renderthread/RenderProxy.h
index ad6d54bfcf91..23b3ebd4b360 100644
--- a/libs/hwui/renderthread/RenderProxy.h
+++ b/libs/hwui/renderthread/RenderProxy.h
@@ -20,7 +20,6 @@
 #include <SkRefCnt.h>
 #include <android/hardware_buffer.h>
 #include <android/native_window.h>
-#include <android/surface_control.h>
 #include <cutils/compiler.h>
 #include <utils/Functor.h>
 
@@ -39,6 +38,7 @@ class SkImage;
 
 namespace android {
 class GraphicBuffer;
+class SurfaceControl;
 class Surface;
 
 namespace uirenderer {
@@ -80,7 +80,7 @@ public:
     void setName(const char* name);
     void setHardwareBuffer(AHardwareBuffer* buffer);
     void setSurface(ANativeWindow* window, bool enableTimeout = true);
-    void setSurfaceControl(ASurfaceControl* surfaceControl);
+    void setSurfaceControl(sp<SurfaceControl> surfaceControl);
     void allocateBuffers();
     bool pause();
     void setStopped(bool stopped);
diff --git a/libs/hwui/renderthread/RenderThread.cpp b/libs/hwui/renderthread/RenderThread.cpp
index 6ab8e4e0e2ab..5e404247376f 100644
--- a/libs/hwui/renderthread/RenderThread.cpp
+++ b/libs/hwui/renderthread/RenderThread.cpp
@@ -55,66 +55,6 @@ static bool gHasRenderThreadInstance = false;
 
 static JVMAttachHook gOnStartHook = nullptr;
 
-ASurfaceControlFunctions::ASurfaceControlFunctions() {
-    void* handle_ = dlopen("libandroid.so", RTLD_NOW | RTLD_NODELETE);
-    createFunc = (ASC_create)dlsym(handle_, "ASurfaceControl_create");
-    LOG_ALWAYS_FATAL_IF(createFunc == nullptr,
-                        "Failed to find required symbol ASurfaceControl_create!");
-
-    acquireFunc = (ASC_acquire) dlsym(handle_, "ASurfaceControl_acquire");
-    LOG_ALWAYS_FATAL_IF(acquireFunc == nullptr,
-            "Failed to find required symbol ASurfaceControl_acquire!");
-
-    releaseFunc = (ASC_release) dlsym(handle_, "ASurfaceControl_release");
-    LOG_ALWAYS_FATAL_IF(releaseFunc == nullptr,
-            "Failed to find required symbol ASurfaceControl_release!");
-
-    registerListenerFunc = (ASC_registerSurfaceStatsListener) dlsym(handle_,
-            "ASurfaceControl_registerSurfaceStatsListener");
-    LOG_ALWAYS_FATAL_IF(registerListenerFunc == nullptr,
-            "Failed to find required symbol ASurfaceControl_registerSurfaceStatsListener!");
-
-    unregisterListenerFunc = (ASC_unregisterSurfaceStatsListener) dlsym(handle_,
-            "ASurfaceControl_unregisterSurfaceStatsListener");
-    LOG_ALWAYS_FATAL_IF(unregisterListenerFunc == nullptr,
-            "Failed to find required symbol ASurfaceControl_unregisterSurfaceStatsListener!");
-
-    getAcquireTimeFunc = (ASCStats_getAcquireTime) dlsym(handle_,
-            "ASurfaceControlStats_getAcquireTime");
-    LOG_ALWAYS_FATAL_IF(getAcquireTimeFunc == nullptr,
-            "Failed to find required symbol ASurfaceControlStats_getAcquireTime!");
-
-    getFrameNumberFunc = (ASCStats_getFrameNumber) dlsym(handle_,
-            "ASurfaceControlStats_getFrameNumber");
-    LOG_ALWAYS_FATAL_IF(getFrameNumberFunc == nullptr,
-            "Failed to find required symbol ASurfaceControlStats_getFrameNumber!");
-
-    transactionCreateFunc = (AST_create)dlsym(handle_, "ASurfaceTransaction_create");
-    LOG_ALWAYS_FATAL_IF(transactionCreateFunc == nullptr,
-                        "Failed to find required symbol ASurfaceTransaction_create!");
-
-    transactionDeleteFunc = (AST_delete)dlsym(handle_, "ASurfaceTransaction_delete");
-    LOG_ALWAYS_FATAL_IF(transactionDeleteFunc == nullptr,
-                        "Failed to find required symbol ASurfaceTransaction_delete!");
-
-    transactionApplyFunc = (AST_apply)dlsym(handle_, "ASurfaceTransaction_apply");
-    LOG_ALWAYS_FATAL_IF(transactionApplyFunc == nullptr,
-                        "Failed to find required symbol ASurfaceTransaction_apply!");
-
-    transactionReparentFunc = (AST_reparent)dlsym(handle_, "ASurfaceTransaction_reparent");
-    LOG_ALWAYS_FATAL_IF(transactionReparentFunc == nullptr,
-                        "Failed to find required symbol transactionReparentFunc!");
-
-    transactionSetVisibilityFunc =
-            (AST_setVisibility)dlsym(handle_, "ASurfaceTransaction_setVisibility");
-    LOG_ALWAYS_FATAL_IF(transactionSetVisibilityFunc == nullptr,
-                        "Failed to find required symbol ASurfaceTransaction_setVisibility!");
-
-    transactionSetZOrderFunc = (AST_setZOrder)dlsym(handle_, "ASurfaceTransaction_setZOrder");
-    LOG_ALWAYS_FATAL_IF(transactionSetZOrderFunc == nullptr,
-                        "Failed to find required symbol ASurfaceTransaction_setZOrder!");
-}
-
 void RenderThread::extendedFrameCallback(const AChoreographerFrameCallbackData* cbData,
                                          void* data) {
     RenderThread* rt = reinterpret_cast<RenderThread*>(data);
diff --git a/libs/hwui/renderthread/RenderThread.h b/libs/hwui/renderthread/RenderThread.h
index 86fddbae0831..f733c7c58ef3 100644
--- a/libs/hwui/renderthread/RenderThread.h
+++ b/libs/hwui/renderthread/RenderThread.h
@@ -77,49 +77,6 @@ struct VsyncSource {
     virtual ~VsyncSource() {}
 };
 
-typedef ASurfaceControl* (*ASC_create)(ASurfaceControl* parent, const char* debug_name);
-typedef void (*ASC_acquire)(ASurfaceControl* control);
-typedef void (*ASC_release)(ASurfaceControl* control);
-
-typedef void (*ASC_registerSurfaceStatsListener)(ASurfaceControl* control, int32_t id,
-                                                 void* context,
-                                                 ASurfaceControl_SurfaceStatsListener func);
-typedef void (*ASC_unregisterSurfaceStatsListener)(void* context,
-                                                   ASurfaceControl_SurfaceStatsListener func);
-
-typedef int64_t (*ASCStats_getAcquireTime)(ASurfaceControlStats* stats);
-typedef uint64_t (*ASCStats_getFrameNumber)(ASurfaceControlStats* stats);
-
-typedef ASurfaceTransaction* (*AST_create)();
-typedef void (*AST_delete)(ASurfaceTransaction* transaction);
-typedef void (*AST_apply)(ASurfaceTransaction* transaction);
-typedef void (*AST_reparent)(ASurfaceTransaction* aSurfaceTransaction,
-                             ASurfaceControl* aSurfaceControl,
-                             ASurfaceControl* newParentASurfaceControl);
-typedef void (*AST_setVisibility)(ASurfaceTransaction* transaction,
-                                  ASurfaceControl* surface_control, int8_t visibility);
-typedef void (*AST_setZOrder)(ASurfaceTransaction* transaction, ASurfaceControl* surface_control,
-                              int32_t z_order);
-
-struct ASurfaceControlFunctions {
-    ASurfaceControlFunctions();
-
-    ASC_create createFunc;
-    ASC_acquire acquireFunc;
-    ASC_release releaseFunc;
-    ASC_registerSurfaceStatsListener registerListenerFunc;
-    ASC_unregisterSurfaceStatsListener unregisterListenerFunc;
-    ASCStats_getAcquireTime getAcquireTimeFunc;
-    ASCStats_getFrameNumber getFrameNumberFunc;
-
-    AST_create transactionCreateFunc;
-    AST_delete transactionDeleteFunc;
-    AST_apply transactionApplyFunc;
-    AST_reparent transactionReparentFunc;
-    AST_setVisibility transactionSetVisibilityFunc;
-    AST_setZOrder transactionSetZOrderFunc;
-};
-
 class ChoreographerSource;
 class DummyVsyncSource;
 
@@ -166,10 +123,6 @@ public:
 
     void preload();
 
-    const ASurfaceControlFunctions& getASurfaceControlFunctions() {
-        return mASurfaceControlFunctions;
-    }
-
     void trimMemory(TrimLevel level);
     void trimCaches(CacheTrimLevel level);
 
@@ -244,7 +197,6 @@ private:
     CacheManager* mCacheManager;
     sp<VulkanManager> mVkManager;
 
-    ASurfaceControlFunctions mASurfaceControlFunctions;
     std::mutex mJankDataMutex;
 };