diff --git a/Android.bp b/Android.bp
index a4ce1a4..b67833a 100644
--- a/Android.bp
+++ b/Android.bp
@@ -123,7 +123,6 @@
         "-DUSING_ANDROID_BP",
         "-D_FILE_OFFSET_BITS=64",
         "-DVK_GFXSTREAM_STRUCTURE_TYPE_EXT",
-        "-DGFXSTREAM_ENABLE_HOST_GLES=1",
         "-Wno-unreachable-code-loop-increment",
         "-Wno-unused-parameter",
         "-Wno-unused-function",
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6a29a17..b23070c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -41,8 +41,6 @@
 if(VIRGL_RENDERER_UNSTABLE_APIS)
     add_definitions(-DVIRGL_RENDERER_UNSTABLE_APIS)
 endif()
-    
-add_definitions(-DGFXSTREAM_ENABLE_HOST_GLES=1)
 
 option(ASTC_CPU_DECODING "Enable decoding ASTC textures on the CPU" OFF)
 
diff --git a/host/Buffer.cpp b/host/Buffer.cpp
index b60a1ec..1858924 100644
--- a/host/Buffer.cpp
+++ b/host/Buffer.cpp
@@ -14,10 +14,7 @@
 
 #include "Buffer.h"
 
-#if GFXSTREAM_ENABLE_HOST_GLES
 #include "gl/EmulationGl.h"
-#endif
-
 #include "vulkan/BufferVk.h"
 #include "vulkan/VkCommonOperations.h"
 
@@ -34,7 +31,6 @@
                                        uint64_t size, HandleType handle) {
     std::shared_ptr<Buffer> buffer(new Buffer(handle, size));
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (emulationGl) {
         buffer->mBufferGl = emulationGl->createBuffer(size, handle);
         if (!buffer->mBufferGl) {
@@ -42,7 +38,6 @@
             return nullptr;
         }
     }
-#endif
 
     if (emulationVk && emulationVk->live) {
         const bool vulkanOnly = emulationGl == nullptr;
@@ -54,11 +49,10 @@
         }
 
         if (!vulkanOnly) {
-#if GFXSTREAM_ENABLE_HOST_GLES
             if (!buffer->mBufferGl) {
                 GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Missing BufferGl?";
             }
-#endif
+
             // TODO: external memory sharing.
         }
     }
@@ -74,7 +68,6 @@
 
     std::shared_ptr<Buffer> buffer(new Buffer(handle, size));
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (emulationGl) {
         buffer->mBufferGl = emulationGl->loadBuffer(stream);
         if (!buffer->mBufferGl) {
@@ -82,7 +75,6 @@
             return nullptr;
         }
     }
-#endif
 
     buffer->mNeedRestore = true;
 
@@ -93,11 +85,9 @@
     stream->putBe32(mHandle);
     stream->putBe64(mSize);
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mBufferGl) {
         mBufferGl->onSave(stream);
     }
-#endif
 }
 
 void Buffer::restore() {}
@@ -105,13 +95,10 @@
 void Buffer::readToBytes(uint64_t offset, uint64_t size, void* outBytes) {
     touch();
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mBufferGl) {
         mBufferGl->read(offset, size, outBytes);
         return;
     }
-#endif
-
     if (mBufferVk) {
         mBufferVk->readToBytes(offset, size, outBytes);
         return;
@@ -123,13 +110,10 @@
 bool Buffer::updateFromBytes(uint64_t offset, uint64_t size, const void* bytes) {
     touch();
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mBufferGl) {
         mBufferGl->subUpdate(offset, size, bytes);
         return true;
     }
-#endif
-
     if (mBufferVk) {
         return mBufferVk->updateFromBytes(offset, size, bytes);
     }
diff --git a/host/Buffer.h b/host/Buffer.h
index 414ff05..5db0db3 100644
--- a/host/Buffer.h
+++ b/host/Buffer.h
@@ -18,11 +18,8 @@
 
 #include "Handle.h"
 #include "aemu/base/files/Stream.h"
-#include "snapshot/LazySnapshotObj.h"
-
-#if GFXSTREAM_ENABLE_HOST_GLES
 #include "gl/BufferGl.h"
-#endif
+#include "snapshot/LazySnapshotObj.h"
 
 namespace gfxstream {
 namespace gl {
@@ -64,10 +61,8 @@
     const uint64_t mSize;
     const HandleType mHandle;
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     // If GL emulation is enabled.
     std::unique_ptr<gl::BufferGl> mBufferGl;
-#endif
 
     // If Vk emulation is enabled.
     std::unique_ptr<vk::BufferVk> mBufferVk;
diff --git a/host/ColorBuffer.cpp b/host/ColorBuffer.cpp
index 3cdecbf..6a8f58d 100644
--- a/host/ColorBuffer.cpp
+++ b/host/ColorBuffer.cpp
@@ -14,10 +14,7 @@
 
 #include "ColorBuffer.h"
 
-#if GFXSTREAM_ENABLE_HOST_GLES
 #include "gl/EmulationGl.h"
-#endif
-
 #include "host-common/GfxstreamFatalError.h"
 #include "host-common/logging.h"
 #include "vulkan/ColorBufferVk.h"
@@ -58,7 +55,6 @@
     std::shared_ptr<ColorBuffer> colorBuffer(
         new ColorBuffer(handle, width, height, format, frameworkFormat));
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (emulationGl) {
         colorBuffer->mColorBufferGl =
             emulationGl->createColorBuffer(width, height, format, frameworkFormat, handle);
@@ -67,7 +63,6 @@
             return nullptr;
         }
     }
-#endif
 
     if (emulationVk && emulationVk->live) {
         const bool vulkanOnly = colorBuffer->mColorBufferGl == nullptr;
@@ -86,7 +81,6 @@
         }
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     bool b271028352Workaround = emulationGl && strstr(emulationGl->getGlesRenderer().c_str(), "Intel");
 
     if (colorBuffer->mColorBufferGl && colorBuffer->mColorBufferVk &&
@@ -103,7 +97,6 @@
             }
         }
     }
-#endif
 
     return colorBuffer;
 }
@@ -120,7 +113,6 @@
     std::shared_ptr<ColorBuffer> colorBuffer(
         new ColorBuffer(handle, width, height, format, frameworkFormat));
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (emulationGl) {
         colorBuffer->mColorBufferGl = emulationGl->loadColorBuffer(stream);
         if (!colorBuffer->mColorBufferGl) {
@@ -128,7 +120,6 @@
             return nullptr;
         }
     }
-#endif
 
     colorBuffer->mNeedRestore = true;
 
@@ -142,32 +133,25 @@
     stream->putBe32(static_cast<uint32_t>(mFormat));
     stream->putBe32(static_cast<uint32_t>(mFrameworkFormat));
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mColorBufferGl) {
         mColorBufferGl->onSave(stream);
     }
-#endif
 }
 
 void ColorBuffer::restore() {
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mColorBufferGl) {
         mColorBufferGl->restore();
     }
-#endif
 }
 
 void ColorBuffer::readToBytes(int x, int y, int width, int height, GLenum pixelsFormat,
                               GLenum pixelsType, void* outPixels) {
     touch();
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mColorBufferGl) {
         mColorBufferGl->readPixels(x, y, width, height, pixelsFormat, pixelsType, outPixels);
         return;
     }
-#endif
-
     if (mColorBufferVk) {
         mColorBufferVk->readToBytes(x, y, width, height, outPixels);
         return;
@@ -181,13 +165,11 @@
                                     void* outPixels) {
     touch();
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mColorBufferGl) {
         mColorBufferGl->readPixelsScaled(pixelsWidth, pixelsHeight, pixelsFormat, pixelsType,
                                          pixelsRotation, rect, outPixels);
         return;
     }
-#endif
 
     GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Unimplemented.";
 }
@@ -196,13 +178,10 @@
                                  uint32_t pixelsSize) {
     touch();
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mColorBufferGl) {
         mColorBufferGl->readPixelsYUVCached(x, y, width, height, outPixels, pixelsSize);
         return;
     }
-#endif
-
     if (mColorBufferVk) {
         mColorBufferVk->readToBytes(x, y, width, height, outPixels);
         return;
@@ -216,14 +195,11 @@
                                   GLenum pixelsType, const void* pixels, void* metadata) {
     touch();
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mColorBufferGl) {
         mColorBufferGl->subUpdateFromFrameworkFormat(x, y, width, height, frameworkFormat,
                                                      pixelsFormat, pixelsType, pixels, metadata);
         return true;
     }
-#endif
-
     if (mColorBufferVk) {
         return mColorBufferVk->updateFromBytes(x, y, width, height, pixels);
     }
@@ -236,12 +212,9 @@
                                   GLenum pixelsType, const void* pixels) {
     touch();
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mColorBufferGl) {
         return mColorBufferGl->subUpdate(x, y, width, height, pixelsFormat, pixelsType, pixels);
     }
-#endif
-
     if (mColorBufferVk) {
         return mColorBufferVk->updateFromBytes(x, y, width, height, pixels);
     }
@@ -251,13 +224,11 @@
 }
 
 bool ColorBuffer::updateGlFromBytes(const void* bytes, std::size_t bytesSize) {
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mColorBufferGl) {
         touch();
 
         return mColorBufferGl->replaceContents(bytes, bytesSize);
     }
-#endif
 
     return true;
 }
@@ -265,12 +236,10 @@
 std::unique_ptr<BorrowedImageInfo> ColorBuffer::borrowForComposition(UsedApi api, bool isTarget) {
     switch (api) {
         case UsedApi::kGl: {
-#if GFXSTREAM_ENABLE_HOST_GLES
             if (!mColorBufferGl) {
                 GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "ColorBufferGl not available.";
             }
             return mColorBufferGl->getBorrowedImageInfo();
-#endif
         }
         case UsedApi::kVk: {
             if (!mColorBufferVk) {
@@ -286,12 +255,10 @@
 std::unique_ptr<BorrowedImageInfo> ColorBuffer::borrowForDisplay(UsedApi api) {
     switch (api) {
         case UsedApi::kGl: {
-#if GFXSTREAM_ENABLE_HOST_GLES
             if (!mColorBufferGl) {
                 GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "ColorBufferGl not available.";
             }
             return mColorBufferGl->getBorrowedImageInfo();
-#endif
         }
         case UsedApi::kVk: {
             if (!mColorBufferVk) {
@@ -326,6 +293,7 @@
     if (mGlAndVkAreSharingExternalMemory) {
         return true;
     }
+
     std::vector<uint8_t> contents;
     if (!vk::readColorBufferToBytes(mHandle, &contents)) {
         ERR("Failed to get VK contents for ColorBuffer:%d", mHandle);
@@ -336,12 +304,10 @@
         return false;
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (!mColorBufferGl->replaceContents(contents.data(), contents.size())) {
         ERR("Failed to set GL contents for ColorBuffer:%d", mHandle);
         return false;
     }
-#endif
 
     return true;
 }
@@ -355,14 +321,12 @@
         return true;
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (mColorBufferGl) {
         if (!mColorBufferGl->replaceContents(bytes, bytesSize)) {
             ERR("Failed to update ColorBuffer:%d GL backing from VK bytes.", mHandle);
             return false;
         }
     }
-#endif
 
     return true;
 }
@@ -390,7 +354,6 @@
         return true;
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     std::size_t contentsSize = 0;
     if (!mColorBufferGl->readContents(&contentsSize, nullptr)) {
         ERR("Failed to get GL contents size for ColorBuffer:%d", mHandle);
@@ -408,7 +371,6 @@
         ERR("Failed to set VK contents for ColorBuffer:%d", mHandle);
         return false;
     }
-#endif
 
     return true;
 }
@@ -437,7 +399,6 @@
     }
 }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
 bool ColorBuffer::glOpBlitFromCurrentReadBuffer() {
     if (!mColorBufferGl) {
         GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "ColorBufferGl not available.";
@@ -568,6 +529,5 @@
 
     mColorBufferGl->postViewportScaledWithOverlay(rotation, dx, dy);
 }
-#endif
 
 }  // namespace gfxstream
diff --git a/host/ColorBuffer.h b/host/ColorBuffer.h
index 7056267..f519fe7 100644
--- a/host/ColorBuffer.h
+++ b/host/ColorBuffer.h
@@ -21,15 +21,10 @@
 #include "Handle.h"
 #include "Hwc2.h"
 #include "aemu/base/files/Stream.h"
+#include "gl/ColorBufferGl.h"
 #include "render-utils/Renderer.h"
 #include "snapshot/LazySnapshotObj.h"
 
-#if GFXSTREAM_ENABLE_HOST_GLES
-#include "gl/ColorBufferGl.h"
-#else
-#include "GlesCompat.h"
-#endif
-
 namespace gfxstream {
 namespace gl {
 class EmulationGl;
@@ -91,7 +86,6 @@
     bool invalidateForVk();
     bool importNativeResource(void* nativeResource, uint32_t type, bool preserveContent);
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     GLuint glOpGetTexture();
     bool glOpBlitFromCurrentReadBuffer();
     bool glOpBindToTexture();
@@ -107,7 +101,6 @@
     bool glOpIsFastBlitSupported() const;
     void glOpPostLayer(const ComposeLayer& l, int frameWidth, int frameHeight);
     void glOpPostViewportScaledWithOverlay(float rotation, float dx, float dy);
-#endif
 
    private:
     ColorBuffer(HandleType, uint32_t width, uint32_t height, GLenum format,
@@ -119,12 +112,8 @@
     const GLenum mFormat;
     const FrameworkFormat mFrameworkFormat;
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     // If GL emulation is enabled.
     std::unique_ptr<gl::ColorBufferGl> mColorBufferGl;
-#else
-    std::unique_ptr<uint32_t> mColorBufferGl = nullptr;
-#endif
 
     // If Vk emulation is enabled.
     std::unique_ptr<vk::ColorBufferVk> mColorBufferVk;
diff --git a/host/FrameBuffer.cpp b/host/FrameBuffer.cpp
index 54f78b9..f7f0016 100644
--- a/host/FrameBuffer.cpp
+++ b/host/FrameBuffer.cpp
@@ -27,9 +27,15 @@
 #endif
 
 #include "ContextHelper.h"
+#include "GLESVersionDetector.h"
 #include "Hwc2.h"
 #include "NativeSubWindow.h"
+#include "OpenGLESDispatch/DispatchTables.h"
+#include "OpenGLESDispatch/EGLDispatch.h"
+#include "PostWorkerGl.h"
+#include "RenderControl.h"
 #include "RenderThreadInfo.h"
+#include "RenderThreadInfoGl.h"
 #include "SyncThread.h"
 #include "aemu/base/LayoutResolver.h"
 #include "aemu/base/Metrics.h"
@@ -40,19 +46,9 @@
 #include "aemu/base/memory/MemoryTracker.h"
 #include "aemu/base/synchronization/Lock.h"
 #include "aemu/base/system/System.h"
-
-#if GFXSTREAM_ENABLE_HOST_GLES
-#include "GLESVersionDetector.h"
-#include "OpenGLESDispatch/DispatchTables.h"
-#include "OpenGLESDispatch/EGLDispatch.h"
-#include "PostWorkerGl.h"
-#include "RenderControl.h"
-#include "RenderThreadInfoGl.h"
 #include "gl/YUVConverter.h"
 #include "gl/gles2_dec/gles2_dec.h"
 #include "gl/glestranslator/EGL/EglGlobalInfo.h"
-#endif
-
 #include "host-common/GfxstreamFatalError.h"
 #include "host-common/crash_reporter.h"
 #include "host-common/feature_control.h"
@@ -77,8 +73,6 @@
 using emugl::CreateHealthMonitor;
 using emugl::FatalError;
 using emugl::GfxApiLogger;
-
-#if GFXSTREAM_ENABLE_HOST_GLES
 using gl::DisplaySurfaceGl;
 using gl::EmulatedEglConfig;
 using gl::EmulatedEglConfigList;
@@ -101,7 +95,6 @@
 using gl::TextureDraw;
 using gl::YUVConverter;
 using gl::YUVPlane;
-#endif
 
 using gfxstream::vk::AstcEmulationMode;
 using gfxstream::vk::VkEmulationFeatures;
@@ -334,7 +327,6 @@
         }
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     // Do not initialize GL emulation if the guest is using ANGLE.
     if (!feature_is_enabled(kFeature_GuestUsesAngle)) {
         fb->m_emulationGl = EmulationGl::create(width, height, useSubWindow, egl2egl);
@@ -343,7 +335,6 @@
             return false;
         }
     }
-#endif
 
     fb->m_guestUsesAngle =
         feature_is_enabled(
@@ -413,13 +404,11 @@
 
         fb->m_graphicsDeviceExtensions = deviceExtensionsStringBuilder.str();
     } else if (fb->m_emulationGl) {
-#if GFXSTREAM_ENABLE_HOST_GLES
         fb->m_graphicsAdapterVendor = fb->m_emulationGl->getGlesVendor();
         fb->m_graphicsAdapterName = fb->m_emulationGl->getGlesRenderer();
         fb->m_graphicsApiVersion = fb->m_emulationGl->getGlesVersionString();
         fb->m_graphicsApiExtensions = fb->m_emulationGl->getGlesExtensionsString();
         fb->m_graphicsDeviceExtensions = "N/A";
-#endif
     } else {
         fb->m_graphicsAdapterVendor = "N/A";
         fb->m_graphicsAdapterName = "N/A";
@@ -443,7 +432,6 @@
     if (!fb->m_emulationGl) {
         vulkanInteropSupported = false;
     } else {
-#if GFXSTREAM_ENABLE_HOST_GLES
         if (!fb->m_emulationGl->isGlesVulkanInteropSupported()) {
             vulkanInteropSupported = false;
         }
@@ -451,7 +439,6 @@
         if (!glesDeviceUuid  || glesDeviceUuid != fb->m_vulkanUUID) {
             vulkanInteropSupported = false;
         }
-#endif
     }
     // TODO: 0-copy gl interop on swiftshader vk
     if (android::base::getEnvironmentVariable("ANDROID_EMU_VK_ICD") == "swiftshader") {
@@ -462,13 +449,11 @@
     fb->m_vulkanInteropSupported = vulkanInteropSupported;
     GL_LOG("interop? %d", fb->m_vulkanInteropSupported);
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (vulkanInteropSupported && fb->m_emulationGl && fb->m_emulationGl->isMesa()) {
         // Mesa currently expects dedicated allocations for external memory sharing
         // between GL and VK. See b/265186355.
         vkEmulationFeatures->useDedicatedAllocations = true;
     }
-#endif
 
     GL_LOG("glvk interop final: %d", fb->m_vulkanInteropSupported);
     vkEmulationFeatures->glInteropSupported = fb->m_vulkanInteropSupported;
@@ -489,19 +474,15 @@
         fb->m_compositor = vkEmu->compositorVk.get();
     } else {
         GL_LOG("Performing composition using CompositorGl.");
-#if GFXSTREAM_ENABLE_HOST_GLES
         auto compositorGl = fb->m_emulationGl->getCompositor();
         fb->m_compositor = compositorGl;
-#endif
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (fb->m_emulationGl) {
         auto displayGl = fb->m_emulationGl->getDisplay();
         fb->m_displayGl = displayGl;
         fb->m_displaySurfaceUsers.push_back(displayGl);
     }
-#endif
 
     INFO("Graphics Adapter Vendor %s", fb->m_graphicsAdapterVendor.c_str());
     INFO("Graphics Adapter %s", fb->m_graphicsAdapterName.c_str());
@@ -514,13 +495,11 @@
     } else {
         const bool shouldPostOnlyOnMainThread = postOnlyOnMainThread();
 
-#if GFXSTREAM_ENABLE_HOST_GLES
         PostWorkerGl* postWorkerGl =
             new PostWorkerGl(shouldPostOnlyOnMainThread, fb.get(), fb->m_compositor,
                              fb->m_displayGl, fb->m_emulationGl.get());
         fb->m_postWorker.reset(postWorkerGl);
         fb->m_displaySurfaceUsers.push_back(postWorkerGl);
-#endif
     }
 
     // Start up the single sync thread. If we are using Vulkan native
@@ -555,6 +534,12 @@
     }
 }
 
+void FrameBuffer::fillGLESUsages(android_studio::EmulatorGLESUsages* usages) {
+    if (s_egl.eglFillUsages) {
+        s_egl.eglFillUsages(usages);
+    }
+}
+
 FrameBuffer::FrameBuffer(int p_width, int p_height, bool useSubWindow)
     : m_framebufferWidth(p_width),
       m_framebufferHeight(p_height),
@@ -615,14 +600,12 @@
     }
     m_colorBufferDelayedCloseList.clear();
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     m_windows.clear();
     m_contexts.clear();
 
     for (auto it : m_platformEglContexts) {
         destroySharedTrivialContext(it.second.context, it.second.surface);
     }
-#endif
 
     vk::teardownGlobalVkEmulation();
 
@@ -939,11 +922,9 @@
                 m_displaySurface =
                     vk::createDisplaySurface(m_subWin, m_windowWidth, m_windowHeight);
             } else if (m_emulationGl) {
-#if GFXSTREAM_ENABLE_HOST_GLES
                 m_displaySurface = m_emulationGl->createWindowSurface(m_windowWidth,
                                                                       m_windowHeight,
                                                                       m_subWin);
-#endif
             } else {
                 GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
                     << "Unhandled window surface creation.";
@@ -1098,10 +1079,8 @@
     HandleType id;
     do {
         id = ++s_nextHandle;
-    } while (id == 0 ||
-#if GFXSTREAM_ENABLE_HOST_GLES
-             m_contexts.find(id) != m_contexts.end() || m_windows.find(id) != m_windows.end() ||
-#endif
+    } while (id == 0 || m_contexts.find(id) != m_contexts.end() ||
+             m_windows.find(id) != m_windows.end() ||
              m_colorbuffers.find(id) != m_colorbuffers.end() ||
              m_buffers.find(id) != m_buffers.end());
 
@@ -1224,10 +1203,296 @@
     return handle;
 }
 
+HandleType FrameBuffer::createEmulatedEglContext(int config,
+                                                 HandleType shareContextHandle,
+                                                 GLESApi version) {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation unavailable.";
+    }
+
+    AutoLock mutex(m_lock);
+    android::base::AutoWriteLock contextLock(m_contextStructureLock);
+    // Hold the ColorBuffer map lock so that the new handle won't collide with a ColorBuffer handle.
+    AutoLock colorBufferMapLock(m_colorBufferMapLock);
+
+    EmulatedEglContextPtr shareContext = nullptr;
+    if (shareContextHandle != 0) {
+        auto shareContextIt = m_contexts.find(shareContextHandle);
+        if (shareContextIt == m_contexts.end()) {
+            ERR("Failed to find share EmulatedEglContext:%d", shareContextHandle);
+            return 0;
+        }
+        shareContext = shareContextIt->second;
+    }
+
+    HandleType contextHandle = genHandle_locked();
+    auto context = m_emulationGl->createEmulatedEglContext(config,
+                                                           shareContext.get(),
+                                                           version,
+                                                           contextHandle);
+    if (!context) {
+        ERR("Failed to create EmulatedEglContext.");
+        return 0;
+    }
+
+    m_contexts[contextHandle] = std::move(context);
+
+    RenderThreadInfo* tinfo = RenderThreadInfo::get();
+    uint64_t puid = tinfo->m_puid;
+    // The new emulator manages render contexts per guest process.
+    // Fall back to per-thread management if the system image does not
+    // support it.
+    if (puid) {
+        m_procOwnedEmulatedEglContexts[puid].insert(contextHandle);
+    } else { // legacy path to manage context lifetime by threads
+        if (!tinfo->m_glInfo) {
+            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                << "Render thread GL not available.";
+        }
+        tinfo->m_glInfo->m_contextSet.insert(contextHandle);
+    }
+
+    return contextHandle;
+}
+
+void FrameBuffer::destroyEmulatedEglContext(HandleType contextHandle) {
+    AutoLock mutex(m_lock);
+    sweepColorBuffersLocked();
+
+    android::base::AutoWriteLock contextLock(m_contextStructureLock);
+    m_contexts.erase(contextHandle);
+    RenderThreadInfo* tinfo = RenderThreadInfo::get();
+    uint64_t puid = tinfo->m_puid;
+    // The new emulator manages render contexts per guest process.
+    // Fall back to per-thread management if the system image does not
+    // support it.
+    if (puid) {
+        auto it = m_procOwnedEmulatedEglContexts.find(puid);
+        if (it != m_procOwnedEmulatedEglContexts.end()) {
+            it->second.erase(contextHandle);
+        }
+    } else {
+        if (!tinfo->m_glInfo) {
+            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                << "Render thread GL not available.";
+        }
+        tinfo->m_glInfo->m_contextSet.erase(contextHandle);
+    }
+}
+
+HandleType FrameBuffer::createEmulatedEglWindowSurface(int p_config,
+                                                       int p_width,
+                                                       int p_height) {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation unavailable.";
+    }
+
+    AutoLock mutex(m_lock);
+    // Hold the ColorBuffer map lock so that the new handle won't collide with a ColorBuffer handle.
+    AutoLock colorBufferMapLock(m_colorBufferMapLock);
+
+    HandleType handle = genHandle_locked();
+
+    auto window = m_emulationGl->createEmulatedEglWindowSurface(p_config,
+                                                                p_width,
+                                                                p_height,
+                                                                handle);
+    if (!window) {
+        ERR("Failed to create EmulatedEglWindowSurface.");
+        return 0;
+    }
+
+    m_windows[handle] = { std::move(window), 0 };
+
+    RenderThreadInfo* info = RenderThreadInfo::get();
+    if (!info->m_glInfo) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "RRenderThreadInfoGl not available.";
+    }
+
+    uint64_t puid = info->m_puid;
+    if (puid) {
+        m_procOwnedEmulatedEglWindowSurfaces[puid].insert(handle);
+    } else { // legacy path to manage window surface lifetime by threads
+        info->m_glInfo->m_windowSet.insert(handle);
+    }
+
+    return handle;
+}
+
+void FrameBuffer::destroyEmulatedEglWindowSurface(HandleType p_surface) {
+    if (m_shuttingDown) {
+        return;
+    }
+    AutoLock mutex(m_lock);
+    destroyEmulatedEglWindowSurfaceLocked(p_surface);
+}
+
+std::vector<HandleType> FrameBuffer::destroyEmulatedEglWindowSurfaceLocked(HandleType p_surface) {
+    std::vector<HandleType> colorBuffersToCleanUp;
+    const auto w = m_windows.find(p_surface);
+    if (w != m_windows.end()) {
+        RecursiveScopedContextBind bind(getPbufferSurfaceContextHelper());
+        if (!m_guestManagedColorBufferLifetime) {
+            if (m_refCountPipeEnabled) {
+                if (decColorBufferRefCountLocked(w->second.second)) {
+                    colorBuffersToCleanUp.push_back(w->second.second);
+                }
+            } else {
+                if (closeColorBufferLocked(w->second.second)) {
+                    colorBuffersToCleanUp.push_back(w->second.second);
+                }
+            }
+        }
+        m_windows.erase(w);
+        RenderThreadInfo* tinfo = RenderThreadInfo::get();
+        uint64_t puid = tinfo->m_puid;
+        if (puid) {
+            auto ite = m_procOwnedEmulatedEglWindowSurfaces.find(puid);
+            if (ite != m_procOwnedEmulatedEglWindowSurfaces.end()) {
+                ite->second.erase(p_surface);
+            }
+        } else {
+            if (!tinfo->m_glInfo) {
+                GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                    << "Render thread GL not available.";
+            }
+            tinfo->m_glInfo->m_windowSet.erase(p_surface);
+        }
+    }
+    return colorBuffersToCleanUp;
+}
+
+void FrameBuffer::createEmulatedEglFenceSync(EGLenum type,
+                                             int destroyWhenSignaled,
+                                             uint64_t* outSync,
+                                             uint64_t* outSyncThread) {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "GL/EGL emulation not available.";
+    }
+
+    // TODO(b/233939967): move RenderThreadInfoGl usage to EmulationGl.
+    RenderThreadInfoGl* const info = RenderThreadInfoGl::get();
+    if (!info) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "RenderThreadInfoGl not available.";
+    }
+    if (!info->currContext) {
+        auto fb = FrameBuffer::getFB();
+        uint32_t syncContext;
+        uint32_t syncSurface;
+        createTrivialContext(0, // There is no context to share.
+                             &syncContext,
+                             &syncSurface);
+        bindContext(syncContext,
+                    syncSurface,
+                    syncSurface);
+        // This context is then cleaned up when the render thread exits.
+    }
+
+    auto sync = m_emulationGl->createEmulatedEglFenceSync(type, destroyWhenSignaled);
+    if (!sync) {
+        return;
+    }
+
+    if (outSync) {
+        *outSync = (uint64_t)(uintptr_t)sync.release();
+    }
+    if (outSyncThread) {
+        *outSyncThread = reinterpret_cast<uint64_t>(SyncThread::get());
+    }
+}
+
+void FrameBuffer::drainGlRenderThreadResources() {
+    // If we're already exiting then snapshot should not contain
+    // this thread information at all.
+    if (isShuttingDown()) {
+        return;
+    }
+
+    // Release references to the current thread's context/surfaces if any
+    bindContext(0, 0, 0);
+
+    drainGlRenderThreadSurfaces();
+    drainGlRenderThreadContexts();
+
+    if (!s_egl.eglReleaseThread()) {
+        ERR("Error: RenderThread @%p failed to eglReleaseThread()", this);
+    }
+}
+
+void FrameBuffer::drainGlRenderThreadContexts() {
+    if (isShuttingDown()) {
+        return;
+    }
+
+    RenderThreadInfoGl* const tinfo = RenderThreadInfoGl::get();
+    if (!tinfo) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "Render thread GL not available.";
+    }
+
+    if (tinfo->m_contextSet.empty()) {
+        return;
+    }
+
+    AutoLock mutex(m_lock);
+    android::base::AutoWriteLock contextLock(m_contextStructureLock);
+    for (const HandleType contextHandle : tinfo->m_contextSet) {
+        m_contexts.erase(contextHandle);
+    }
+    tinfo->m_contextSet.clear();
+}
+
+void FrameBuffer::drainGlRenderThreadSurfaces() {
+    if (isShuttingDown()) {
+        return;
+    }
+
+    RenderThreadInfoGl* const tinfo = RenderThreadInfoGl::get();
+    if (!tinfo) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "Render thread GL not available.";
+    }
+
+    if (tinfo->m_windowSet.empty()) {
+        return;
+    }
+
+    std::vector<HandleType> colorBuffersToCleanup;
+
+    AutoLock mutex(m_lock);
+    RecursiveScopedContextBind bind(getPbufferSurfaceContextHelper());
+    for (const HandleType winHandle : tinfo->m_windowSet) {
+        const auto winIt = m_windows.find(winHandle);
+        if (winIt != m_windows.end()) {
+            if (const HandleType oldColorBufferHandle = winIt->second.second) {
+                if (!m_guestManagedColorBufferLifetime) {
+                    if (m_refCountPipeEnabled) {
+                        if (decColorBufferRefCountLocked(oldColorBufferHandle)) {
+                            colorBuffersToCleanup.push_back(oldColorBufferHandle);
+                        }
+                    } else {
+                        if (closeColorBufferLocked(oldColorBufferHandle)) {
+                            colorBuffersToCleanup.push_back(oldColorBufferHandle);
+                        }
+                    }
+                }
+                m_windows.erase(winIt);
+            }
+        }
+    }
+    tinfo->m_windowSet.clear();
+}
+
 int FrameBuffer::openColorBuffer(HandleType p_colorbuffer) {
     // When guest feature flag RefCountPipe is on, no reference counting is
     // needed.
-    if (m_refCountPipeEnabled) return 0;
+    if (m_refCountPipeEnabled)
+        return 0;
 
     RenderThreadInfo* tInfo = RenderThreadInfo::get();
 
@@ -1296,7 +1561,8 @@
     m_buffers.erase(it);
 }
 
-bool FrameBuffer::closeColorBufferLocked(HandleType p_colorbuffer, bool forced) {
+bool FrameBuffer::closeColorBufferLocked(HandleType p_colorbuffer,
+                                         bool forced) {
     // When guest feature flag RefCountPipe is on, no reference counting is
     // needed.
     if (m_refCountPipeEnabled) {
@@ -1466,7 +1732,6 @@
     std::vector<HandleType> colorBuffersToCleanup;
     {
         std::unique_ptr<RecursiveScopedContextBind> bind = nullptr;
-#if GFXSTREAM_ENABLE_HOST_GLES
         if (m_emulationGl) {
             bind = std::make_unique<RecursiveScopedContextBind>(getPbufferSurfaceContextHelper());
         }
@@ -1496,8 +1761,6 @@
                 m_procOwnedEmulatedEglWindowSurfaces.erase(procIte);
             }
         }
-#endif
-
         // Clean up color buffers.
         // A color buffer needs to be closed as many times as it is opened by
         // the guest process, to give the correct reference count.
@@ -1516,7 +1779,6 @@
             }
         }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
         // Clean up EGLImage handles
         if (m_emulationGl) {
             auto procImagesIt = m_procOwnedEmulatedEglImages.find(puid);
@@ -1527,10 +1789,7 @@
                 m_procOwnedEmulatedEglImages.erase(procImagesIt);
             }
         }
-#endif
     }
-
-#if GFXSTREAM_ENABLE_HOST_GLES
     // Unbind before cleaning up contexts
     // Cleanup render contexts
     if (m_emulationGl) {
@@ -1542,7 +1801,6 @@
             m_procOwnedEmulatedEglContexts.erase(procIte);
         }
     }
-#endif
 
     return colorBuffersToCleanup;
 }
@@ -1553,6 +1811,77 @@
     cbRef->closedTs = 0;
 }
 
+bool FrameBuffer::flushEmulatedEglWindowSurfaceColorBuffer(HandleType p_surface) {
+    AutoLock mutex(m_lock);
+
+    auto it = m_windows.find(p_surface);
+    if (it == m_windows.end()) {
+        ERR("FB::flushEmulatedEglWindowSurfaceColorBuffer: window handle %#x not found",
+            p_surface);
+        // bad surface handle
+        return false;
+    }
+
+    EmulatedEglWindowSurface* surface = it->second.first.get();
+    surface->flushColorBuffer();
+
+    return true;
+}
+
+HandleType FrameBuffer::getEmulatedEglWindowSurfaceColorBufferHandle(HandleType p_surface) {
+    AutoLock mutex(m_lock);
+
+    auto it = m_EmulatedEglWindowSurfaceToColorBuffer.find(p_surface);
+    if (it == m_EmulatedEglWindowSurfaceToColorBuffer.end()) {
+        return 0;
+    }
+
+    return it->second;
+}
+
+bool FrameBuffer::setEmulatedEglWindowSurfaceColorBuffer(HandleType p_surface,
+                                                         HandleType p_colorbuffer) {
+    AutoLock mutex(m_lock);
+
+    EmulatedEglWindowSurfaceMap::iterator w(m_windows.find(p_surface));
+    if (w == m_windows.end()) {
+        // bad surface handle
+        ERR("bad window surface handle %#x", p_surface);
+        return false;
+    }
+
+    {
+        AutoLock colorBufferMapLock(m_colorBufferMapLock);
+        ColorBufferMap::iterator c(m_colorbuffers.find(p_colorbuffer));
+        if (c == m_colorbuffers.end()) {
+            ERR("bad color buffer handle %#x", p_colorbuffer);
+            // bad colorbuffer handle
+            return false;
+        }
+
+        (*w).second.first->setColorBuffer((*c).second.cb);
+        markOpened(&c->second);
+        if (!m_guestManagedColorBufferLifetime) {
+            c->second.refcount++;
+        }
+    }
+    if (w->second.second) {
+        if (!m_guestManagedColorBufferLifetime) {
+            if (m_refCountPipeEnabled) {
+                decColorBufferRefCountLocked(w->second.second);
+            } else {
+                closeColorBufferLocked(w->second.second);
+            }
+        }
+    }
+
+    (*w).second.second = p_colorbuffer;
+
+    m_EmulatedEglWindowSurfaceToColorBuffer[p_surface] = p_colorbuffer;
+
+    return true;
+}
+
 void FrameBuffer::readBuffer(HandleType handle, uint64_t offset, uint64_t size, void* bytes) {
     AutoLock mutex(m_lock);
 
@@ -1591,6 +1920,92 @@
     colorBuffer->readYuvToBytes(x, y, width, height, pixels, pixels_size);
 }
 
+void FrameBuffer::createYUVTextures(uint32_t type,
+                                    uint32_t count,
+                                    int width,
+                                    int height,
+                                    uint32_t* output) {
+    FrameworkFormat format = static_cast<FrameworkFormat>(type);
+    AutoLock mutex(m_lock);
+    RecursiveScopedContextBind bind(getPbufferSurfaceContextHelper());
+    for (uint32_t i = 0; i < count; ++i) {
+        if (format == FRAMEWORK_FORMAT_NV12) {
+            YUVConverter::createYUVGLTex(GL_TEXTURE0, width, height,
+                                         format, YUVPlane::Y, &output[2 * i]);
+            YUVConverter::createYUVGLTex(GL_TEXTURE1, width / 2, height / 2,
+                                         format, YUVPlane::UV, &output[2 * i + 1]);
+        } else if (format == FRAMEWORK_FORMAT_YUV_420_888) {
+            YUVConverter::createYUVGLTex(GL_TEXTURE0, width, height,
+                                         format, YUVPlane::Y, &output[3 * i]);
+            YUVConverter::createYUVGLTex(GL_TEXTURE1, width / 2, height / 2,
+                                         format, YUVPlane::U, &output[3 * i + 1]);
+            YUVConverter::createYUVGLTex(GL_TEXTURE2, width / 2, height / 2,
+                                         format, YUVPlane::V, &output[3 * i + 2]);
+        }
+    }
+}
+
+void FrameBuffer::destroyYUVTextures(uint32_t type,
+                                     uint32_t count,
+                                     uint32_t* textures) {
+    AutoLock mutex(m_lock);
+    RecursiveScopedContextBind bind(getPbufferSurfaceContextHelper());
+    if (type == FRAMEWORK_FORMAT_NV12) {
+        s_gles2.glDeleteTextures(2 * count, textures);
+    } else if (type == FRAMEWORK_FORMAT_YUV_420_888) {
+        s_gles2.glDeleteTextures(3 * count, textures);
+    }
+}
+
+void FrameBuffer::updateYUVTextures(uint32_t type,
+                                    uint32_t* textures,
+                                    void* privData,
+                                    void* func) {
+    AutoLock mutex(m_lock);
+    RecursiveScopedContextBind bind(getPbufferSurfaceContextHelper());
+
+    yuv_updater_t updater = (yuv_updater_t)func;
+    uint32_t gtextures[3] = {0, 0, 0};
+
+    if (type == FRAMEWORK_FORMAT_NV12) {
+        gtextures[0] = s_gles2.glGetGlobalTexName(textures[0]);
+        gtextures[1] = s_gles2.glGetGlobalTexName(textures[1]);
+    } else if (type == FRAMEWORK_FORMAT_YUV_420_888) {
+        gtextures[0] = s_gles2.glGetGlobalTexName(textures[0]);
+        gtextures[1] = s_gles2.glGetGlobalTexName(textures[1]);
+        gtextures[2] = s_gles2.glGetGlobalTexName(textures[2]);
+    }
+
+#ifdef __APPLE__
+    EGLContext prevContext = s_egl.eglGetCurrentContext();
+    auto mydisp = EglGlobalInfo::getInstance()->getDisplayFromDisplayType(EGL_DEFAULT_DISPLAY);
+    void* nativecontext = mydisp->getLowLevelContext(prevContext);
+    struct MediaNativeCallerData callerdata;
+    callerdata.ctx = nativecontext;
+    callerdata.converter = nsConvertVideoFrameToNV12Textures;
+    void* pcallerdata = &callerdata;
+#else
+    void* pcallerdata = nullptr;
+#endif
+
+    updater(privData, type, gtextures, pcallerdata);
+}
+
+void FrameBuffer::swapTexturesAndUpdateColorBuffer(uint32_t p_colorbuffer, int x, int y, int width,
+                                                   int height, uint32_t format, uint32_t type,
+                                                   uint32_t texture_type, uint32_t* textures) {
+    {
+        AutoLock mutex(m_lock);
+        ColorBufferPtr colorBuffer = findColorBuffer(p_colorbuffer);
+        if (!colorBuffer) {
+            // bad colorbuffer handle
+            return;
+        }
+        colorBuffer->glOpSwapYuvTexturesAndUpdate(
+            format, type, static_cast<FrameworkFormat>(texture_type), textures);
+    }
+}
+
 bool FrameBuffer::updateBuffer(HandleType p_buffer, uint64_t offset, uint64_t size, void* bytes) {
     AutoLock mutex(m_lock);
 
@@ -1648,6 +2063,20 @@
     return true;
 }
 
+bool FrameBuffer::readColorBufferContents(
+    HandleType p_colorbuffer, size_t* numBytes, void* pixels) {
+
+    AutoLock mutex(m_lock);
+
+    ColorBufferPtr colorBuffer = findColorBuffer(p_colorbuffer);
+    if (!colorBuffer) {
+        // bad colorbuffer handle
+        return false;
+    }
+
+    return colorBuffer->glOpReadContents(numBytes, pixels);
+}
+
 bool FrameBuffer::getColorBufferInfo(
     HandleType p_colorbuffer, int* width, int* height, GLint* internalformat,
     FrameworkFormat* frameworkFormat) {
@@ -1684,12 +2113,272 @@
     return true;
 }
 
+bool FrameBuffer::bindColorBufferToTexture(HandleType p_colorbuffer) {
+    AutoLock mutex(m_lock);
+
+    ColorBufferPtr colorBuffer = findColorBuffer(p_colorbuffer);
+    if (!colorBuffer) {
+        // bad colorbuffer handle
+        return false;
+    }
+
+    return colorBuffer->glOpBindToTexture();
+}
+
+bool FrameBuffer::bindColorBufferToTexture2(HandleType p_colorbuffer) {
+    // This is only called when using multi window display
+    // It will deadlock when posting from main thread.
+    std::unique_ptr<AutoLock> mutex;
+    if (!postOnlyOnMainThread()) {
+        mutex = std::make_unique<AutoLock>(m_lock);
+    }
+
+    ColorBufferPtr colorBuffer = findColorBuffer(p_colorbuffer);
+    if (!colorBuffer) {
+        // bad colorbuffer handle
+        return false;
+    }
+
+    return colorBuffer->glOpBindToTexture2();
+}
+
+bool FrameBuffer::bindColorBufferToRenderbuffer(HandleType p_colorbuffer) {
+    AutoLock mutex(m_lock);
+
+    ColorBufferPtr colorBuffer = findColorBuffer(p_colorbuffer);
+    if (!colorBuffer) {
+        // bad colorbuffer handle
+        return false;
+    }
+
+    return colorBuffer->glOpBindToRenderbuffer();
+}
+
+bool FrameBuffer::bindContext(HandleType p_context,
+                              HandleType p_drawSurface,
+                              HandleType p_readSurface) {
+    if (m_shuttingDown) {
+        return false;
+    }
+
+    AutoLock mutex(m_lock);
+
+    EmulatedEglWindowSurfacePtr draw, read;
+    EmulatedEglContextPtr ctx;
+
+    //
+    // if this is not an unbind operation - make sure all handles are good
+    //
+    if (p_context || p_drawSurface || p_readSurface) {
+        ctx = getContext_locked(p_context);
+        if (!ctx)
+            return false;
+        EmulatedEglWindowSurfaceMap::iterator w(m_windows.find(p_drawSurface));
+        if (w == m_windows.end()) {
+            // bad surface handle
+            return false;
+        }
+        draw = (*w).second.first;
+
+        if (p_readSurface != p_drawSurface) {
+            EmulatedEglWindowSurfaceMap::iterator w(m_windows.find(p_readSurface));
+            if (w == m_windows.end()) {
+                // bad surface handle
+                return false;
+            }
+            read = (*w).second.first;
+        } else {
+            read = draw;
+        }
+    } else {
+        // if unbind operation, sweep color buffers
+        sweepColorBuffersLocked();
+    }
+
+    if (!s_egl.eglMakeCurrent(getDisplay(),
+                              draw ? draw->getEGLSurface() : EGL_NO_SURFACE,
+                              read ? read->getEGLSurface() : EGL_NO_SURFACE,
+                              ctx ? ctx->getEGLContext() : EGL_NO_CONTEXT)) {
+        ERR("eglMakeCurrent failed");
+        return false;
+    }
+
+    //
+    // Bind the surface(s) to the context
+    //
+    RenderThreadInfoGl* const tinfo = RenderThreadInfoGl::get();
+    if (!tinfo) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "Render thread GL not available.";
+    }
+
+    EmulatedEglWindowSurfacePtr bindDraw, bindRead;
+    if (draw.get() == NULL && read.get() == NULL) {
+        // Unbind the current read and draw surfaces from the context
+        bindDraw = tinfo->currDrawSurf;
+        bindRead = tinfo->currReadSurf;
+    } else {
+        bindDraw = draw;
+        bindRead = read;
+    }
+
+    if (bindDraw.get() != NULL && bindRead.get() != NULL) {
+        if (bindDraw.get() != bindRead.get()) {
+            bindDraw->bind(ctx, EmulatedEglWindowSurface::BIND_DRAW);
+            bindRead->bind(ctx, EmulatedEglWindowSurface::BIND_READ);
+        } else {
+            bindDraw->bind(ctx, EmulatedEglWindowSurface::BIND_READDRAW);
+        }
+    }
+
+    //
+    // update thread info with current bound context
+    //
+    tinfo->currContext = ctx;
+    tinfo->currDrawSurf = draw;
+    tinfo->currReadSurf = read;
+    if (ctx) {
+        if (ctx->clientVersion() > GLESApi_CM)
+            tinfo->m_gl2Dec.setContextData(&ctx->decoderContextData());
+        else
+            tinfo->m_glDec.setContextData(&ctx->decoderContextData());
+    } else {
+        tinfo->m_glDec.setContextData(NULL);
+        tinfo->m_gl2Dec.setContextData(NULL);
+    }
+    return true;
+}
+
+EmulatedEglContextPtr FrameBuffer::getContext_locked(HandleType p_context) {
+    return android::base::findOrDefault(m_contexts, p_context);
+}
+
+EmulatedEglWindowSurfacePtr FrameBuffer::getWindowSurface_locked(HandleType p_windowsurface) {
+    return android::base::findOrDefault(m_windows, p_windowsurface).first;
+}
+
+HandleType FrameBuffer::createEmulatedEglImage(HandleType contextHandle,
+                                               EGLenum target,
+                                               GLuint buffer) {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "GL/EGL emulation not enabled.";
+    }
+
+    AutoLock mutex(m_lock);
+
+    EmulatedEglContext* context = nullptr;
+    if (contextHandle) {
+        android::base::AutoWriteLock contextLock(m_contextStructureLock);
+
+        auto it = m_contexts.find(contextHandle);
+        if (it == m_contexts.end()) {
+            ERR("Failed to find EmulatedEglContext:%d", contextHandle);
+            return false;
+        }
+
+        context = it->second.get();
+    }
+
+    auto image = m_emulationGl->createEmulatedEglImage(context,
+                                                       target,
+                                                       reinterpret_cast<EGLClientBuffer>(buffer));
+    if (!image) {
+        ERR("Failed to create EmulatedEglImage");
+        return false;
+    }
+
+    HandleType imageHandle = image->getHandle();
+
+    m_images[imageHandle] = std::move(image);
+
+    RenderThreadInfo* tInfo = RenderThreadInfo::get();
+    uint64_t puid = tInfo->m_puid;
+    if (puid) {
+        m_procOwnedEmulatedEglImages[puid].insert(imageHandle);
+    }
+    return imageHandle;
+}
+
+EGLBoolean FrameBuffer::destroyEmulatedEglImage(HandleType imageHandle) {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "GL/EGL emulation not enabled.";
+    }
+
+    AutoLock mutex(m_lock);
+
+    auto imageIt = m_images.find(imageHandle);
+    if (imageIt == m_images.end()) {
+        ERR("Failed to find EmulatedEglImage:%d", imageHandle);
+        return false;
+    }
+    auto& image = imageIt->second;
+
+    EGLBoolean success = image->destroy();
+    m_images.erase(imageIt);
+
+    RenderThreadInfo* tInfo = RenderThreadInfo::get();
+    uint64_t puid = tInfo->m_puid;
+    if (puid) {
+        m_procOwnedEmulatedEglImages[puid].erase(imageHandle);
+        // We don't explicitly call m_procOwnedEmulatedEglImages.erase(puid) when the
+        // size reaches 0, since it could go between zero and one many times in
+        // the lifetime of a process. It will be cleaned up by
+        // cleanupProcGLObjects(puid) when the process is dead.
+    }
+    return success;
+}
+
+void FrameBuffer::createTrivialContext(HandleType shared,
+                                       HandleType* contextOut,
+                                       HandleType* surfOut) {
+    assert(contextOut);
+    assert(surfOut);
+
+    *contextOut = createEmulatedEglContext(0, shared, GLESApi_2);
+    // Zero size is formally allowed here, but SwiftShader doesn't like it and
+    // fails.
+    *surfOut = createEmulatedEglWindowSurface(0, 1, 1);
+}
+
+void FrameBuffer::createSharedTrivialContext(EGLContext* contextOut,
+                                             EGLSurface* surfOut) {
+    assert(contextOut);
+    assert(surfOut);
+
+    const EmulatedEglConfig* config = getConfigs()->get(0 /* p_config */);
+    if (!config) return;
+
+    int maj, min;
+    emugl::getGlesVersion(&maj, &min);
+
+    const EGLint contextAttribs[] = {
+        EGL_CONTEXT_MAJOR_VERSION_KHR, maj,
+        EGL_CONTEXT_MINOR_VERSION_KHR, min,
+        EGL_NONE };
+
+    *contextOut = s_egl.eglCreateContext(
+            getDisplay(), config->getHostEglConfig(), getGlobalEGLContext(), contextAttribs);
+
+    const EGLint pbufAttribs[] = {
+        EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };
+
+    *surfOut = s_egl.eglCreatePbufferSurface(getDisplay(), config->getHostEglConfig(), pbufAttribs);
+}
+
+void FrameBuffer::destroySharedTrivialContext(EGLContext context,
+                                              EGLSurface surface) {
+    if (getDisplay() != EGL_NO_DISPLAY) {
+        s_egl.eglDestroyContext(getDisplay(), context);
+        s_egl.eglDestroySurface(getDisplay(), surface);
+    }
+}
+
 bool FrameBuffer::post(HandleType p_colorbuffer, bool needLockAndBind) {
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (m_guestUsesAngle) {
         flushColorBufferFromGl(p_colorbuffer);
     }
-#endif
 
     auto res = postImplSync(p_colorbuffer, needLockAndBind);
     if (res) setGuestPostedAFrame();
@@ -1698,11 +2387,9 @@
 
 void FrameBuffer::postWithCallback(HandleType p_colorbuffer, Post::CompletionCallback callback,
                                    bool needLockAndBind) {
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (m_guestUsesAngle) {
         flushColorBufferFromGl(p_colorbuffer);
     }
-#endif
 
     AsyncResult res = postImpl(p_colorbuffer, callback, needLockAndBind);
     if (res.Succeeded()) {
@@ -1717,7 +2404,9 @@
     }
 }
 
-bool FrameBuffer::postImplSync(HandleType p_colorbuffer, bool needLockAndBind, bool repaint) {
+bool FrameBuffer::postImplSync(HandleType p_colorbuffer,
+    bool needLockAndBind,
+    bool repaint) {
     std::promise<void> promise;
     std::future<void> completeFuture = promise.get_future();
     auto posted = postImpl(
@@ -1734,16 +2423,16 @@
     return posted.Succeeded();
 }
 
-AsyncResult FrameBuffer::postImpl(HandleType p_colorbuffer, Post::CompletionCallback callback,
-                                  bool needLockAndBind, bool repaint) {
+AsyncResult FrameBuffer::postImpl(HandleType p_colorbuffer,
+                           Post::CompletionCallback callback,
+                           bool needLockAndBind,
+                           bool repaint) {
     std::unique_ptr<RecursiveScopedContextBind> bind;
     if (needLockAndBind) {
         m_lock.lock();
-#if GFXSTREAM_ENABLE_HOST_GLES
         if (m_emulationGl) {
             bind = std::make_unique<RecursiveScopedContextBind>(getPbufferSurfaceContextHelper());
         }
-#endif
     }
     AsyncResult ret = AsyncResult::FAIL_AND_CALLBACK_NOT_SCHEDULED;
 
@@ -1820,20 +2509,21 @@
 
         if (asyncReadbackSupported()) {
             ensureReadbackWorker();
-            const auto status = m_readbackWorker->doNextReadback(
-                iter.first, cb.get(), iter.second.img, repaint, iter.second.readBgra);
+            const auto status = m_readbackWorker->doNextReadback(iter.first,
+                                                                 cb.get(),
+                                                                 iter.second.img,
+                                                                 repaint,
+                                                                 iter.second.readBgra);
             if (status == ReadbackWorker::DoNextReadbackResult::OK_READY_FOR_READ) {
                 doPostCallback(iter.second.img, iter.first);
             }
         } else {
-#if GFXSTREAM_ENABLE_HOST_GLES
             cb->glOpReadback(iter.second.img, iter.second.readBgra);
-#endif
             doPostCallback(iter.second.img, iter.first);
         }
     }
 DEC_REFCOUNT_AND_EXIT:
-    if (!m_subWin) {  // m_subWin is supposed to be false
+    if (!m_subWin) { // m_subWin is supposed to be false
         decColorBufferRefCountLocked(p_colorbuffer);
     }
 
@@ -1851,8 +2541,9 @@
         ERR("Cannot find post callback function for display %d", displayId);
         return;
     }
-    iter->second.cb(iter->second.context, displayId, iter->second.width, iter->second.height, -1,
-                    GL_RGBA, GL_UNSIGNED_BYTE, (unsigned char*)pixels);
+    iter->second.cb(iter->second.context, displayId, iter->second.width,
+                    iter->second.height, -1, GL_RGBA, GL_UNSIGNED_BYTE,
+                    (unsigned char*)pixels);
 }
 
 void FrameBuffer::getPixels(void* pixels, uint32_t bytes, uint32_t displayId) {
@@ -1861,8 +2552,8 @@
         ERR("Display %d not configured for recording yet", displayId);
         return;
     }
-    std::future<void> completeFuture =
-        m_readbackThread.enqueue({ReadbackCmd::GetPixels, displayId, pixels, bytes});
+    std::future<void> completeFuture = m_readbackThread.enqueue(
+        {ReadbackCmd::GetPixels, displayId, pixels, bytes});
     completeFuture.wait();
 }
 
@@ -1882,17 +2573,17 @@
 }
 
 void FrameBuffer::ensureReadbackWorker() {
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (!m_readbackWorker) {
         if (!m_emulationGl) {
-            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "GL/EGL emulation not enabled.";
+            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                << "GL/EGL emulation not enabled.";
         }
         m_readbackWorker = m_emulationGl->getReadbackWorker();
     }
-#endif
 }
 
-static void sFrameBuffer_ReadPixelsCallback(void* pixels, uint32_t bytes, uint32_t displayId) {
+static void sFrameBuffer_ReadPixelsCallback(
+    void* pixels, uint32_t bytes, uint32_t displayId) {
     FrameBuffer::getFB()->getPixels(pixels, bytes, displayId);
 }
 
@@ -1901,11 +2592,7 @@
 }
 
 bool FrameBuffer::asyncReadbackSupported() {
-#if GFXSTREAM_ENABLE_HOST_GLES
     return m_emulationGl && m_emulationGl->isAsyncReadbackSupported();
-#else
-    return false;
-#endif
 }
 
 Renderer::ReadPixelsCallback FrameBuffer::getReadPixelsCallback() {
@@ -1921,7 +2608,8 @@
     if (m_displayVk) {
         return true;
     }
-    if (m_lastPostedColorBuffer && sInitialized.load(std::memory_order_relaxed)) {
+    if (m_lastPostedColorBuffer &&
+        sInitialized.load(std::memory_order_relaxed)) {
         GL_LOG("Has last posted colorbuffer and is initialized; post.");
         return postImplSync(m_lastPostedColorBuffer, needLockAndBind, true);
     } else {
@@ -1938,26 +2626,30 @@
     // Exclude empty handle lists from saving as they add no value but only
     // increase the snapshot size; keep the format compatible with
     // android::base::saveCollection() though.
-    const int count = std::count_if(
-        c.begin(), c.end(),
-        [](const typename Collection::value_type& pair) { return !pair.second.empty(); });
+    const int count =
+            std::count_if(c.begin(), c.end(),
+                          [](const typename Collection::value_type& pair) {
+                              return !pair.second.empty();
+                          });
     stream->putBe32(count);
     for (const auto& pair : c) {
         if (pair.second.empty()) {
             continue;
         }
         stream->putBe64(pair.first);
-        saveCollection(stream, pair.second, [](Stream* s, HandleType h) { s->putBe32(h); });
+        saveCollection(stream, pair.second,
+                       [](Stream* s, HandleType h) { s->putBe32(h); });
     }
 }
 
 template <class Collection>
 static void loadProcOwnedCollection(Stream* stream, Collection* c) {
-    loadCollection(stream, c, [](Stream* stream) -> typename Collection::value_type {
+    loadCollection(stream, c,
+                   [](Stream* stream) -> typename Collection::value_type {
         const int processId = stream->getBe64();
         typename Collection::mapped_type handles;
         loadCollection(stream, &handles, [](Stream* s) { return s->getBe32(); });
-        return {processId, std::move(handles)};
+        return { processId, std::move(handles) };
     });
 }
 
@@ -1966,8 +2658,14 @@
                                int desiredHeight, int desiredRotation, Rect rect) {
     AutoLock mutex(m_lock);
     uint32_t w, h, cb, screenWidth, screenHeight;
-    if (!emugl::get_emugl_multi_display_operations().getMultiDisplay(
-            displayId, nullptr, nullptr, &w, &h, nullptr, nullptr, nullptr)) {
+    if (!emugl::get_emugl_multi_display_operations().getMultiDisplay(displayId,
+                                                                     nullptr,
+                                                                     nullptr,
+                                                                     &w,
+                                                                     &h,
+                                                                     nullptr,
+                                                                     nullptr,
+                                                                     nullptr)) {
         ERR("Screenshot of invalid display %d", displayId);
         *width = 0;
         *height = 0;
@@ -2007,7 +2705,8 @@
             return -1;
         }
         if ((rect.pos.x < 0 || rect.pos.y < 0) ||
-            (desiredWidth < rect.pos.x + rect.size.w || desiredHeight < rect.pos.y + rect.size.h)) {
+            (desiredWidth < rect.pos.x + rect.size.w ||
+             desiredHeight < rect.pos.y + rect.size.h)) {
             return -1;
         }
     }
@@ -2020,8 +2719,8 @@
         *height = screenHeight;
     }
 
-    int needed =
-        useSnipping ? (nChannels * rect.size.w * rect.size.h) : (nChannels * (*width) * (*height));
+    int needed = useSnipping ? (nChannels * rect.size.w * rect.size.h)
+                             : (nChannels * (*width) * (*height));
 
     if (*cPixels < needed) {
         *cPixels = needed;
@@ -2102,8 +2801,8 @@
 bool FrameBuffer::compose(uint32_t bufferSize, void* buffer, bool needPost) {
     std::promise<void> promise;
     std::future<void> completeFuture = promise.get_future();
-    auto composeRes =
-        composeWithCallback(bufferSize, buffer, [&](std::shared_future<void> waitForGpu) {
+    auto composeRes = composeWithCallback(
+        bufferSize, buffer, [&](std::shared_future<void> waitForGpu) {
             waitForGpu.wait();
             promise.set_value();
         });
@@ -2142,47 +2841,48 @@
 }
 
 AsyncResult FrameBuffer::composeWithCallback(uint32_t bufferSize, void* buffer,
-                                             Post::CompletionCallback callback) {
+                                      Post::CompletionCallback callback) {
     ComposeDevice* p = (ComposeDevice*)buffer;
     AutoLock mutex(m_lock);
 
     switch (p->version) {
-        case 1: {
-            Post composeCmd;
-            composeCmd.composeVersion = 1;
-            composeCmd.composeBuffer.resize(bufferSize);
-            memcpy(composeCmd.composeBuffer.data(), buffer, bufferSize);
-            composeCmd.completionCallback = std::make_unique<Post::CompletionCallback>(callback);
-            composeCmd.cmd = PostCmd::Compose;
-            sendPostWorkerCmd(std::move(composeCmd));
-            return AsyncResult::OK_AND_CALLBACK_SCHEDULED;
-        }
+    case 1: {
+        Post composeCmd;
+        composeCmd.composeVersion = 1;
+        composeCmd.composeBuffer.resize(bufferSize);
+        memcpy(composeCmd.composeBuffer.data(), buffer, bufferSize);
+        composeCmd.completionCallback = std::make_unique<Post::CompletionCallback>(callback);
+        composeCmd.cmd = PostCmd::Compose;
+        sendPostWorkerCmd(std::move(composeCmd));
+        return AsyncResult::OK_AND_CALLBACK_SCHEDULED;
+    }
 
-        case 2: {
-            // support for multi-display
-            ComposeDevice_v2* p2 = (ComposeDevice_v2*)buffer;
-            if (p2->displayId != 0) {
-                mutex.unlock();
-                setDisplayColorBuffer(p2->displayId, p2->targetHandle);
-                mutex.lock();
-            }
-            Post composeCmd;
-            composeCmd.composeVersion = 2;
-            composeCmd.composeBuffer.resize(bufferSize);
-            memcpy(composeCmd.composeBuffer.data(), buffer, bufferSize);
-            composeCmd.completionCallback = std::make_unique<Post::CompletionCallback>(callback);
-            composeCmd.cmd = PostCmd::Compose;
-            sendPostWorkerCmd(std::move(composeCmd));
-            return AsyncResult::OK_AND_CALLBACK_SCHEDULED;
+    case 2: {
+        // support for multi-display
+        ComposeDevice_v2* p2 = (ComposeDevice_v2*)buffer;
+        if (p2->displayId != 0) {
+            mutex.unlock();
+            setDisplayColorBuffer(p2->displayId, p2->targetHandle);
+            mutex.lock();
         }
+        Post composeCmd;
+        composeCmd.composeVersion = 2;
+        composeCmd.composeBuffer.resize(bufferSize);
+        memcpy(composeCmd.composeBuffer.data(), buffer, bufferSize);
+        composeCmd.completionCallback = std::make_unique<Post::CompletionCallback>(callback);
+        composeCmd.cmd = PostCmd::Compose;
+        sendPostWorkerCmd(std::move(composeCmd));
+        return AsyncResult::OK_AND_CALLBACK_SCHEDULED;
+    }
 
-        default:
-            ERR("yet to handle composition device version: %d", p->version);
-            return AsyncResult::FAIL_AND_CALLBACK_NOT_SCHEDULED;
+    default:
+       ERR("yet to handle composition device version: %d", p->version);
+        return AsyncResult::FAIL_AND_CALLBACK_NOT_SCHEDULED;
     }
 }
 
-void FrameBuffer::onSave(Stream* stream, const android::snapshot::ITextureSaverPtr& textureSaver) {
+void FrameBuffer::onSave(Stream* stream,
+                         const android::snapshot::ITextureSaverPtr& textureSaver) {
     // Things we do not need to snapshot:
     //     m_eglSurface
     //     m_eglContext
@@ -2194,7 +2894,6 @@
     AutoLock mutex(m_lock);
 
     std::unique_ptr<RecursiveScopedContextBind> bind;
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (m_emulationGl) {
         // Some snapshot commands try using GL.
         bind = std::make_unique<RecursiveScopedContextBind>(getPbufferSurfaceContextHelper());
@@ -2208,12 +2907,12 @@
         // and save all labeled textures and EGLImages.
         if (s_egl.eglPreSaveContext && s_egl.eglSaveAllImages) {
             for (const auto& ctx : m_contexts) {
-                s_egl.eglPreSaveContext(getDisplay(), ctx.second->getEGLContext(), stream);
+                s_egl.eglPreSaveContext(getDisplay(), ctx.second->getEGLContext(),
+                        stream);
             }
             s_egl.eglSaveAllImages(getDisplay(), stream, &textureSaver);
         }
     }
-#endif
 
     // Don't save subWindow's x/y/w/h here - those are related to the current
     // emulator UI state, not guest state that we're saving.
@@ -2243,11 +2942,10 @@
     // previous eglPreSaveContext and eglSaveAllImages calls (for texture
     // objects).
     // TODO: skip reading from GPU even for texture objects.
-#if GFXSTREAM_ENABLE_HOST_GLES
-    saveCollection(
-        stream, m_contexts,
-        [](Stream* s, const EmulatedEglContextMap::value_type& pair) { pair.second->onSave(s); });
-#endif
+    saveCollection(stream, m_contexts,
+                   [](Stream* s, const EmulatedEglContextMap::value_type& pair) {
+        pair.second->onSave(s);
+    });
 
     // We don't need to save |m_colorBufferCloseTsMap| here - there's enough
     // information to reconstruct it when loading.
@@ -2265,23 +2963,16 @@
                        });
     }
     stream->putBe32(m_lastPostedColorBuffer);
-#if GFXSTREAM_ENABLE_HOST_GLES
     saveCollection(stream, m_windows,
                    [](Stream* s, const EmulatedEglWindowSurfaceMap::value_type& pair) {
-                       pair.second.first->onSave(s);
-                       s->putBe32(pair.second.second);  // Color buffer handle.
-                   });
-#endif
+        pair.second.first->onSave(s);
+        s->putBe32(pair.second.second); // Color buffer handle.
+    });
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     saveProcOwnedCollection(stream, m_procOwnedEmulatedEglWindowSurfaces);
-#endif
     saveProcOwnedCollection(stream, m_procOwnedColorBuffers);
-#if GFXSTREAM_ENABLE_HOST_GLES
     saveProcOwnedCollection(stream, m_procOwnedEmulatedEglImages);
     saveProcOwnedCollection(stream, m_procOwnedEmulatedEglContexts);
-#endif
-
     // TODO(b/309858017): remove if when ready to bump snapshot version
     if (feature_is_enabled(kFeature_VulkanSnapshots)) {
         stream->putBe64(m_procOwnedResources.size());
@@ -2296,11 +2987,11 @@
         vk::VkDecoderGlobalState::get()->save(stream);
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (m_emulationGl) {
         if (s_egl.eglPostSaveContext) {
             for (const auto& ctx : m_contexts) {
-                s_egl.eglPostSaveContext(getDisplay(), ctx.second->getEGLContext(), stream);
+                s_egl.eglPostSaveContext(getDisplay(), ctx.second->getEGLContext(),
+                        stream);
             }
             // We need to run the post save step for m_eglContext
             // to mark their texture handles dirty
@@ -2311,7 +3002,6 @@
 
         EmulatedEglFenceSync::onSave(stream);
     }
-#endif
 }
 
 bool FrameBuffer::onLoad(Stream* stream,
@@ -2322,7 +3012,6 @@
         sweepColorBuffersLocked();
 
         std::unique_ptr<RecursiveScopedContextBind> bind;
-#if GFXSTREAM_ENABLE_HOST_GLES
         if (m_emulationGl) {
             // Some snapshot commands try using GL.
             bind = std::make_unique<RecursiveScopedContextBind>(getPbufferSurfaceContextHelper());
@@ -2330,27 +3019,21 @@
                 ERR("Failed to make context current for loading snapshot.");
             }
         }
-#endif
 
         bool cleanupComplete = false;
         {
             AutoLock colorBufferMapLock(m_colorBufferMapLock);
-            if (m_procOwnedCleanupCallbacks.empty() && m_procOwnedColorBuffers.empty() &&
-#if GFXSTREAM_ENABLE_HOST_GLES
-                m_procOwnedEmulatedEglContexts.empty() && m_procOwnedEmulatedEglImages.empty() &&
+            if (m_procOwnedCleanupCallbacks.empty() &&
+                m_procOwnedColorBuffers.empty() &&
+                m_procOwnedEmulatedEglContexts.empty() &&
+                m_procOwnedEmulatedEglImages.empty() &&
                 m_procOwnedEmulatedEglWindowSurfaces.empty() &&
-#endif
-                (
-#if GFXSTREAM_ENABLE_HOST_GLES
-                    !m_contexts.empty() || !m_windows.empty() ||
-#endif
-                    m_colorbuffers.size() > m_colorBufferDelayedCloseList.size())) {
+                (!m_contexts.empty() || !m_windows.empty() ||
+                 m_colorbuffers.size() > m_colorBufferDelayedCloseList.size())) {
                 // we are likely on a legacy system image, which does not have
                 // process owned objects. We need to force cleanup everything
-#if GFXSTREAM_ENABLE_HOST_GLES
                 m_contexts.clear();
                 m_windows.clear();
-#endif
                 m_colorbuffers.clear();
                 cleanupComplete = true;
             }
@@ -2358,34 +3041,30 @@
         if (!cleanupComplete) {
             std::vector<HandleType> colorBuffersToCleanup;
 
-#if GFXSTREAM_ENABLE_HOST_GLES
             while (m_procOwnedEmulatedEglWindowSurfaces.size()) {
                 auto cleanupHandles = cleanupProcGLObjects_locked(
-                    m_procOwnedEmulatedEglWindowSurfaces.begin()->first, true);
-                colorBuffersToCleanup.insert(colorBuffersToCleanup.end(), cleanupHandles.begin(),
-                                             cleanupHandles.end());
+                        m_procOwnedEmulatedEglWindowSurfaces.begin()->first, true);
+                colorBuffersToCleanup.insert(colorBuffersToCleanup.end(),
+                    cleanupHandles.begin(), cleanupHandles.end());
             }
-#endif
             while (m_procOwnedColorBuffers.size()) {
-                auto cleanupHandles =
-                    cleanupProcGLObjects_locked(m_procOwnedColorBuffers.begin()->first, true);
-                colorBuffersToCleanup.insert(colorBuffersToCleanup.end(), cleanupHandles.begin(),
-                                             cleanupHandles.end());
+                auto cleanupHandles = cleanupProcGLObjects_locked(
+                        m_procOwnedColorBuffers.begin()->first, true);
+                colorBuffersToCleanup.insert(colorBuffersToCleanup.end(),
+                    cleanupHandles.begin(), cleanupHandles.end());
             }
-#if GFXSTREAM_ENABLE_HOST_GLES
             while (m_procOwnedEmulatedEglImages.size()) {
-                auto cleanupHandles =
-                    cleanupProcGLObjects_locked(m_procOwnedEmulatedEglImages.begin()->first, true);
-                colorBuffersToCleanup.insert(colorBuffersToCleanup.end(), cleanupHandles.begin(),
-                                             cleanupHandles.end());
+                auto cleanupHandles = cleanupProcGLObjects_locked(
+                        m_procOwnedEmulatedEglImages.begin()->first, true);
+                colorBuffersToCleanup.insert(colorBuffersToCleanup.end(),
+                    cleanupHandles.begin(), cleanupHandles.end());
             }
             while (m_procOwnedEmulatedEglContexts.size()) {
                 auto cleanupHandles = cleanupProcGLObjects_locked(
-                    m_procOwnedEmulatedEglContexts.begin()->first, true);
-                colorBuffersToCleanup.insert(colorBuffersToCleanup.end(), cleanupHandles.begin(),
-                                             cleanupHandles.end());
+                        m_procOwnedEmulatedEglContexts.begin()->first, true);
+                colorBuffersToCleanup.insert(colorBuffersToCleanup.end(),
+                    cleanupHandles.begin(), cleanupHandles.end());
             }
-#endif
 
             std::vector<std::function<void()>> cleanupCallbacks;
 
@@ -2413,10 +3092,8 @@
             cleanupComplete = true;
         }
         m_colorBufferDelayedCloseList.clear();
-#if GFXSTREAM_ENABLE_HOST_GLES
         assert(m_contexts.empty());
         assert(m_windows.empty());
-#endif
         {
             AutoLock colorBufferMapLock(m_colorBufferMapLock);
             if (!m_colorbuffers.empty()) {
@@ -2428,13 +3105,11 @@
 #ifdef SNAPSHOT_PROFILE
         uint64_t texTime = android::base::getUnixTimeUs();
 #endif
-#if GFXSTREAM_ENABLE_HOST_GLES
         if (m_emulationGl) {
             if (s_egl.eglLoadAllImages) {
                 s_egl.eglLoadAllImages(getDisplay(), stream, &textureLoader);
             }
         }
-#endif
 #ifdef SNAPSHOT_PROFILE
         printf("Texture load time: %lld ms\n",
                (long long)(android::base::getUnixTimeUs() - texTime) / 1000);
@@ -2450,7 +3125,7 @@
                        int idx = static_cast<int>(s->getBe32());
                        int w = static_cast<int>(s->getBe32());
                        int h = static_cast<int>(s->getBe32());
-                       int dpiX = static_cast<int>(s->getBe32());
+                       int dpiX =  static_cast<int>(s->getBe32());
                        int dpiY = static_cast<int>(s->getBe32());
                        return {idx, {w, h, dpiX, dpiY}};
                    });
@@ -2464,19 +3139,18 @@
     m_statsNumFrames = stream->getBe32();
     m_statsStartTime = stream->getBe64();
 
-#if GFXSTREAM_ENABLE_HOST_GLES
-    loadCollection(
-        stream, &m_contexts, [this](Stream* stream) -> EmulatedEglContextMap::value_type {
-            if (!m_emulationGl) {
-                GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "GL/EGL emulation not enabled.";
-            }
+    loadCollection(stream, &m_contexts,
+                   [this](Stream* stream) -> EmulatedEglContextMap::value_type {
+                        if (!m_emulationGl) {
+                            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                                << "GL/EGL emulation not enabled.";
+                        }
 
-            auto context = m_emulationGl->loadEmulatedEglContext(stream);
-            auto contextHandle = context ? context->getHndl() : 0;
-            return {contextHandle, std::move(context)};
-        });
+                        auto context = m_emulationGl->loadEmulatedEglContext(stream);
+                        auto contextHandle = context ? context->getHndl() : 0;
+                        return { contextHandle, std::move(context) };
+                   });
     assert(!android::base::find(m_contexts, 0));
-#endif
 
     auto now = android::base::getUnixTimeUs();
     {
@@ -2500,32 +3174,28 @@
 
     {
         AutoLock colorBufferMapLock(m_colorBufferMapLock);
-#if GFXSTREAM_ENABLE_HOST_GLES
-        loadCollection(
-            stream, &m_windows, [this](Stream* stream) -> EmulatedEglWindowSurfaceMap::value_type {
-                if (!m_emulationGl) {
-                    GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
-                        << "GL/EGL emulation not enabled.";
-                }
+        loadCollection(stream, &m_windows,
+                       [this](Stream* stream) -> EmulatedEglWindowSurfaceMap::value_type {
+                            if (!m_emulationGl) {
+                                GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                                    << "GL/EGL emulation not enabled.";
+                            }
 
-                auto window =
-                    m_emulationGl->loadEmulatedEglWindowSurface(stream, m_colorbuffers, m_contexts);
+                            auto window = m_emulationGl->loadEmulatedEglWindowSurface(
+                                stream,
+                                m_colorbuffers,
+                                m_contexts);
 
-                HandleType handle = window->getHndl();
-                HandleType colorBufferHandle = stream->getBe32();
-                return {handle, {std::move(window), colorBufferHandle}};
-            });
-#endif
+                            HandleType handle = window->getHndl();
+                            HandleType colorBufferHandle = stream->getBe32();
+                            return { handle, { std::move(window), colorBufferHandle } };
+                        });
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     loadProcOwnedCollection(stream, &m_procOwnedEmulatedEglWindowSurfaces);
-#endif
     loadProcOwnedCollection(stream, &m_procOwnedColorBuffers);
-#if GFXSTREAM_ENABLE_HOST_GLES
     loadProcOwnedCollection(stream, &m_procOwnedEmulatedEglImages);
     loadProcOwnedCollection(stream, &m_procOwnedEmulatedEglContexts);
-#endif
     // TODO(b/309858017): remove if when ready to bump snapshot version
     if (feature_is_enabled(kFeature_VulkanSnapshots)) {
         size_t resourceCount = stream->getBe64();
@@ -2538,7 +3208,6 @@
         }
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (m_emulationGl) {
         if (s_egl.eglPostLoadAllImages) {
             s_egl.eglPostLoadAllImages(getDisplay(), stream);
@@ -2546,11 +3215,9 @@
     }
 
     registerTriggerWait();
-#endif
 
     {
         std::unique_ptr<RecursiveScopedContextBind> bind;
-#if GFXSTREAM_ENABLE_HOST_GLES
         if (m_emulationGl) {
             // Some snapshot commands try using GL.
             bind = std::make_unique<RecursiveScopedContextBind>(getPbufferSurfaceContextHelper());
@@ -2558,7 +3225,6 @@
                 ERR("Failed to make context current for loading snapshot.");
             }
         }
-#endif
 
         AutoLock colorBufferMapLock(m_colorBufferMapLock);
         for (auto& it : m_colorbuffers) {
@@ -2578,26 +3244,36 @@
 
     repost(false);
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (m_emulationGl) {
         EmulatedEglFenceSync::onLoad(stream);
     }
-#endif
 
     return true;
     // TODO: restore memory management
 }
 
-void FrameBuffer::lock() { m_lock.lock(); }
+void FrameBuffer::lock() {
+    m_lock.lock();
+}
 
-void FrameBuffer::unlock() { m_lock.unlock(); }
+void FrameBuffer::unlock() {
+    m_lock.unlock();
+}
+
+GLESDispatchMaxVersion FrameBuffer::getMaxGLESVersion() {
+    if (!m_emulationGl) {
+        return GLES_DISPATCH_MAX_VERSION_2;
+    }
+    return m_emulationGl->getGlesMaxDispatchVersion();
+}
 
 ColorBufferPtr FrameBuffer::findColorBuffer(HandleType p_colorbuffer) {
     AutoLock colorBufferMapLock(m_colorBufferMapLock);
     ColorBufferMap::iterator c(m_colorbuffers.find(p_colorbuffer));
     if (c == m_colorbuffers.end()) {
         return nullptr;
-    } else {
+    }
+    else {
         return c->second.cb;
     }
 }
@@ -2645,7 +3321,7 @@
     return i->second.get();
 }
 
-int FrameBuffer::createDisplay(uint32_t* displayId) {
+int FrameBuffer::createDisplay(uint32_t *displayId) {
     return emugl::get_emugl_multi_display_operations().createDisplay(displayId);
 }
 
@@ -2658,28 +3334,37 @@
 }
 
 int FrameBuffer::setDisplayColorBuffer(uint32_t displayId, uint32_t colorBuffer) {
-    return emugl::get_emugl_multi_display_operations().setDisplayColorBuffer(displayId,
-                                                                             colorBuffer);
+    return emugl::get_emugl_multi_display_operations().
+        setDisplayColorBuffer(displayId, colorBuffer);
 }
 
 int FrameBuffer::getDisplayColorBuffer(uint32_t displayId, uint32_t* colorBuffer) {
-    return emugl::get_emugl_multi_display_operations().getDisplayColorBuffer(displayId,
-                                                                             colorBuffer);
+    return emugl::get_emugl_multi_display_operations().
+        getDisplayColorBuffer(displayId, colorBuffer);
 }
 
 int FrameBuffer::getColorBufferDisplay(uint32_t colorBuffer, uint32_t* displayId) {
-    return emugl::get_emugl_multi_display_operations().getColorBufferDisplay(colorBuffer,
-                                                                             displayId);
+    return emugl::get_emugl_multi_display_operations().
+        getColorBufferDisplay(colorBuffer, displayId);
 }
 
-int FrameBuffer::getDisplayPose(uint32_t displayId, int32_t* x, int32_t* y, uint32_t* w,
+int FrameBuffer::getDisplayPose(uint32_t displayId,
+                                int32_t* x,
+                                int32_t* y,
+                                uint32_t* w,
                                 uint32_t* h) {
-    return emugl::get_emugl_multi_display_operations().getDisplayPose(displayId, x, y, w, h);
+    return emugl::get_emugl_multi_display_operations().
+        getDisplayPose(displayId, x, y, w, h);
 }
 
-int FrameBuffer::setDisplayPose(uint32_t displayId, int32_t x, int32_t y, uint32_t w, uint32_t h,
+int FrameBuffer::setDisplayPose(uint32_t displayId,
+                                int32_t x,
+                                int32_t y,
+                                uint32_t w,
+                                uint32_t h,
                                 uint32_t dpi) {
-    return emugl::get_emugl_multi_display_operations().setDisplayPose(displayId, x, y, w, h, dpi);
+    return emugl::get_emugl_multi_display_operations().
+        setDisplayPose(displayId, x, y, w, h, dpi);
 }
 
 void FrameBuffer::sweepColorBuffersLocked() {
@@ -2703,25 +3388,44 @@
     return scheduledFuture;
 }
 
-void FrameBuffer::waitForGpuVulkan(uint64_t deviceHandle, uint64_t fenceHandle) {
-    (void)deviceHandle;
-    if (!m_emulationGl) {
-        // Guest ANGLE should always use the asyncWaitForGpuVulkanWithCb call. EmulatedEglFenceSync
-        // is a wrapper over EGLSyncKHR and should not be used for pure Vulkan environment.
+void FrameBuffer::waitForGpu(uint64_t eglsync) {
+    EmulatedEglFenceSync* fenceSync = EmulatedEglFenceSync::getFromHandle(eglsync);
+
+    if (!fenceSync) {
+        ERR("err: fence sync 0x%llx not found", (unsigned long long)eglsync);
         return;
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
+    SyncThread::get()->triggerBlockedWaitNoTimeline(fenceSync);
+}
+
+void FrameBuffer::waitForGpuVulkan(uint64_t deviceHandle, uint64_t fenceHandle) {
+    (void)deviceHandle;
+    if (!m_emulationGl) {
+        // Guest ANGLE should always use the asyncWaitForGpuVulkanWithCb call. EmulatedEglFenceSync is a
+        // wrapper over EGLSyncKHR and should not be used for pure Vulkan environment.
+        return;
+    }
+
     // Note: this will always be nullptr.
     EmulatedEglFenceSync* fenceSync = EmulatedEglFenceSync::getFromHandle(fenceHandle);
 
     // Note: This will always signal right away.
     SyncThread::get()->triggerBlockedWaitNoTimeline(fenceSync);
-#endif
 }
 
-void FrameBuffer::asyncWaitForGpuVulkanWithCb(uint64_t deviceHandle, uint64_t fenceHandle,
-                                              FenceCompletionCallback cb) {
+void FrameBuffer::asyncWaitForGpuWithCb(uint64_t eglsync, FenceCompletionCallback cb) {
+    EmulatedEglFenceSync* fenceSync = EmulatedEglFenceSync::getFromHandle(eglsync);
+
+    if (!fenceSync) {
+        ERR("err: fence sync 0x%llx not found", (unsigned long long)eglsync);
+        return;
+    }
+
+    SyncThread::get()->triggerWaitWithCompletionCallback(fenceSync, std::move(cb));
+}
+
+void FrameBuffer::asyncWaitForGpuVulkanWithCb(uint64_t deviceHandle, uint64_t fenceHandle, FenceCompletionCallback cb) {
     (void)deviceHandle;
     SyncThread::get()->triggerWaitVkWithCompletionCallback((VkFence)fenceHandle, std::move(cb));
 }
@@ -2733,9 +3437,7 @@
 void FrameBuffer::waitForGpuVulkanQsri(uint64_t image) {
     (void)image;
     // Signal immediately, because this was a sync wait and it's vulkan.
-#if GFXSTREAM_ENABLE_HOST_GLES
     SyncThread::get()->triggerBlockedWaitNoTimeline(nullptr);
-#endif
 }
 
 void FrameBuffer::setGuestManagedColorBufferLifetime(bool guestManaged) {
@@ -2759,12 +3461,11 @@
     bool preserveContent = (info & RESOURCE_USE_PRESERVE);
 
     switch (type) {
-#if GFXSTREAM_ENABLE_HOST_GLES
         case RESOURCE_TYPE_EGL_NATIVE_PIXMAP:
             return colorBuffer->glOpImportEglNativePixmap(resource, preserveContent);
         case RESOURCE_TYPE_EGL_IMAGE:
             return colorBuffer->glOpImportEglImage(resource, preserveContent);
-#endif
+
         // Note: Additional non-EGL resource-types can be added here, and will
         // be propagated through color-buffer import functionality
         case RESOURCE_TYPE_VK_EXT_MEMORY_HANDLE:
@@ -2777,6 +3478,51 @@
     return true;
 }
 
+void* FrameBuffer::platformCreateSharedEglContext(void) {
+    AutoLock lock(m_lock);
+
+    EGLContext context = 0;
+    EGLSurface surface = 0;
+    createSharedTrivialContext(&context, &surface);
+
+    void* underlyingContext = s_egl.eglGetNativeContextANDROID(getDisplay(), context);
+    if (!underlyingContext) {
+        ERR("Error: Underlying egl backend could not produce a native EGL context.");
+        return nullptr;
+    }
+
+    m_platformEglContexts[underlyingContext] = { context, surface };
+
+#if defined(__QNX__)
+    EGLDisplay currDisplay = eglGetCurrentDisplay();
+    EGLSurface currRead = eglGetCurrentSurface(EGL_READ);
+    EGLSurface currDraw = eglGetCurrentSurface(EGL_DRAW);
+    EGLSurface currContext = eglGetCurrentContext();
+    // Make this context current to ensure thread-state is initialized
+    s_egl.eglMakeCurrent(getDisplay(), surface, surface, context);
+    // Revert back to original state
+    s_egl.eglMakeCurrent(currDisplay, currRead, currDraw, currContext);
+#endif
+
+    return underlyingContext;
+}
+
+bool FrameBuffer::platformDestroySharedEglContext(void* underlyingContext) {
+    AutoLock lock(m_lock);
+
+    auto it = m_platformEglContexts.find(underlyingContext);
+    if (it == m_platformEglContexts.end()) {
+        ERR("Error: Could not find underlying egl context %p (perhaps already destroyed?)", underlyingContext);
+        return false;
+    }
+
+    destroySharedTrivialContext(it->second.context, it->second.surface);
+
+    m_platformEglContexts.erase(it);
+
+    return true;
+}
+
 std::unique_ptr<BorrowedImageInfo> FrameBuffer::borrowColorBufferForComposition(
     uint32_t colorBufferHandle, bool colorBufferIsTarget) {
     ColorBufferPtr colorBufferPtr = findColorBuffer(colorBufferHandle);
@@ -2788,9 +3534,7 @@
     if (m_useVulkanComposition) {
         invalidateColorBufferForVk(colorBufferHandle);
     } else {
-#if GFXSTREAM_ENABLE_HOST_GLES
         invalidateColorBufferForGl(colorBufferHandle);
-#endif
     }
 
     const auto api = m_useVulkanComposition ? ColorBuffer::UsedApi::kVk : ColorBuffer::UsedApi::kGl;
@@ -2808,17 +3552,96 @@
     if (m_useVulkanComposition) {
         invalidateColorBufferForVk(colorBufferHandle);
     } else {
-#if GFXSTREAM_ENABLE_HOST_GLES
         invalidateColorBufferForGl(colorBufferHandle);
-#else
-        ERR("Failed to invalidate ColorBuffer:%d", colorBufferHandle);
-#endif
     }
 
     const auto api = m_useVulkanComposition ? ColorBuffer::UsedApi::kVk : ColorBuffer::UsedApi::kGl;
     return colorBufferPtr->borrowForDisplay(api);
 }
 
+EmulationGl& FrameBuffer::getEmulationGl() {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "GL/EGL emulation not enabled.";
+    }
+    return *m_emulationGl;
+}
+
+EGLDisplay FrameBuffer::getDisplay() const {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+    return m_emulationGl->mEglDisplay;
+}
+
+EGLSurface FrameBuffer::getWindowSurface() const {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+
+    if (!m_emulationGl->mWindowSurface) {
+        return EGL_NO_SURFACE;
+    }
+
+    const auto* displaySurfaceGl =
+        reinterpret_cast<const DisplaySurfaceGl*>(
+            m_emulationGl->mWindowSurface->getImpl());
+
+    return displaySurfaceGl->getSurface();
+}
+
+EGLContext FrameBuffer::getContext() const {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+    return m_emulationGl->mEglContext;
+}
+
+EGLContext FrameBuffer::getConfig() const {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+    return m_emulationGl->mEglConfig;
+}
+
+EGLContext FrameBuffer::getGlobalEGLContext() const {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+
+    if (!m_emulationGl->mPbufferSurface) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "FrameBuffer pbuffer surface not available.";
+    }
+
+    const auto* displaySurfaceGl =
+        reinterpret_cast<const DisplaySurfaceGl*>(
+            m_emulationGl->mPbufferSurface->getImpl());
+
+    return displaySurfaceGl->getContextForShareContext();
+}
+
+ContextHelper* FrameBuffer::getPbufferSurfaceContextHelper() const {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+    if (!m_emulationGl->mPbufferSurface) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation pbuffer surface not available.";
+    }
+    const auto* displaySurfaceGl =
+        reinterpret_cast<const DisplaySurfaceGl*>(
+            m_emulationGl->mPbufferSurface->getImpl());
+
+    return displaySurfaceGl->getContextHelper();
+}
+
 void FrameBuffer::logVulkanOutOfMemory(VkResult result, const char* function, int line,
                                        std::optional<uint64_t> allocationSize) {
     m_logger->logMetricEvent(MetricEventVulkanOutOfMemory{
@@ -2829,6 +3652,42 @@
     });
 }
 
+const EmulatedEglConfigList* FrameBuffer::getConfigs() const {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+
+    return &m_emulationGl->getEmulationEglConfigs();
+}
+
+TextureDraw* FrameBuffer::getTextureDraw() const {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+
+    return m_emulationGl->mTextureDraw.get();
+}
+
+bool FrameBuffer::isFastBlitSupported() const {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+
+    return m_emulationGl->isFastBlitSupported();
+}
+
+void FrameBuffer::disableFastBlitForTesting() {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+
+    m_emulationGl->disableFastBlitForTesting();
+}
+
 void FrameBuffer::setVsyncHz(int vsyncHz) {
     const uint64_t kOneSecondNs = 1000000000ULL;
     m_vsyncHz = vsyncHz;
@@ -2847,7 +3706,8 @@
     m_vsyncThread->schedule(task);
 }
 
-void FrameBuffer::setDisplayConfigs(int configId, int w, int h, int dpiX, int dpiY) {
+void FrameBuffer::setDisplayConfigs(int configId, int w, int h,
+                                    int dpiX, int dpiY) {
     AutoLock mutex(m_lock);
     mDisplayConfigs[configId] = {w, h, dpiX, dpiY};
     INFO("setDisplayConfigs w %d h %d dpiX %d dpiY %d", w, h, dpiX, dpiY);
@@ -2901,6 +3761,15 @@
     return mDisplayActiveConfigId >= 0 ? mDisplayActiveConfigId : -1;
 }
 
+bool FrameBuffer::flushColorBufferFromGl(HandleType colorBufferHandle) {
+    auto colorBuffer = findColorBuffer(colorBufferHandle);
+    if (!colorBuffer) {
+        ERR("Failed to find ColorBuffer:%d", colorBufferHandle);
+        return false;
+    }
+    return colorBuffer->flushFromGl();
+}
+
 bool FrameBuffer::flushColorBufferFromVk(HandleType colorBufferHandle) {
     auto colorBuffer = findColorBuffer(colorBufferHandle);
     if (!colorBuffer) {
@@ -2910,8 +3779,7 @@
     return colorBuffer->flushFromVk();
 }
 
-bool FrameBuffer::flushColorBufferFromVkBytes(HandleType colorBufferHandle, const void* bytes,
-                                              size_t bytesSize) {
+bool FrameBuffer::flushColorBufferFromVkBytes(HandleType colorBufferHandle, const void* bytes, size_t bytesSize) {
     AutoLock mutex(m_lock);
 
     auto colorBuffer = findColorBuffer(colorBufferHandle);
@@ -2922,6 +3790,15 @@
     return colorBuffer->flushFromVkBytes(bytes, bytesSize);
 }
 
+bool FrameBuffer::invalidateColorBufferForGl(HandleType colorBufferHandle) {
+    auto colorBuffer = findColorBuffer(colorBufferHandle);
+    if (!colorBuffer) {
+        ERR("Failed to find ColorBuffer:%d", colorBufferHandle);
+        return false;
+    }
+    return colorBuffer->invalidateForGl();
+}
+
 bool FrameBuffer::invalidateColorBufferForVk(HandleType colorBufferHandle) {
     // It reads contents from GL, which requires a context lock.
     // Also we should not do this in PostWorkerGl, otherwise it will deadlock.
@@ -2937,900 +3814,22 @@
     return colorBuffer->invalidateForVk();
 }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
-HandleType FrameBuffer::getEmulatedEglWindowSurfaceColorBufferHandle(HandleType p_surface) {
-    AutoLock mutex(m_lock);
-
-    auto it = m_EmulatedEglWindowSurfaceToColorBuffer.find(p_surface);
-    if (it == m_EmulatedEglWindowSurfaceToColorBuffer.end()) {
-        return 0;
-    }
-
-    return it->second;
-}
-
-void FrameBuffer::createTrivialContext(HandleType shared, HandleType* contextOut,
-                                       HandleType* surfOut) {
-    assert(contextOut);
-    assert(surfOut);
-
-    *contextOut = createEmulatedEglContext(0, shared, GLESApi_2);
-    // Zero size is formally allowed here, but SwiftShader doesn't like it and
-    // fails.
-    *surfOut = createEmulatedEglWindowSurface(0, 1, 1);
-}
-
-void FrameBuffer::createSharedTrivialContext(EGLContext* contextOut, EGLSurface* surfOut) {
-    assert(contextOut);
-    assert(surfOut);
-
-    const EmulatedEglConfig* config = getConfigs()->get(0 /* p_config */);
-    if (!config) return;
-
-    int maj, min;
-    emugl::getGlesVersion(&maj, &min);
-
-    const EGLint contextAttribs[] = {EGL_CONTEXT_MAJOR_VERSION_KHR, maj,
-                                     EGL_CONTEXT_MINOR_VERSION_KHR, min, EGL_NONE};
-
-    *contextOut = s_egl.eglCreateContext(getDisplay(), config->getHostEglConfig(),
-                                         getGlobalEGLContext(), contextAttribs);
-
-    const EGLint pbufAttribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE};
-
-    *surfOut = s_egl.eglCreatePbufferSurface(getDisplay(), config->getHostEglConfig(), pbufAttribs);
-}
-
-void FrameBuffer::destroySharedTrivialContext(EGLContext context, EGLSurface surface) {
-    if (getDisplay() != EGL_NO_DISPLAY) {
-        s_egl.eglDestroyContext(getDisplay(), context);
-        s_egl.eglDestroySurface(getDisplay(), surface);
-    }
-}
-
-const EmulatedEglConfigList* FrameBuffer::getConfigs() const {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-
-    return &m_emulationGl->getEmulationEglConfigs();
-}
-
-bool FrameBuffer::setEmulatedEglWindowSurfaceColorBuffer(HandleType p_surface,
-                                                         HandleType p_colorbuffer) {
-    AutoLock mutex(m_lock);
-
-    EmulatedEglWindowSurfaceMap::iterator w(m_windows.find(p_surface));
-    if (w == m_windows.end()) {
-        // bad surface handle
-        ERR("bad window surface handle %#x", p_surface);
-        return false;
-    }
-
-    {
-        AutoLock colorBufferMapLock(m_colorBufferMapLock);
-        ColorBufferMap::iterator c(m_colorbuffers.find(p_colorbuffer));
-        if (c == m_colorbuffers.end()) {
-            ERR("bad color buffer handle %#x", p_colorbuffer);
-            // bad colorbuffer handle
-            return false;
-        }
-
-        (*w).second.first->setColorBuffer((*c).second.cb);
-        markOpened(&c->second);
-        if (!m_guestManagedColorBufferLifetime) {
-            c->second.refcount++;
-        }
-    }
-    if (w->second.second) {
-        if (!m_guestManagedColorBufferLifetime) {
-            if (m_refCountPipeEnabled) {
-                decColorBufferRefCountLocked(w->second.second);
-            } else {
-                closeColorBufferLocked(w->second.second);
-            }
-        }
-    }
-
-    (*w).second.second = p_colorbuffer;
-
-    m_EmulatedEglWindowSurfaceToColorBuffer[p_surface] = p_colorbuffer;
-
-    return true;
-}
-
-HandleType FrameBuffer::createEmulatedEglContext(int config, HandleType shareContextHandle,
-                                                 GLESApi version) {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation unavailable.";
-    }
-
-    AutoLock mutex(m_lock);
-    android::base::AutoWriteLock contextLock(m_contextStructureLock);
-    // Hold the ColorBuffer map lock so that the new handle won't collide with a ColorBuffer handle.
-    AutoLock colorBufferMapLock(m_colorBufferMapLock);
-
-    EmulatedEglContextPtr shareContext = nullptr;
-    if (shareContextHandle != 0) {
-        auto shareContextIt = m_contexts.find(shareContextHandle);
-        if (shareContextIt == m_contexts.end()) {
-            ERR("Failed to find share EmulatedEglContext:%d", shareContextHandle);
-            return 0;
-        }
-        shareContext = shareContextIt->second;
-    }
-
-    HandleType contextHandle = genHandle_locked();
-    auto context =
-        m_emulationGl->createEmulatedEglContext(config, shareContext.get(), version, contextHandle);
-    if (!context) {
-        ERR("Failed to create EmulatedEglContext.");
-        return 0;
-    }
-
-    m_contexts[contextHandle] = std::move(context);
-
-    RenderThreadInfo* tinfo = RenderThreadInfo::get();
-    uint64_t puid = tinfo->m_puid;
-    // The new emulator manages render contexts per guest process.
-    // Fall back to per-thread management if the system image does not
-    // support it.
-    if (puid) {
-        m_procOwnedEmulatedEglContexts[puid].insert(contextHandle);
-    } else {  // legacy path to manage context lifetime by threads
-        if (!tinfo->m_glInfo) {
-            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Render thread GL not available.";
-        }
-        tinfo->m_glInfo->m_contextSet.insert(contextHandle);
-    }
-
-    return contextHandle;
-}
-
-void FrameBuffer::destroyEmulatedEglContext(HandleType contextHandle) {
-    AutoLock mutex(m_lock);
-    sweepColorBuffersLocked();
-
-    android::base::AutoWriteLock contextLock(m_contextStructureLock);
-    m_contexts.erase(contextHandle);
-    RenderThreadInfo* tinfo = RenderThreadInfo::get();
-    uint64_t puid = tinfo->m_puid;
-    // The new emulator manages render contexts per guest process.
-    // Fall back to per-thread management if the system image does not
-    // support it.
-    if (puid) {
-        auto it = m_procOwnedEmulatedEglContexts.find(puid);
-        if (it != m_procOwnedEmulatedEglContexts.end()) {
-            it->second.erase(contextHandle);
-        }
-    } else {
-        if (!tinfo->m_glInfo) {
-            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Render thread GL not available.";
-        }
-        tinfo->m_glInfo->m_contextSet.erase(contextHandle);
-    }
-}
-
-HandleType FrameBuffer::createEmulatedEglWindowSurface(int p_config, int p_width, int p_height) {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation unavailable.";
-    }
-
-    AutoLock mutex(m_lock);
-    // Hold the ColorBuffer map lock so that the new handle won't collide with a ColorBuffer handle.
-    AutoLock colorBufferMapLock(m_colorBufferMapLock);
-
-    HandleType handle = genHandle_locked();
-
-    auto window =
-        m_emulationGl->createEmulatedEglWindowSurface(p_config, p_width, p_height, handle);
-    if (!window) {
-        ERR("Failed to create EmulatedEglWindowSurface.");
-        return 0;
-    }
-
-    m_windows[handle] = {std::move(window), 0};
-
-    RenderThreadInfo* info = RenderThreadInfo::get();
-    if (!info->m_glInfo) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "RRenderThreadInfoGl not available.";
-    }
-
-    uint64_t puid = info->m_puid;
-    if (puid) {
-        m_procOwnedEmulatedEglWindowSurfaces[puid].insert(handle);
-    } else {  // legacy path to manage window surface lifetime by threads
-        info->m_glInfo->m_windowSet.insert(handle);
-    }
-
-    return handle;
-}
-
-void FrameBuffer::destroyEmulatedEglWindowSurface(HandleType p_surface) {
-    if (m_shuttingDown) {
-        return;
-    }
-    AutoLock mutex(m_lock);
-    destroyEmulatedEglWindowSurfaceLocked(p_surface);
-}
-
-std::vector<HandleType> FrameBuffer::destroyEmulatedEglWindowSurfaceLocked(HandleType p_surface) {
-    std::vector<HandleType> colorBuffersToCleanUp;
-    const auto w = m_windows.find(p_surface);
-    if (w != m_windows.end()) {
-        RecursiveScopedContextBind bind(getPbufferSurfaceContextHelper());
-        if (!m_guestManagedColorBufferLifetime) {
-            if (m_refCountPipeEnabled) {
-                if (decColorBufferRefCountLocked(w->second.second)) {
-                    colorBuffersToCleanUp.push_back(w->second.second);
-                }
-            } else {
-                if (closeColorBufferLocked(w->second.second)) {
-                    colorBuffersToCleanUp.push_back(w->second.second);
-                }
-            }
-        }
-        m_windows.erase(w);
-        RenderThreadInfo* tinfo = RenderThreadInfo::get();
-        uint64_t puid = tinfo->m_puid;
-        if (puid) {
-            auto ite = m_procOwnedEmulatedEglWindowSurfaces.find(puid);
-            if (ite != m_procOwnedEmulatedEglWindowSurfaces.end()) {
-                ite->second.erase(p_surface);
-            }
-        } else {
-            if (!tinfo->m_glInfo) {
-                GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
-                    << "Render thread GL not available.";
-            }
-            tinfo->m_glInfo->m_windowSet.erase(p_surface);
-        }
-    }
-    return colorBuffersToCleanUp;
-}
-
-void FrameBuffer::createEmulatedEglFenceSync(EGLenum type, int destroyWhenSignaled,
-                                             uint64_t* outSync, uint64_t* outSyncThread) {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "GL/EGL emulation not available.";
-    }
-
-    // TODO(b/233939967): move RenderThreadInfoGl usage to EmulationGl.
-    RenderThreadInfoGl* const info = RenderThreadInfoGl::get();
-    if (!info) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "RenderThreadInfoGl not available.";
-    }
-    if (!info->currContext) {
-        auto fb = FrameBuffer::getFB();
-        uint32_t syncContext;
-        uint32_t syncSurface;
-        createTrivialContext(0,  // There is no context to share.
-                             &syncContext, &syncSurface);
-        bindContext(syncContext, syncSurface, syncSurface);
-        // This context is then cleaned up when the render thread exits.
-    }
-
-    auto sync = m_emulationGl->createEmulatedEglFenceSync(type, destroyWhenSignaled);
-    if (!sync) {
-        return;
-    }
-
-    if (outSync) {
-        *outSync = (uint64_t)(uintptr_t)sync.release();
-    }
-    if (outSyncThread) {
-        *outSyncThread = reinterpret_cast<uint64_t>(SyncThread::get());
-    }
-}
-
-void FrameBuffer::drainGlRenderThreadResources() {
-    // If we're already exiting then snapshot should not contain
-    // this thread information at all.
-    if (isShuttingDown()) {
-        return;
-    }
-
-    // Release references to the current thread's context/surfaces if any
-    bindContext(0, 0, 0);
-
-    drainGlRenderThreadSurfaces();
-    drainGlRenderThreadContexts();
-
-    if (!s_egl.eglReleaseThread()) {
-        ERR("Error: RenderThread @%p failed to eglReleaseThread()", this);
-    }
-}
-
-void FrameBuffer::drainGlRenderThreadContexts() {
-    if (isShuttingDown()) {
-        return;
-    }
-
-    RenderThreadInfoGl* const tinfo = RenderThreadInfoGl::get();
-    if (!tinfo) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Render thread GL not available.";
-    }
-
-    if (tinfo->m_contextSet.empty()) {
-        return;
-    }
-
-    AutoLock mutex(m_lock);
-    android::base::AutoWriteLock contextLock(m_contextStructureLock);
-    for (const HandleType contextHandle : tinfo->m_contextSet) {
-        m_contexts.erase(contextHandle);
-    }
-    tinfo->m_contextSet.clear();
-}
-
-void FrameBuffer::drainGlRenderThreadSurfaces() {
-    if (isShuttingDown()) {
-        return;
-    }
-
-    RenderThreadInfoGl* const tinfo = RenderThreadInfoGl::get();
-    if (!tinfo) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Render thread GL not available.";
-    }
-
-    if (tinfo->m_windowSet.empty()) {
-        return;
-    }
-
-    std::vector<HandleType> colorBuffersToCleanup;
-
-    AutoLock mutex(m_lock);
-    RecursiveScopedContextBind bind(getPbufferSurfaceContextHelper());
-    for (const HandleType winHandle : tinfo->m_windowSet) {
-        const auto winIt = m_windows.find(winHandle);
-        if (winIt != m_windows.end()) {
-            if (const HandleType oldColorBufferHandle = winIt->second.second) {
-                if (!m_guestManagedColorBufferLifetime) {
-                    if (m_refCountPipeEnabled) {
-                        if (decColorBufferRefCountLocked(oldColorBufferHandle)) {
-                            colorBuffersToCleanup.push_back(oldColorBufferHandle);
-                        }
-                    } else {
-                        if (closeColorBufferLocked(oldColorBufferHandle)) {
-                            colorBuffersToCleanup.push_back(oldColorBufferHandle);
-                        }
-                    }
-                }
-                m_windows.erase(winIt);
-            }
-        }
-    }
-    tinfo->m_windowSet.clear();
-}
-
-EmulationGl& FrameBuffer::getEmulationGl() {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "GL/EGL emulation not enabled.";
-    }
-    return *m_emulationGl;
-}
-
-EGLDisplay FrameBuffer::getDisplay() const {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-    return m_emulationGl->mEglDisplay;
-}
-
-EGLSurface FrameBuffer::getWindowSurface() const {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-
-    if (!m_emulationGl->mWindowSurface) {
-        return EGL_NO_SURFACE;
-    }
-
-    const auto* displaySurfaceGl =
-        reinterpret_cast<const DisplaySurfaceGl*>(m_emulationGl->mWindowSurface->getImpl());
-
-    return displaySurfaceGl->getSurface();
-}
-
-EGLContext FrameBuffer::getContext() const {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-    return m_emulationGl->mEglContext;
-}
-
-EGLContext FrameBuffer::getConfig() const {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-    return m_emulationGl->mEglConfig;
-}
-
-EGLContext FrameBuffer::getGlobalEGLContext() const {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-
-    if (!m_emulationGl->mPbufferSurface) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
-            << "FrameBuffer pbuffer surface not available.";
-    }
-
-    const auto* displaySurfaceGl =
-        reinterpret_cast<const DisplaySurfaceGl*>(m_emulationGl->mPbufferSurface->getImpl());
-
-    return displaySurfaceGl->getContextForShareContext();
-}
-
-EmulatedEglContextPtr FrameBuffer::getContext_locked(HandleType p_context) {
-    return android::base::findOrDefault(m_contexts, p_context);
-}
-
-EmulatedEglWindowSurfacePtr FrameBuffer::getWindowSurface_locked(HandleType p_windowsurface) {
-    return android::base::findOrDefault(m_windows, p_windowsurface).first;
-}
-
-TextureDraw* FrameBuffer::getTextureDraw() const {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-
-    return m_emulationGl->mTextureDraw.get();
-}
-
-bool FrameBuffer::isFastBlitSupported() const {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-
-    return m_emulationGl->isFastBlitSupported();
-}
-
-void FrameBuffer::disableFastBlitForTesting() {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-
-    m_emulationGl->disableFastBlitForTesting();
-}
-
-HandleType FrameBuffer::createEmulatedEglImage(HandleType contextHandle, EGLenum target,
-                                               GLuint buffer) {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "GL/EGL emulation not enabled.";
-    }
-
-    AutoLock mutex(m_lock);
-
-    EmulatedEglContext* context = nullptr;
-    if (contextHandle) {
-        android::base::AutoWriteLock contextLock(m_contextStructureLock);
-
-        auto it = m_contexts.find(contextHandle);
-        if (it == m_contexts.end()) {
-            ERR("Failed to find EmulatedEglContext:%d", contextHandle);
-            return false;
-        }
-
-        context = it->second.get();
-    }
-
-    auto image = m_emulationGl->createEmulatedEglImage(context, target,
-                                                       reinterpret_cast<EGLClientBuffer>(buffer));
-    if (!image) {
-        ERR("Failed to create EmulatedEglImage");
-        return false;
-    }
-
-    HandleType imageHandle = image->getHandle();
-
-    m_images[imageHandle] = std::move(image);
-
-    RenderThreadInfo* tInfo = RenderThreadInfo::get();
-    uint64_t puid = tInfo->m_puid;
-    if (puid) {
-        m_procOwnedEmulatedEglImages[puid].insert(imageHandle);
-    }
-    return imageHandle;
-}
-
-EGLBoolean FrameBuffer::destroyEmulatedEglImage(HandleType imageHandle) {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "GL/EGL emulation not enabled.";
-    }
-
-    AutoLock mutex(m_lock);
-
-    auto imageIt = m_images.find(imageHandle);
-    if (imageIt == m_images.end()) {
-        ERR("Failed to find EmulatedEglImage:%d", imageHandle);
-        return false;
-    }
-    auto& image = imageIt->second;
-
-    EGLBoolean success = image->destroy();
-    m_images.erase(imageIt);
-
-    RenderThreadInfo* tInfo = RenderThreadInfo::get();
-    uint64_t puid = tInfo->m_puid;
-    if (puid) {
-        m_procOwnedEmulatedEglImages[puid].erase(imageHandle);
-        // We don't explicitly call m_procOwnedEmulatedEglImages.erase(puid) when the
-        // size reaches 0, since it could go between zero and one many times in
-        // the lifetime of a process. It will be cleaned up by
-        // cleanupProcGLObjects(puid) when the process is dead.
-    }
-    return success;
-}
-
-bool FrameBuffer::flushEmulatedEglWindowSurfaceColorBuffer(HandleType p_surface) {
-    AutoLock mutex(m_lock);
-
-    auto it = m_windows.find(p_surface);
-    if (it == m_windows.end()) {
-        ERR("FB::flushEmulatedEglWindowSurfaceColorBuffer: window handle %#x not found", p_surface);
-        // bad surface handle
-        return false;
-    }
-
-    EmulatedEglWindowSurface* surface = it->second.first.get();
-    surface->flushColorBuffer();
-
-    return true;
-}
-
-GLESDispatchMaxVersion FrameBuffer::getMaxGLESVersion() {
-    if (!m_emulationGl) {
-        return GLES_DISPATCH_MAX_VERSION_2;
-    }
-    return m_emulationGl->getGlesMaxDispatchVersion();
-}
-
-void FrameBuffer::fillGLESUsages(android_studio::EmulatorGLESUsages* usages) {
-    if (s_egl.eglFillUsages) {
-        s_egl.eglFillUsages(usages);
-    }
-}
-
-void* FrameBuffer::platformCreateSharedEglContext(void) {
-    AutoLock lock(m_lock);
-
-    EGLContext context = 0;
-    EGLSurface surface = 0;
-    createSharedTrivialContext(&context, &surface);
-
-    void* underlyingContext = s_egl.eglGetNativeContextANDROID(getDisplay(), context);
-    if (!underlyingContext) {
-        ERR("Error: Underlying egl backend could not produce a native EGL context.");
-        return nullptr;
-    }
-
-    m_platformEglContexts[underlyingContext] = {context, surface};
-
-#if defined(__QNX__)
-    EGLDisplay currDisplay = eglGetCurrentDisplay();
-    EGLSurface currRead = eglGetCurrentSurface(EGL_READ);
-    EGLSurface currDraw = eglGetCurrentSurface(EGL_DRAW);
-    EGLSurface currContext = eglGetCurrentContext();
-    // Make this context current to ensure thread-state is initialized
-    s_egl.eglMakeCurrent(getDisplay(), surface, surface, context);
-    // Revert back to original state
-    s_egl.eglMakeCurrent(currDisplay, currRead, currDraw, currContext);
-#endif
-
-    return underlyingContext;
-}
-
-bool FrameBuffer::platformDestroySharedEglContext(void* underlyingContext) {
-    AutoLock lock(m_lock);
-
-    auto it = m_platformEglContexts.find(underlyingContext);
-    if (it == m_platformEglContexts.end()) {
-        ERR("Error: Could not find underlying egl context %p (perhaps already destroyed?)",
-            underlyingContext);
-        return false;
-    }
-
-    destroySharedTrivialContext(it->second.context, it->second.surface);
-
-    m_platformEglContexts.erase(it);
-
-    return true;
-}
-
-bool FrameBuffer::flushColorBufferFromGl(HandleType colorBufferHandle) {
-    auto colorBuffer = findColorBuffer(colorBufferHandle);
-    if (!colorBuffer) {
-        ERR("Failed to find ColorBuffer:%d", colorBufferHandle);
-        return false;
-    }
-    return colorBuffer->flushFromGl();
-}
-
-bool FrameBuffer::invalidateColorBufferForGl(HandleType colorBufferHandle) {
-    auto colorBuffer = findColorBuffer(colorBufferHandle);
-    if (!colorBuffer) {
-        ERR("Failed to find ColorBuffer:%d", colorBufferHandle);
-        return false;
-    }
-    return colorBuffer->invalidateForGl();
-}
-
-ContextHelper* FrameBuffer::getPbufferSurfaceContextHelper() const {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-    if (!m_emulationGl->mPbufferSurface) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
-            << "EGL emulation pbuffer surface not available.";
-    }
-    const auto* displaySurfaceGl =
-        reinterpret_cast<const DisplaySurfaceGl*>(m_emulationGl->mPbufferSurface->getImpl());
-
-    return displaySurfaceGl->getContextHelper();
-}
-
-bool FrameBuffer::bindColorBufferToTexture(HandleType p_colorbuffer) {
-    AutoLock mutex(m_lock);
-
-    ColorBufferPtr colorBuffer = findColorBuffer(p_colorbuffer);
-    if (!colorBuffer) {
-        // bad colorbuffer handle
-        return false;
-    }
-
-    return colorBuffer->glOpBindToTexture();
-}
-
-bool FrameBuffer::bindColorBufferToTexture2(HandleType p_colorbuffer) {
-    // This is only called when using multi window display
-    // It will deadlock when posting from main thread.
-    std::unique_ptr<AutoLock> mutex;
-    if (!postOnlyOnMainThread()) {
-        mutex = std::make_unique<AutoLock>(m_lock);
-    }
-
-    ColorBufferPtr colorBuffer = findColorBuffer(p_colorbuffer);
-    if (!colorBuffer) {
-        // bad colorbuffer handle
-        return false;
-    }
-
-    return colorBuffer->glOpBindToTexture2();
-}
-
-bool FrameBuffer::bindColorBufferToRenderbuffer(HandleType p_colorbuffer) {
-    AutoLock mutex(m_lock);
-
-    ColorBufferPtr colorBuffer = findColorBuffer(p_colorbuffer);
-    if (!colorBuffer) {
-        // bad colorbuffer handle
-        return false;
-    }
-
-    return colorBuffer->glOpBindToRenderbuffer();
-}
-
-bool FrameBuffer::bindContext(HandleType p_context, HandleType p_drawSurface,
-                              HandleType p_readSurface) {
-    if (m_shuttingDown) {
-        return false;
-    }
-
-    AutoLock mutex(m_lock);
-
-    EmulatedEglWindowSurfacePtr draw, read;
-    EmulatedEglContextPtr ctx;
-
-    //
-    // if this is not an unbind operation - make sure all handles are good
-    //
-    if (p_context || p_drawSurface || p_readSurface) {
-        ctx = getContext_locked(p_context);
-        if (!ctx) return false;
-        EmulatedEglWindowSurfaceMap::iterator w(m_windows.find(p_drawSurface));
-        if (w == m_windows.end()) {
-            // bad surface handle
-            return false;
-        }
-        draw = (*w).second.first;
-
-        if (p_readSurface != p_drawSurface) {
-            EmulatedEglWindowSurfaceMap::iterator w(m_windows.find(p_readSurface));
-            if (w == m_windows.end()) {
-                // bad surface handle
-                return false;
-            }
-            read = (*w).second.first;
-        } else {
-            read = draw;
-        }
-    } else {
-        // if unbind operation, sweep color buffers
-        sweepColorBuffersLocked();
-    }
-
-    if (!s_egl.eglMakeCurrent(getDisplay(), draw ? draw->getEGLSurface() : EGL_NO_SURFACE,
-                              read ? read->getEGLSurface() : EGL_NO_SURFACE,
-                              ctx ? ctx->getEGLContext() : EGL_NO_CONTEXT)) {
-        ERR("eglMakeCurrent failed");
-        return false;
-    }
-
-    //
-    // Bind the surface(s) to the context
-    //
-    RenderThreadInfoGl* const tinfo = RenderThreadInfoGl::get();
-    if (!tinfo) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "Render thread GL not available.";
-    }
-
-    EmulatedEglWindowSurfacePtr bindDraw, bindRead;
-    if (draw.get() == NULL && read.get() == NULL) {
-        // Unbind the current read and draw surfaces from the context
-        bindDraw = tinfo->currDrawSurf;
-        bindRead = tinfo->currReadSurf;
-    } else {
-        bindDraw = draw;
-        bindRead = read;
-    }
-
-    if (bindDraw.get() != NULL && bindRead.get() != NULL) {
-        if (bindDraw.get() != bindRead.get()) {
-            bindDraw->bind(ctx, EmulatedEglWindowSurface::BIND_DRAW);
-            bindRead->bind(ctx, EmulatedEglWindowSurface::BIND_READ);
-        } else {
-            bindDraw->bind(ctx, EmulatedEglWindowSurface::BIND_READDRAW);
-        }
-    }
-
-    //
-    // update thread info with current bound context
-    //
-    tinfo->currContext = ctx;
-    tinfo->currDrawSurf = draw;
-    tinfo->currReadSurf = read;
-    if (ctx) {
-        if (ctx->clientVersion() > GLESApi_CM)
-            tinfo->m_gl2Dec.setContextData(&ctx->decoderContextData());
-        else
-            tinfo->m_glDec.setContextData(&ctx->decoderContextData());
-    } else {
-        tinfo->m_glDec.setContextData(NULL);
-        tinfo->m_gl2Dec.setContextData(NULL);
-    }
-    return true;
-}
-
-void FrameBuffer::createYUVTextures(uint32_t type, uint32_t count, int width, int height,
-                                    uint32_t* output) {
-    FrameworkFormat format = static_cast<FrameworkFormat>(type);
-    AutoLock mutex(m_lock);
-    RecursiveScopedContextBind bind(getPbufferSurfaceContextHelper());
-    for (uint32_t i = 0; i < count; ++i) {
-        if (format == FRAMEWORK_FORMAT_NV12) {
-            YUVConverter::createYUVGLTex(GL_TEXTURE0, width, height, format, YUVPlane::Y,
-                                         &output[2 * i]);
-            YUVConverter::createYUVGLTex(GL_TEXTURE1, width / 2, height / 2, format, YUVPlane::UV,
-                                         &output[2 * i + 1]);
-        } else if (format == FRAMEWORK_FORMAT_YUV_420_888) {
-            YUVConverter::createYUVGLTex(GL_TEXTURE0, width, height, format, YUVPlane::Y,
-                                         &output[3 * i]);
-            YUVConverter::createYUVGLTex(GL_TEXTURE1, width / 2, height / 2, format, YUVPlane::U,
-                                         &output[3 * i + 1]);
-            YUVConverter::createYUVGLTex(GL_TEXTURE2, width / 2, height / 2, format, YUVPlane::V,
-                                         &output[3 * i + 2]);
-        }
-    }
-}
-
-void FrameBuffer::destroyYUVTextures(uint32_t type, uint32_t count, uint32_t* textures) {
-    AutoLock mutex(m_lock);
-    RecursiveScopedContextBind bind(getPbufferSurfaceContextHelper());
-    if (type == FRAMEWORK_FORMAT_NV12) {
-        s_gles2.glDeleteTextures(2 * count, textures);
-    } else if (type == FRAMEWORK_FORMAT_YUV_420_888) {
-        s_gles2.glDeleteTextures(3 * count, textures);
-    }
-}
-
-void FrameBuffer::updateYUVTextures(uint32_t type, uint32_t* textures, void* privData, void* func) {
-    AutoLock mutex(m_lock);
-    RecursiveScopedContextBind bind(getPbufferSurfaceContextHelper());
-
-    yuv_updater_t updater = (yuv_updater_t)func;
-    uint32_t gtextures[3] = {0, 0, 0};
-
-    if (type == FRAMEWORK_FORMAT_NV12) {
-        gtextures[0] = s_gles2.glGetGlobalTexName(textures[0]);
-        gtextures[1] = s_gles2.glGetGlobalTexName(textures[1]);
-    } else if (type == FRAMEWORK_FORMAT_YUV_420_888) {
-        gtextures[0] = s_gles2.glGetGlobalTexName(textures[0]);
-        gtextures[1] = s_gles2.glGetGlobalTexName(textures[1]);
-        gtextures[2] = s_gles2.glGetGlobalTexName(textures[2]);
-    }
-
-#ifdef __APPLE__
-    EGLContext prevContext = s_egl.eglGetCurrentContext();
-    auto mydisp = EglGlobalInfo::getInstance()->getDisplayFromDisplayType(EGL_DEFAULT_DISPLAY);
-    void* nativecontext = mydisp->getLowLevelContext(prevContext);
-    struct MediaNativeCallerData callerdata;
-    callerdata.ctx = nativecontext;
-    callerdata.converter = nsConvertVideoFrameToNV12Textures;
-    void* pcallerdata = &callerdata;
-#else
-    void* pcallerdata = nullptr;
-#endif
-
-    updater(privData, type, gtextures, pcallerdata);
-}
-
-void FrameBuffer::swapTexturesAndUpdateColorBuffer(uint32_t p_colorbuffer, int x, int y, int width,
-                                                   int height, uint32_t format, uint32_t type,
-                                                   uint32_t texture_type, uint32_t* textures) {
-    {
-        AutoLock mutex(m_lock);
-        ColorBufferPtr colorBuffer = findColorBuffer(p_colorbuffer);
-        if (!colorBuffer) {
-            // bad colorbuffer handle
-            return;
-        }
-        colorBuffer->glOpSwapYuvTexturesAndUpdate(
-            format, type, static_cast<FrameworkFormat>(texture_type), textures);
-    }
-}
-
-bool FrameBuffer::readColorBufferContents(HandleType p_colorbuffer, size_t* numBytes,
-                                          void* pixels) {
-    AutoLock mutex(m_lock);
-
-    ColorBufferPtr colorBuffer = findColorBuffer(p_colorbuffer);
-    if (!colorBuffer) {
-        // bad colorbuffer handle
-        return false;
-    }
-
-    return colorBuffer->glOpReadContents(numBytes, pixels);
-}
-
-void FrameBuffer::waitForGpu(uint64_t eglsync) {
-    EmulatedEglFenceSync* fenceSync = EmulatedEglFenceSync::getFromHandle(eglsync);
-
-    if (!fenceSync) {
-        ERR("err: fence sync 0x%llx not found", (unsigned long long)eglsync);
-        return;
-    }
-
-    SyncThread::get()->triggerBlockedWaitNoTimeline(fenceSync);
-}
-
-void FrameBuffer::asyncWaitForGpuWithCb(uint64_t eglsync, FenceCompletionCallback cb) {
-    EmulatedEglFenceSync* fenceSync = EmulatedEglFenceSync::getFromHandle(eglsync);
-
-    if (!fenceSync) {
-        ERR("err: fence sync 0x%llx not found", (unsigned long long)eglsync);
-        return;
-    }
-
-    SyncThread::get()->triggerWaitWithCompletionCallback(fenceSync, std::move(cb));
-}
-
-const gl::GLESv2Dispatch* FrameBuffer::getGles2Dispatch() {
-    if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
-    }
-
-    return m_emulationGl->getGles2Dispatch();
-}
-
 const gl::EGLDispatch* FrameBuffer::getEglDispatch() {
     if (!m_emulationGl) {
-        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "EGL emulation not enabled.";
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
     }
 
     return m_emulationGl->getEglDispatch();
 }
 
-#endif
+const gl::GLESv2Dispatch* FrameBuffer::getGles2Dispatch() {
+    if (!m_emulationGl) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "EGL emulation not enabled.";
+    }
+
+    return m_emulationGl->getGles2Dispatch();
+}
 
 }  // namespace gfxstream
diff --git a/host/FrameBuffer.h b/host/FrameBuffer.h
index ecb28a9..60a6a35 100644
--- a/host/FrameBuffer.h
+++ b/host/FrameBuffer.h
@@ -16,6 +16,9 @@
 #ifndef _LIBRENDER_FRAMEBUFFER_H
 #define _LIBRENDER_FRAMEBUFFER_H
 
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
 #include <stdint.h>
 
 #include <array>
@@ -27,7 +30,6 @@
 #include <unordered_set>
 
 #include "Buffer.h"
-#include "ColorBuffer.h"
 #include "Compositor.h"
 #include "Display.h"
 #include "DisplaySurface.h"
@@ -46,13 +48,6 @@
 #include "aemu/base/synchronization/MessageChannel.h"
 #include "aemu/base/threads/Thread.h"
 #include "aemu/base/threads/WorkerThread.h"
-
-#if GFXSTREAM_ENABLE_HOST_GLES
-
-#include <EGL/egl.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-
 #include "gl/BufferGl.h"
 #include "gl/ColorBufferGl.h"
 #include "gl/CompositorGl.h"
@@ -64,19 +59,6 @@
 #include "gl/EmulationGl.h"
 #include "gl/GLESVersionDetector.h"
 #include "gl/TextureDraw.h"
-#else
-#include "GlesCompat.h"
-#endif
-
-// values for 'param' argument of rcGetFBParam
-#define FB_WIDTH 1
-#define FB_HEIGHT 2
-#define FB_XDPI 3
-#define FB_YDPI 4
-#define FB_FPS 5
-#define FB_MIN_SWAP_INTERVAL 6
-#define FB_MAX_SWAP_INTERVAL 7
-
 #include "render-utils/Renderer.h"
 #include "render-utils/virtio_gpu_ops.h"
 #include "render-utils/render_api.h"
@@ -119,13 +101,10 @@
     mutable std::atomic<uint32_t> mSequenceNumber;
 };
 
-#if GFXSTREAM_ENABLE_HOST_GLES
 typedef std::unordered_map<uint64_t, gl::EmulatedEglWindowSurfaceSet>
     ProcOwnedEmulatedEglWindowSurfaces;
 
 typedef std::unordered_map<uint64_t, gl::EmulatedEglContextSet> ProcOwnedEmulatedEglContexts;
-typedef std::unordered_map<uint64_t, gl::EmulatedEglImageSet> ProcOwnedEmulatedEGLImages;
-#endif
 
 typedef std::unordered_map<uint64_t, ColorBufferSet> ProcOwnedColorBuffers;
 
@@ -133,6 +112,8 @@
 typedef std::unordered_multiset<HandleType> BufferSet;
 typedef std::unordered_map<uint64_t, BufferSet> ProcOwnedBuffers;
 
+typedef std::unordered_map<uint64_t, gl::EmulatedEglImageSet> ProcOwnedEmulatedEGLImages;
+
 typedef std::unordered_map<void*, std::function<void()>> CallbackMap;
 typedef std::unordered_map<uint64_t, CallbackMap> ProcOwnedCleanupCallbacks;
 
@@ -199,12 +180,55 @@
     // Return the emulated GPU display height in pixels.
     int getHeight() const { return m_framebufferHeight; }
 
+    // Return the list of configs available from this display.
+    const gl::EmulatedEglConfigList* getConfigs() const;
+
     // Set a callback that will be called each time the emulated GPU content
     // is updated. This can be relatively slow with host-based GPU emulation,
     // so only do this when you need to.
     void setPostCallback(Renderer::OnPostCallback onPost, void* onPostContext, uint32_t displayId,
                          bool useBgraReadback = false);
 
+    // Retrieve the GL strings of the underlying EGL/GLES implementation.
+    // On return, |*vendor|, |*renderer| and |*version| will point to strings
+    // that are owned by the instance (and must not be freed by the caller).
+    void getGLStrings(const char** vendor, const char** renderer,
+                      const char** version) const {
+        *vendor = m_graphicsAdapterVendor.c_str();
+        *renderer = m_graphicsAdapterName.c_str();
+        *version = m_graphicsApiVersion.c_str();
+    }
+
+    // Create a new EmulatedEglContext instance for this display instance.
+    // |p_config| is the index of one of the configs returned by getConfigs().
+    // |p_share| is either EGL_NO_CONTEXT or the handle of a shared context.
+    // |version| specifies the GLES version as a GLESApi enum.
+    // Return a new handle value, which will be 0 in case of error.
+    HandleType createEmulatedEglContext(int p_config, HandleType p_share,
+                                        gl::GLESApi version = gl::GLESApi_CM);
+
+    // Destroy a given EmulatedEglContext instance. |p_context| is its handle
+    // value as returned by createEmulatedEglContext().
+    void destroyEmulatedEglContext(HandleType p_context);
+
+    // Create a new EmulatedEglWindowSurface instance from this display instance.
+    // |p_config| is the index of one of the configs returned by getConfigs().
+    // |p_width| and |p_height| are the window dimensions in pixels.
+    // Return a new handle value, or 0 in case of error.
+    HandleType createEmulatedEglWindowSurface(int p_config, int p_width, int p_height);
+
+    // Destroy a given EmulatedEglWindowSurface instance. |p_surcace| is its
+    // handle value as returned by createEmulatedEglWindowSurface().
+    void destroyEmulatedEglWindowSurface(HandleType p_surface);
+
+    // Returns the set of ColorBuffers destroyed (for further cleanup)
+    std::vector<HandleType> destroyEmulatedEglWindowSurfaceLocked(HandleType p_surface);
+
+    void createEmulatedEglFenceSync(EGLenum type,
+                                    int destroyWhenSignaled,
+                                    uint64_t* outSync = nullptr,
+                                    uint64_t* outSyncThread = nullptr);
+
     // Create a new ColorBuffer instance from this display instance.
     // |p_width| and |p_height| are its dimensions in pixels.
     // |p_internalFormat| is the OpenGL format of this color buffer.
@@ -236,6 +260,21 @@
     // virtio-gpu's RESOURCE_CREATE ioctl for BLOB resources.
     void createBufferWithHandle(uint64_t size, HandleType handle);
 
+    // Call this function when a render thread terminates to destroy all
+    // resources it created. Necessary to avoid leaking host resources
+    // when a guest application crashes, for example.
+    void drainGlRenderThreadResources();
+
+    // Call this function when a render thread terminates to destroy all
+    // the remaining contexts it created. Necessary to avoid leaking host
+    // contexts when a guest application crashes, for example.
+    void drainGlRenderThreadContexts();
+
+    // Call this function when a render thread terminates to destroy all
+    // remaining window surface it created. Necessary to avoid leaking
+    // host buffers when a guest application crashes, for example.
+    void drainGlRenderThreadSurfaces();
+
     // Increment the reference count associated with a given ColorBuffer
     // instance. |p_colorbuffer| is its handle value as returned by
     // createColorBuffer().
@@ -259,6 +298,54 @@
     // TODO(kaiyili): retire cleanupProcGLObjects in favor of removeGraphicsProcessResources.
     void cleanupProcGLObjects(uint64_t puid);
 
+    // Equivalent for eglMakeCurrent() for the current display.
+    // |p_context|, |p_drawSurface| and |p_readSurface| are the handle values
+    // of the context, the draw surface and the read surface, respectively.
+    // Returns true on success, false on failure.
+    // Note: if all handle values are 0, this is an unbind operation.
+    bool bindContext(HandleType p_context, HandleType p_drawSurface,
+                     HandleType p_readSurface);
+
+    // Return a render context pointer from its handle
+    gl::EmulatedEglContextPtr getContext_locked(HandleType p_context);
+
+    // Return a color buffer pointer from its handle
+    gl::EmulatedEglWindowSurfacePtr getWindowSurface_locked(HandleType p_windowsurface);
+
+    // Attach a ColorBuffer to a EmulatedEglWindowSurface instance.
+    // See the documentation for EmulatedEglWindowSurface::setColorBuffer().
+    // |p_surface| is the target EmulatedEglWindowSurface's handle value.
+    // |p_colorbuffer| is the ColorBuffer handle value.
+    // Returns true on success, false otherwise.
+    bool setEmulatedEglWindowSurfaceColorBuffer(HandleType p_surface,
+                                                HandleType p_colorbuffer);
+
+    // Copy the content of a EmulatedEglWindowSurface's Pbuffer to its attached
+    // ColorBuffer. See the documentation for
+    // EmulatedEglWindowSurface::flushColorBuffer().
+    // |p_surface| is the target WindowSurface's handle value.
+    // Returns true on success, false on failure.
+    bool flushEmulatedEglWindowSurfaceColorBuffer(HandleType p_surface);
+
+    // Retrieves the color buffer handle associated with |p_surface|.
+    // Returns 0 if there is no such handle.
+    HandleType getEmulatedEglWindowSurfaceColorBufferHandle(HandleType p_surface);
+
+    // Bind the current context's EGL_TEXTURE_2D texture to a ColorBuffer
+    // instance's EGLImage. This is intended to implement
+    // glEGLImageTargetTexture2DOES() for all GLES versions.
+    // |p_colorbuffer| is the ColorBuffer's handle value.
+    // Returns true on success, false on failure.
+    bool bindColorBufferToTexture(HandleType p_colorbuffer);
+    bool bindColorBufferToTexture2(HandleType p_colorbuffer);
+
+    // Bind the current context's EGL_RENDERBUFFER_OES render buffer to this
+    // ColorBuffer's EGLImage. This is intended to implement
+    // glEGLImageTargetRenderbufferStorageOES() for all GLES versions.
+    // |p_colorbuffer| is the ColorBuffer's handle value.
+    // Returns true on success, false on failure.
+    bool bindColorBufferToRenderbuffer(HandleType p_colorbuffer);
+
     // Read the content of a given Buffer into client memory.
     // |p_buffer| is the Buffer's handle value.
     // |offset| and |size| are the position and size of a slice of the buffer
@@ -290,6 +377,17 @@
     void readColorBufferYUV(HandleType p_colorbuffer, int x, int y, int width,
                             int height, void* pixels, uint32_t pixels_size);
 
+    // create a Y texture and a UV texture with width and height, the created
+    // texture ids are stored in textures respectively
+    void createYUVTextures(uint32_t type, uint32_t count, int width, int height,
+                           uint32_t* output);
+    void destroyYUVTextures(uint32_t type, uint32_t count, uint32_t* textures);
+    void updateYUVTextures(uint32_t type, uint32_t* textures, void* privData,
+                           void* func);
+    void swapTexturesAndUpdateColorBuffer(uint32_t colorbufferhandle, int x, int y, int width,
+                                          int height, uint32_t format, uint32_t type,
+                                          uint32_t texture_type, uint32_t* textures);
+
     // Update the content of a given Buffer from client data.
     // |p_buffer| is the Buffer's handle value.
     // |offset| and |size| are the position and size of a slice of the buffer
@@ -317,6 +415,17 @@
                                               int height, FrameworkFormat fwkFormat, GLenum format,
                                               GLenum type, void* pixels, void* metadata = nullptr);
 
+    // Reads back the raw color buffer to |pixels|
+    // if |pixels| is not null.
+    // Always returns in |numBytes| how many bytes were
+    // planned to be transmitted.
+    // |numBytes| is not an input parameter;
+    // fewer or more bytes cannot be specified.
+    // If the framework format is YUV, it will read
+    // back as raw YUV data.
+    bool readColorBufferContents(HandleType p_colorbuffer, size_t* numBytes,
+                                 void* pixels);
+
     bool getColorBufferInfo(HandleType p_colorbuffer, int* width, int* height,
                             GLint* internalformat,
                             FrameworkFormat* frameworkFormat = nullptr);
@@ -352,6 +461,16 @@
     // be re-displayed for any reason.
     bool repost(bool needLockAndBind = true);
 
+    gl::EmulationGl& getEmulationGl();
+    bool hasEmulationGl() const { return m_emulationGl != nullptr; }
+
+    // Return the host EGLDisplay used by this instance.
+    EGLDisplay getDisplay() const;
+    EGLSurface getWindowSurface() const;
+    EGLContext getContext() const;
+    EGLConfig getConfig() const;
+    ContextHelper* getPbufferSurfaceContextHelper() const;
+
     // Change the rotation of the displayed GPU sub-window.
     void setDisplayRotation(float zRot) {
         if (zRot != m_zRot) {
@@ -377,6 +496,19 @@
         }
     }
 
+    // Return a TextureDraw instance that can be used with this surfaces
+    // and windows created by this instance.
+    gl::TextureDraw* getTextureDraw() const;
+
+    // Create an eglImage and return its handle.  Reference:
+    // https://www.khronos.org/registry/egl/extensions/KHR/EGL_KHR_image_base.txt
+    HandleType createEmulatedEglImage(HandleType context, EGLenum target,
+                                      GLuint buffer);
+    // Call the implementation of eglDestroyImageKHR, return if succeeds or
+    // not. Reference:
+    // https://www.khronos.org/registry/egl/extensions/KHR/EGL_KHR_image_base.txt
+    EGLBoolean destroyEmulatedEglImage(HandleType image);
+
     void lockContextStructureRead() { m_contextStructureLock.lockRead(); }
     void unlockContextStructureRead() { m_contextStructureLock.unlockRead(); }
 
@@ -385,7 +517,12 @@
     // GL state.
     // It can be unsafe / leaky to change the structure of contexts
     // outside the facilities the FrameBuffer class provides.
-    void createTrivialContext(HandleType shared, HandleType* contextOut, HandleType* surfOut);
+    void createTrivialContext(HandleType shared, HandleType* contextOut,
+                              HandleType* surfOut);
+    // createTrivialContext(), but with a m_pbufContext
+    // as shared, and not adding itself to the context map at all.
+    void createSharedTrivialContext(EGLContext* contextOut, EGLSurface* surfOut);
+    void destroySharedTrivialContext(EGLContext context, EGLSurface surf);
 
     void setShuttingDown() { m_shuttingDown = true; }
     bool isShuttingDown() const { return m_shuttingDown; }
@@ -406,6 +543,8 @@
     void lock();
     void unlock();
 
+    gl::GLESDispatchMaxVersion getMaxGLESVersion();
+
     float getDpr() const { return m_dpr; }
     int windowWidth() const { return m_windowWidth; }
     int windowHeight() const { return m_windowHeight; }
@@ -413,9 +552,15 @@
     float getPy() const { return m_py; }
     int getZrot() const { return m_zRot; }
 
+    bool isFastBlitSupported() const;
+    void disableFastBlitForTesting();
+
     bool isVulkanInteropSupported() const { return m_vulkanInteropSupported; }
     bool isVulkanEnabled() const { return m_vulkanEnabled; }
 
+    // Fill GLES usage protobuf
+    void fillGLESUsages(android_studio::EmulatorGLESUsages*);
+
     // Saves a screenshot of the previous frame.
     // nChannels should be 3 (RGB) or 4 (RGBA).
     // You must provide a pre-allocated buffer of sufficient
@@ -477,13 +622,18 @@
     static const uint32_t s_invalidIdMultiDisplay = 0xFFFFFFAB;
     static const uint32_t s_maxNumMultiDisplay = 11;
 
+    EGLContext getGlobalEGLContext() const;
     HandleType getLastPostedColorBuffer() { return m_lastPostedColorBuffer; }
+    void waitForGpu(uint64_t eglsync);
     void waitForGpuVulkan(uint64_t deviceHandle, uint64_t fenceHandle);
+    void asyncWaitForGpuWithCb(uint64_t eglsync, FenceCompletionCallback cb);
     void asyncWaitForGpuVulkanWithCb(uint64_t deviceHandle, uint64_t fenceHandle, FenceCompletionCallback cb);
     void asyncWaitForGpuVulkanQsriWithCb(uint64_t image, FenceCompletionCallback cb);
     void waitForGpuVulkanQsri(uint64_t image);
 
     bool platformImportResource(uint32_t handle, uint32_t info, void* resource);
+    void* platformCreateSharedEglContext(void);
+    bool platformDestroySharedEglContext(void* context);
 
     void setGuestManagedColorBufferLifetime(bool guestManaged);
 
@@ -508,182 +658,14 @@
     const int getDisplayConfigsParam(int configId, EGLint param);
     const int getDisplayActiveConfig();
 
-    bool flushColorBufferFromVk(HandleType colorBufferHandle);
-    bool flushColorBufferFromVkBytes(HandleType colorBufferHandle, const void* bytes,
-                                     size_t bytesSize);
-    bool invalidateColorBufferForVk(HandleType colorBufferHandle);
-
-#if GFXSTREAM_ENABLE_HOST_GLES
-    // Retrieves the color buffer handle associated with |p_surface|.
-    // Returns 0 if there is no such handle.
-    HandleType getEmulatedEglWindowSurfaceColorBufferHandle(HandleType p_surface);
-
-    // createTrivialContext(), but with a m_pbufContext
-    // as shared, and not adding itself to the context map at all.
-    void createSharedTrivialContext(EGLContext* contextOut, EGLSurface* surfOut);
-    void destroySharedTrivialContext(EGLContext context, EGLSurface surf);
-
-    // Attach a ColorBuffer to a EmulatedEglWindowSurface instance.
-    // See the documentation for EmulatedEglWindowSurface::setColorBuffer().
-    // |p_surface| is the target EmulatedEglWindowSurface's handle value.
-    // |p_colorbuffer| is the ColorBuffer handle value.
-    // Returns true on success, false otherwise.
-
-    bool setEmulatedEglWindowSurfaceColorBuffer(HandleType p_surface, HandleType p_colorbuffer);
-    // Return the list of configs available from this display.
-    const gl::EmulatedEglConfigList* getConfigs() const;
-
-    // Retrieve the GL strings of the underlying EGL/GLES implementation.
-    // On return, |*vendor|, |*renderer| and |*version| will point to strings
-    // that are owned by the instance (and must not be freed by the caller).
-    void getGLStrings(const char** vendor, const char** renderer, const char** version) const {
-        *vendor = m_graphicsAdapterVendor.c_str();
-        *renderer = m_graphicsAdapterName.c_str();
-        *version = m_graphicsApiVersion.c_str();
-    }
-
-    // Create a new EmulatedEglContext instance for this display instance.
-    // |p_config| is the index of one of the configs returned by getConfigs().
-    // |p_share| is either EGL_NO_CONTEXT or the handle of a shared context.
-    // |version| specifies the GLES version as a GLESApi enum.
-    // Return a new handle value, which will be 0 in case of error.
-    HandleType createEmulatedEglContext(int p_config, HandleType p_share,
-                                        gl::GLESApi version = gl::GLESApi_CM);
-
-    // Destroy a given EmulatedEglContext instance. |p_context| is its handle
-    // value as returned by createEmulatedEglContext().
-    void destroyEmulatedEglContext(HandleType p_context);
-
-    // Create a new EmulatedEglWindowSurface instance from this display instance.
-    // |p_config| is the index of one of the configs returned by getConfigs().
-    // |p_width| and |p_height| are the window dimensions in pixels.
-    // Return a new handle value, or 0 in case of error.
-    HandleType createEmulatedEglWindowSurface(int p_config, int p_width, int p_height);
-
-    // Destroy a given EmulatedEglWindowSurface instance. |p_surcace| is its
-    // handle value as returned by createEmulatedEglWindowSurface().
-    void destroyEmulatedEglWindowSurface(HandleType p_surface);
-
-    // Returns the set of ColorBuffers destroyed (for further cleanup)
-    std::vector<HandleType> destroyEmulatedEglWindowSurfaceLocked(HandleType p_surface);
-
-    void createEmulatedEglFenceSync(EGLenum type, int destroyWhenSignaled,
-                                    uint64_t* outSync = nullptr, uint64_t* outSyncThread = nullptr);
-
-    // Call this function when a render thread terminates to destroy all
-    // resources it created. Necessary to avoid leaking host resources
-    // when a guest application crashes, for example.
-    void drainGlRenderThreadResources();
-
-    // Call this function when a render thread terminates to destroy all
-    // the remaining contexts it created. Necessary to avoid leaking host
-    // contexts when a guest application crashes, for example.
-    void drainGlRenderThreadContexts();
-
-    // Call this function when a render thread terminates to destroy all
-    // remaining window surface it created. Necessary to avoid leaking
-    // host buffers when a guest application crashes, for example.
-    void drainGlRenderThreadSurfaces();
-
-    gl::EmulationGl& getEmulationGl();
-    bool hasEmulationGl() const { return m_emulationGl != nullptr; }
-
-    // Return the host EGLDisplay used by this instance.
-    EGLDisplay getDisplay() const;
-    EGLSurface getWindowSurface() const;
-    EGLContext getContext() const;
-    EGLConfig getConfig() const;
-
-    EGLContext getGlobalEGLContext() const;
-
-    // Return a render context pointer from its handle
-    gl::EmulatedEglContextPtr getContext_locked(HandleType p_context);
-
-    // Return a color buffer pointer from its handle
-    gl::EmulatedEglWindowSurfacePtr getWindowSurface_locked(HandleType p_windowsurface);
-
-    // Return a TextureDraw instance that can be used with this surfaces
-    // and windows created by this instance.
-    gl::TextureDraw* getTextureDraw() const;
-
-    bool isFastBlitSupported() const;
-    void disableFastBlitForTesting();
-
-    // Create an eglImage and return its handle.  Reference:
-    // https://www.khronos.org/registry/egl/extensions/KHR/EGL_KHR_image_base.txt
-    HandleType createEmulatedEglImage(HandleType context, EGLenum target, GLuint buffer);
-    // Call the implementation of eglDestroyImageKHR, return if succeeds or
-    // not. Reference:
-    // https://www.khronos.org/registry/egl/extensions/KHR/EGL_KHR_image_base.txt
-    EGLBoolean destroyEmulatedEglImage(HandleType image);
-    // Copy the content of a EmulatedEglWindowSurface's Pbuffer to its attached
-    // ColorBuffer. See the documentation for
-    // EmulatedEglWindowSurface::flushColorBuffer().
-    // |p_surface| is the target WindowSurface's handle value.
-    // Returns true on success, false on failure.
-    bool flushEmulatedEglWindowSurfaceColorBuffer(HandleType p_surface);
-
-    gl::GLESDispatchMaxVersion getMaxGLESVersion();
-
-    // Fill GLES usage protobuf
-    void fillGLESUsages(android_studio::EmulatorGLESUsages*);
-
-    void* platformCreateSharedEglContext(void);
-    bool platformDestroySharedEglContext(void* context);
-
     bool flushColorBufferFromGl(HandleType colorBufferHandle);
-
+    bool flushColorBufferFromVk(HandleType colorBufferHandle);
+    bool flushColorBufferFromVkBytes(HandleType colorBufferHandle, const void* bytes, size_t bytesSize);
     bool invalidateColorBufferForGl(HandleType colorBufferHandle);
-
-    ContextHelper* getPbufferSurfaceContextHelper() const;
-
-    // Bind the current context's EGL_TEXTURE_2D texture to a ColorBuffer
-    // instance's EGLImage. This is intended to implement
-    // glEGLImageTargetTexture2DOES() for all GLES versions.
-    // |p_colorbuffer| is the ColorBuffer's handle value.
-    // Returns true on success, false on failure.
-    bool bindColorBufferToTexture(HandleType p_colorbuffer);
-    bool bindColorBufferToTexture2(HandleType p_colorbuffer);
-
-    // Bind the current context's EGL_RENDERBUFFER_OES render buffer to this
-    // ColorBuffer's EGLImage. This is intended to implement
-    // glEGLImageTargetRenderbufferStorageOES() for all GLES versions.
-    // |p_colorbuffer| is the ColorBuffer's handle value.
-    // Returns true on success, false on failure.
-    bool bindColorBufferToRenderbuffer(HandleType p_colorbuffer);
-
-    // Equivalent for eglMakeCurrent() for the current display.
-    // |p_context|, |p_drawSurface| and |p_readSurface| are the handle values
-    // of the context, the draw surface and the read surface, respectively.
-    // Returns true on success, false on failure.
-    // Note: if all handle values are 0, this is an unbind operation.
-    bool bindContext(HandleType p_context, HandleType p_drawSurface, HandleType p_readSurface);
-
-    // create a Y texture and a UV texture with width and height, the created
-    // texture ids are stored in textures respectively
-    void createYUVTextures(uint32_t type, uint32_t count, int width, int height, uint32_t* output);
-    void destroyYUVTextures(uint32_t type, uint32_t count, uint32_t* textures);
-    void updateYUVTextures(uint32_t type, uint32_t* textures, void* privData, void* func);
-    void swapTexturesAndUpdateColorBuffer(uint32_t colorbufferhandle, int x, int y, int width,
-                                          int height, uint32_t format, uint32_t type,
-                                          uint32_t texture_type, uint32_t* textures);
-
-    // Reads back the raw color buffer to |pixels|
-    // if |pixels| is not null.
-    // Always returns in |numBytes| how many bytes were
-    // planned to be transmitted.
-    // |numBytes| is not an input parameter;
-    // fewer or more bytes cannot be specified.
-    // If the framework format is YUV, it will read
-    // back as raw YUV data.
-    bool readColorBufferContents(HandleType p_colorbuffer, size_t* numBytes, void* pixels);
-
-    void waitForGpu(uint64_t eglsync);
-    void asyncWaitForGpuWithCb(uint64_t eglsync, FenceCompletionCallback cb);
+    bool invalidateColorBufferForVk(HandleType colorBufferHandle);
 
     const gl::EGLDispatch* getEglDispatch();
     const gl::GLESv2Dispatch* getGles2Dispatch();
-#endif
 
    private:
     FrameBuffer(int p_width, int p_height, bool useSubWindow);
@@ -756,9 +738,12 @@
     android::base::Lock m_colorBufferMapLock;
     uint64_t mFrameNumber;
     FBNativeWindowType m_nativeWindow = 0;
-
+    gl::EmulatedEglContextMap m_contexts;
+    gl::EmulatedEglImageMap m_images;
+    gl::EmulatedEglWindowSurfaceMap m_windows;
     ColorBufferMap m_colorbuffers;
     BufferMap m_buffers;
+    std::unordered_map<HandleType, HandleType> m_EmulatedEglWindowSurfaceToColorBuffer;
 
     // A collection of color buffers that were closed without any usages
     // (|opened| == false).
@@ -828,6 +813,15 @@
     std::string m_graphicsApiVersion;
     std::string m_graphicsApiExtensions;
     std::string m_graphicsDeviceExtensions;
+
+    // The host associates color buffers with guest processes for memory
+    // cleanup. Guest processes are identified with a host generated unique ID.
+    // TODO(kaiyili): move all those resources to the ProcessResources struct.
+    ProcOwnedColorBuffers m_procOwnedColorBuffers;
+    ProcOwnedEmulatedEGLImages m_procOwnedEmulatedEglImages;
+    ProcOwnedEmulatedEglContexts m_procOwnedEmulatedEglContexts;
+    ProcOwnedEmulatedEglWindowSurfaces m_procOwnedEmulatedEglWindowSurfaces;
+    ProcOwnedCleanupCallbacks m_procOwnedCleanupCallbacks;
     std::unordered_map<uint64_t, std::unique_ptr<ProcessResources>> m_procOwnedResources;
 
     // Flag set when emulator is shutting down.
@@ -863,6 +857,9 @@
     android::base::MessageChannel<HandleType, 1024>
         mOutstandingColorBufferDestroys;
 
+    std::unique_ptr<gl::EmulationGl> m_emulationGl;
+    gl::DisplayGl* m_displayGl = nullptr;
+
     Compositor* m_compositor = nullptr;
     bool m_useVulkanComposition = false;
 
@@ -886,9 +883,15 @@
     // cases, this determines whether we can support zero-copy interop.
     using VkUuid = std::array<uint8_t, VK_UUID_SIZE>;
     VkUuid m_vulkanUUID{};
+    static_assert(VK_UUID_SIZE == GL_UUID_SIZE_EXT);
 
     // Tracks platform EGL contexts that have been handed out to other users,
     // indexed by underlying native EGL context object.
+    struct PlatformEglContextInfo {
+        EGLContext context;
+        EGLSurface surface;
+    };
+    std::unordered_map<void*, PlatformEglContextInfo> m_platformEglContexts;
 
     std::unique_ptr<MetricsLogger> m_logger;
     std::unique_ptr<HealthMonitor<>> m_healthMonitor;
@@ -909,34 +912,6 @@
     };
     std::map<int, DisplayConfig> mDisplayConfigs;
     int mDisplayActiveConfigId = -1;
-
-    std::unique_ptr<gl::EmulationGl> m_emulationGl;
-
-    // The host associates color buffers with guest processes for memory
-    // cleanup. Guest processes are identified with a host generated unique ID.
-    // TODO(kaiyili): move all those resources to the ProcessResources struct.
-    ProcOwnedColorBuffers m_procOwnedColorBuffers;
-    ProcOwnedCleanupCallbacks m_procOwnedCleanupCallbacks;
-
-#if GFXSTREAM_ENABLE_HOST_GLES
-    gl::EmulatedEglContextMap m_contexts;
-    gl::EmulatedEglImageMap m_images;
-    gl::EmulatedEglWindowSurfaceMap m_windows;
-
-    std::unordered_map<HandleType, HandleType> m_EmulatedEglWindowSurfaceToColorBuffer;
-
-    ProcOwnedEmulatedEGLImages m_procOwnedEmulatedEglImages;
-    ProcOwnedEmulatedEglContexts m_procOwnedEmulatedEglContexts;
-    ProcOwnedEmulatedEglWindowSurfaces m_procOwnedEmulatedEglWindowSurfaces;
-    gl::DisplayGl* m_displayGl = nullptr;
-
-    struct PlatformEglContextInfo {
-        EGLContext context;
-        EGLSurface surface;
-    };
-
-    std::unordered_map<void*, PlatformEglContextInfo> m_platformEglContexts;
-#endif
 };
 
 }  // namespace gfxstream
diff --git a/host/GlesCompat.h b/host/GlesCompat.h
deleted file mode 100644
index 3c57028..0000000
--- a/host/GlesCompat.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2024 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.
-
-#ifndef GLES_COMPAT_H
-#define GLES_COMPAT_H
-
-#include <cstdint>
-
-typedef unsigned int GLenum;
-typedef int32_t EGLint;
-// typedef void *EGLNativeDisplayType;
-typedef unsigned int EGLNativeWindowType;
-
-namespace gfxstream {
-namespace gl {
-class EmulationGl {
-   public:
-    EmulationGl() {}
-    ~EmulationGl() {}
-
-   private:
-    uint32_t payload;
-};
-}  // namespace gl
-}  // namespace gfxstream
-
-#endif
diff --git a/host/NativeSubWindow.h b/host/NativeSubWindow.h
index aff117c..07dec0e 100644
--- a/host/NativeSubWindow.h
+++ b/host/NativeSubWindow.h
@@ -18,11 +18,7 @@
 
 #include "render-utils/render_api_platform_types.h"
 
-#if GFXSTREAM_ENABLE_HOST_GLES
 #include <EGL/egl.h>
-#else
-#include "GlesCompat.h"
-#endif
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/host/NativeSubWindow_stub.cpp b/host/NativeSubWindow_stub.cpp
deleted file mode 100644
index 75a1ea8..0000000
--- a/host/NativeSubWindow_stub.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 2024 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.
- */
-
-#include "GlesCompat.h"
-#include "NativeSubWindow.h"
-
-EGLNativeWindowType createSubWindow(FBNativeWindowType p_window, int x, int y, int width,
-                                    int height, float dpr,
-                                    SubWindowRepaintCallback repaint_callback,
-                                    void* repaint_callback_param, int hideWindow) {
-    return 0;
-}
-
-void destroySubWindow(EGLNativeWindowType win) { return; }
-
-int moveSubWindow(FBNativeWindowType p_parent_window, EGLNativeWindowType p_sub_window, int x,
-                  int y, int width, int height) {
-    return 0;
-}
diff --git a/host/RenderControl.cpp b/host/RenderControl.cpp
index 698914c..2c84d45 100644
--- a/host/RenderControl.cpp
+++ b/host/RenderControl.cpp
@@ -1636,4 +1636,4 @@
     dec->rcGetHostExtensionsString = rcGetHostExtensionsString;
 }
 
-}  // namespace gfxstream
+}  // namespace gfxstream
\ No newline at end of file
diff --git a/host/RenderLibImpl.cpp b/host/RenderLibImpl.cpp
index 8f695e6..cd1dffe 100644
--- a/host/RenderLibImpl.cpp
+++ b/host/RenderLibImpl.cpp
@@ -14,6 +14,8 @@
 #include "RenderLibImpl.h"
 
 #include "FrameBuffer.h"
+#include "OpenGLESDispatch/EGLDispatch.h"
+#include "OpenGLESDispatch/DispatchTables.h"
 #include "RendererImpl.h"
 #include "aemu/base/files/Stream.h"
 #include "host-common/address_space_device_control_ops.h"
@@ -25,11 +27,6 @@
 #include "host-common/opengl/misc.h"
 #include "host-common/sync_device.h"
 
-#if GFXSTREAM_ENABLE_HOST_GLES
-#include "OpenGLESDispatch/DispatchTables.h"
-#include "OpenGLESDispatch/EGLDispatch.h"
-#endif
-
 namespace gfxstream {
 
 void RenderLibImpl::setRenderer(SelectedRenderer renderer) {
@@ -114,11 +111,10 @@
         return false;
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     opt->display = fb->getDisplay();
     opt->surface = fb->getWindowSurface();
     opt->config = fb->getConfig();
-#endif
+
     return (opt->display && opt->surface  && opt->config);
 }
 
diff --git a/host/RenderThread.cpp b/host/RenderThread.cpp
index d1d34ea..abe4fcc 100644
--- a/host/RenderThread.cpp
+++ b/host/RenderThread.cpp
@@ -19,24 +19,21 @@
 #include "FrameBuffer.h"
 #include "ReadBuffer.h"
 #include "RenderChannelImpl.h"
+#include "RenderControl.h"
 #include "RenderThreadInfo.h"
 #include "RingStream.h"
 #include "VkDecoderContext.h"
+#include "apigen-codec-common/ChecksumCalculatorThreadInfo.h"
 #include "aemu/base/HealthMonitor.h"
-#include "aemu/base/Metrics.h"
-#include "aemu/base/files/StreamSerializing.h"
 #include "aemu/base/synchronization/Lock.h"
 #include "aemu/base/synchronization/MessageChannel.h"
+#include "aemu/base/Metrics.h"
+#include "aemu/base/files/StreamSerializing.h"
 #include "aemu/base/system/System.h"
-#include "apigen-codec-common/ChecksumCalculatorThreadInfo.h"
 #include "host-common/feature_control.h"
 #include "host-common/logging.h"
 #include "vulkan/VkCommonOperations.h"
 
-#if GFXSTREAM_ENABLE_HOST_GLES
-#include "RenderControl.h"
-#endif
-
 #define EMUGL_DEBUG_LEVEL 0
 #include "host-common/debug.h"
 
@@ -273,13 +270,12 @@
 
     //
     // initialize decoders
-#if GFXSTREAM_ENABLE_HOST_GLES
+    //
     if (!feature_is_enabled(kFeature_GuestUsesAngle)) {
         tInfo.initGl();
     }
 
     initRenderControlContext(&tInfo.m_rcDec);
-#endif
 
     if (!mChannel && !mRingStream) {
         GL_LOG("Exited a loader RenderThread @%p", this);
@@ -527,7 +523,6 @@
                 FrameBuffer::getFB()->lockContextStructureRead();
             }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
             if (tInfo.m_glInfo) {
                 {
                     last = tInfo.m_glInfo->m_glDec.decode(
@@ -552,14 +547,12 @@
                     }
                 }
             }
-#endif
 
             FrameBuffer::getFB()->unlockContextStructureRead();
             //
             // try to process some of the command buffer using the
             // renderControl decoder
             //
-#if GFXSTREAM_ENABLE_HOST_GLES
             {
                 last = tInfo.m_rcDec.decode(readBuf.buf(), readBuf.validData(),
                                             ioStream, &checksumCalc);
@@ -568,7 +561,6 @@
                     progress = true;
                 }
             }
-#endif
 
             //
             // try to process some of the command buffer using the Magma
@@ -597,11 +589,9 @@
         fclose(dumpFP);
     }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (tInfo.m_glInfo) {
         FrameBuffer::getFB()->drainGlRenderThreadResources();
     }
-#endif
 
     setFinished();
 
diff --git a/host/RenderThreadInfo.cpp b/host/RenderThreadInfo.cpp
index b3cab71..fdbbfc8 100644
--- a/host/RenderThreadInfo.cpp
+++ b/host/RenderThreadInfo.cpp
@@ -61,21 +61,16 @@
     }
 }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
 void RenderThreadInfo::initGl() {
     m_glInfo.emplace();
 }
-#endif
 
 void RenderThreadInfo::onSave(Stream* stream) {
     // TODO(b/309858017): remove if when ready to bump snapshot version
     if (feature_is_enabled(kFeature_VulkanSnapshots)) {
         stream->putBe64(m_puid);
     }
-
-#if GFXSTREAM_ENABLE_HOST_GLES
     m_glInfo->onSave(stream);
-#endif
 }
 
 bool RenderThreadInfo::onLoad(Stream* stream) {
@@ -83,19 +78,11 @@
     if (feature_is_enabled(kFeature_VulkanSnapshots)) {
         m_puid = stream->getBe64();
     }
-
-#if GFXSTREAM_ENABLE_HOST_GLES
     return m_glInfo->onLoad(stream);
-#else
-    // Functions only work with GLES for now.
-    return false;
-#endif
 }
 
 void RenderThreadInfo::postLoadRefreshCurrentContextSurfacePtrs() {
-#if GFXSTREAM_ENABLE_HOST_GLES
     return m_glInfo->postLoadRefreshCurrentContextSurfacePtrs();
-#endif
 }
 
 }  // namespace gfxstream
diff --git a/host/RenderThreadInfo.h b/host/RenderThreadInfo.h
index 5e20d8a..636421e 100644
--- a/host/RenderThreadInfo.h
+++ b/host/RenderThreadInfo.h
@@ -21,12 +21,8 @@
 #include <unordered_set>
 
 #include "aemu/base/files/Stream.h"
-
-#if GFXSTREAM_ENABLE_HOST_GLES
 #include "renderControl_dec/renderControl_dec.h"
 #include "RenderThreadInfoGl.h"
-#endif
-
 #include "RenderThreadInfoVk.h"
 
 #if GFXSTREAM_ENABLE_HOST_MAGMA
@@ -51,19 +47,15 @@
     // Loop over all active render thread infos
     static void forAllRenderThreadInfos(std::function<void(RenderThreadInfo*)>);
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     void initGl();
-#endif
+
+    renderControl_decoder_context_t m_rcDec;
 
     // The unique id of owner guest process of this render thread
     uint64_t                        m_puid = 0;
     std::optional<std::string>      m_processName;
 
-#if GFXSTREAM_ENABLE_HOST_GLES
-    renderControl_decoder_context_t m_rcDec;
     std::optional<gl::RenderThreadInfoGl> m_glInfo;
-#endif
-
     std::optional<vk::RenderThreadInfoVk> m_vkInfo;
 
 #if GFXSTREAM_ENABLE_HOST_MAGMA
diff --git a/host/RenderWindow.cpp b/host/RenderWindow.cpp
index ace6114..58c374e 100644
--- a/host/RenderWindow.cpp
+++ b/host/RenderWindow.cpp
@@ -498,16 +498,11 @@
         D("No framebuffer!\n");
         return false;
     }
-
-#if GFXSTREAM_ENABLE_HOST_GLES
     fb->getGLStrings(vendor, renderer, version);
     D("Exiting vendor=[%s] renderer=[%s] version=[%s]\n",
       *vendor, *renderer, *version);
 
     return true;
-#else
-    return false;
-#endif
 }
 
 void RenderWindow::setPostCallback(Renderer::OnPostCallback onPost, void* onPostContext,
@@ -615,11 +610,11 @@
 
 void RenderWindow::setScreenMask(int width, int height, const unsigned char* rgbaData) {
     if (FrameBuffer* fb = FrameBuffer::getFB()) {
-#if GFXSTREAM_ENABLE_HOST_GLES
         if (fb->hasEmulationGl()) {
             fb->getTextureDraw()->setScreenMask(width, height, rgbaData);
+        } else {
+            ERR("RenderWindow::setScreenMask() not supported without GL emulation.");
         }
-#endif
     }
 }
 
@@ -695,4 +690,4 @@
     }
 }
 
-}  // namespace gfxstream
+}  // namespace gfxstream
\ No newline at end of file
diff --git a/host/RendererImpl.cpp b/host/RendererImpl.cpp
index 33972b4..c1fb7dd 100644
--- a/host/RendererImpl.cpp
+++ b/host/RendererImpl.cpp
@@ -24,13 +24,10 @@
 #include "RenderThread.h"
 #include "aemu/base/system/System.h"
 #include "aemu/base/threads/WorkerThread.h"
+#include "gl/EmulatedEglFenceSync.h"
 #include "host-common/logging.h"
 #include "snapshot/common.h"
 
-#if GFXSTREAM_ENABLE_HOST_GLES
-#include "gl/EmulatedEglFenceSync.h"
-#endif
-
 namespace gfxstream {
 
 // kUseSubwindowThread is used to determine whether the RenderWindow should use
@@ -392,18 +389,14 @@
     bool res = true;
 
     res = fb->onLoad(stream, textureLoader);
-#if GFXSTREAM_ENABLE_HOST_GLES
     gl::EmulatedEglFenceSync::onLoad(stream);
-#endif
 
     return res;
 }
 
 void RendererImpl::fillGLESUsages(android_studio::EmulatorGLESUsages* usages) {
     auto fb = FrameBuffer::getFB();
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (fb) fb->fillGLESUsages(usages);
-#endif
 }
 
 int RendererImpl::getScreenshot(unsigned int nChannels, unsigned int* width, unsigned int* height,
@@ -595,7 +588,6 @@
             FrameBuffer::getFB()->postWithCallback(handle, cb);
         },
     .repost = []() { FrameBuffer::getFB()->repost(); },
-#if GFXSTREAM_ENABLE_HOST_GLES
     .create_yuv_textures =
         [](uint32_t type, uint32_t count, int width, int height, uint32_t* output) {
             FrameBuffer::getFB()->createYUVTextures(type, count, width, height, output);
@@ -614,15 +606,12 @@
             FrameBuffer::getFB()->swapTexturesAndUpdateColorBuffer(
                 colorbufferhandle, x, y, width, height, format, type, texture_type, textures);
         },
-#endif
     .get_last_posted_color_buffer =
         []() { return FrameBuffer::getFB()->getLastPostedColorBuffer(); },
-#if GFXSTREAM_ENABLE_HOST_GLES
     .bind_color_buffer_to_texture =
         [](uint32_t handle) { FrameBuffer::getFB()->bindColorBufferToTexture2(handle); },
     .get_global_egl_context = []() { return FrameBuffer::getFB()->getGlobalEGLContext(); },
     .wait_for_gpu = [](uint64_t eglsync) { FrameBuffer::getFB()->waitForGpu(eglsync); },
-#endif
     .wait_for_gpu_vulkan =
         [](uint64_t device, uint64_t fence) {
             FrameBuffer::getFB()->waitForGpuVulkan(device, fence);
@@ -631,12 +620,10 @@
         [](bool guestManaged) {
             FrameBuffer::getFB()->setGuestManagedColorBufferLifetime(guestManaged);
         },
-#if GFXSTREAM_ENABLE_HOST_GLES
     .async_wait_for_gpu_with_cb =
         [](uint64_t eglsync, FenceCompletionCallback cb) {
             FrameBuffer::getFB()->asyncWaitForGpuWithCb(eglsync, cb);
         },
-#endif
     .async_wait_for_gpu_vulkan_with_cb =
         [](uint64_t device, uint64_t fence, FenceCompletionCallback cb) {
             FrameBuffer::getFB()->asyncWaitForGpuVulkanWithCb(device, fence, cb);
@@ -662,14 +649,12 @@
         [](uint32_t handle, int32_t* width, int32_t* height, int32_t* internal_format) {
             return FrameBuffer::getFB()->getColorBufferInfo(handle, width, height, internal_format);
         },
-#if GFXSTREAM_ENABLE_HOST_GLES
     .platform_create_shared_egl_context =
         []() { return FrameBuffer::getFB()->platformCreateSharedEglContext(); },
     .platform_destroy_shared_egl_context =
         [](void* context) {
             return FrameBuffer::getFB()->platformDestroySharedEglContext(context);
         },
-#endif
 };
 
 struct AndroidVirtioGpuOps* RendererImpl::getVirtioGpuOps() {
@@ -724,19 +709,11 @@
 }
 
 const void* RendererImpl::getEglDispatch() {
-#if GFXSTREAM_ENABLE_HOST_GLES
     return FrameBuffer::getFB()->getEglDispatch();
-#else
-    return nullptr;
-#endif
 }
 
 const void* RendererImpl::getGles2Dispatch() {
-#if GFXSTREAM_ENABLE_HOST_GLES
     return FrameBuffer::getFB()->getGles2Dispatch();
-#else
-    return nullptr;
-#endif
 }
 
 }  // namespace gfxstream
diff --git a/host/SyncThread.cpp b/host/SyncThread.cpp
index 5b1d1c1..5835387 100644
--- a/host/SyncThread.cpp
+++ b/host/SyncThread.cpp
@@ -16,10 +16,7 @@
 
 #include "SyncThread.h"
 
-#if GFXSTREAM_ENABLE_HOST_GLES
 #include "OpenGLESDispatch/OpenGLDispatchLoader.h"
-#endif
-
 #include "aemu/base/Metrics.h"
 #include "aemu/base/system/System.h"
 #include "aemu/base/threads/Thread.h"
@@ -38,11 +35,8 @@
 using android::base::EventHangMetadata;
 using emugl::ABORT_REASON_OTHER;
 using emugl::FatalError;
-
-#if GFXSTREAM_ENABLE_HOST_GLES
 using gl::EGLDispatch;
 using gl::EmulatedEglFenceSync;
-#endif
 
 #define DEBUG 0
 
@@ -118,18 +112,15 @@
       mHealthMonitor(healthMonitor) {
     this->start();
     mWorkerThreadPool.start();
-#if GFXSTREAM_ENABLE_HOST_GLES
     if (hasGl) {
         initSyncEGLContext();
     }
-#endif
 }
 
 SyncThread::~SyncThread() {
     cleanup();
 }
 
-#if GFXSTREAM_ENABLE_HOST_GLES
 void SyncThread::triggerWait(EmulatedEglFenceSync* fenceSync,
                              uint64_t timeline) {
     std::stringstream ss;
@@ -145,6 +136,20 @@
         ss.str());
 }
 
+void SyncThread::triggerWaitVk(VkFence vkFence, uint64_t timeline) {
+    std::stringstream ss;
+    ss << "triggerWaitVk vkFence=0x" << std::hex << reinterpret_cast<uintptr_t>(vkFence)
+       << " timeline=0x" << std::hex << timeline;
+    sendAsync(
+        [vkFence, timeline](WorkerId) {
+            doSyncWaitVk(vkFence, [timeline] {
+                DPRINT("vk wait done, use goldfish sync timeline inc");
+                emugl::emugl_sync_timeline_inc(timeline, kTimelineInterval);
+            });
+        },
+        ss.str());
+}
+
 void SyncThread::triggerBlockedWaitNoTimeline(EmulatedEglFenceSync* fenceSync) {
     std::stringstream ss;
     ss << "triggerBlockedWaitNoTimeline fenceSyncInfo=0x" << std::hex
@@ -166,6 +171,137 @@
         ss.str());
 }
 
+
+void SyncThread::triggerWaitVkWithCompletionCallback(VkFence vkFence, FenceCompletionCallback cb) {
+    std::stringstream ss;
+    ss << "triggerWaitVkWithCompletionCallback vkFence=0x" << std::hex
+       << reinterpret_cast<uintptr_t>(vkFence);
+    sendAsync([vkFence, cb = std::move(cb)](WorkerId) { doSyncWaitVk(vkFence, std::move(cb)); },
+              ss.str());
+}
+
+void SyncThread::triggerWaitVkQsriWithCompletionCallback(VkImage vkImage, FenceCompletionCallback cb) {
+    std::stringstream ss;
+    ss << "triggerWaitVkQsriWithCompletionCallback vkImage=0x"
+       << reinterpret_cast<uintptr_t>(vkImage);
+    sendAsync(
+        [vkImage, cb = std::move(cb)](WorkerId) {
+            auto decoder = vk::VkDecoderGlobalState::get();
+            auto res = decoder->registerQsriCallback(vkImage, cb);
+            // If registerQsriCallback does not schedule the callback, we still need to complete
+            // the task, otherwise we may hit deadlocks on tasks on the same ring.
+            if (!res.CallbackScheduledOrFired()) {
+                cb();
+            }
+        },
+        ss.str());
+}
+
+void SyncThread::triggerWaitVkQsri(VkImage vkImage, uint64_t timeline) {
+     std::stringstream ss;
+    ss << "triggerWaitVkQsri vkImage=0x" << std::hex << vkImage
+       << " timeline=0x" << std::hex << timeline;
+    sendAsync(
+        [vkImage, timeline](WorkerId) {
+            auto decoder = vk::VkDecoderGlobalState::get();
+            auto res = decoder->registerQsriCallback(vkImage, [timeline](){
+                 emugl::emugl_sync_timeline_inc(timeline, kTimelineInterval);
+            });
+            // If registerQsriCallback does not schedule the callback, we still need to complete
+            // the task, otherwise we may hit deadlocks on tasks on the same ring.
+            if (!res.CallbackScheduledOrFired()) {
+                emugl::emugl_sync_timeline_inc(timeline, kTimelineInterval);
+            }
+        },
+        ss.str());
+}
+
+void SyncThread::triggerGeneral(FenceCompletionCallback cb, std::string description) {
+    std::stringstream ss;
+    ss << "triggerGeneral: " << description;
+    sendAsync(std::bind(std::move(cb)), ss.str());
+}
+
+void SyncThread::cleanup() {
+    sendAndWaitForResult(
+        [this](WorkerId workerId) {
+            if (mHasGl) {
+                const EGLDispatch* egl = gl::LazyLoadedEGLDispatch::get();
+
+                egl->eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+
+                egl->eglDestroyContext(mDisplay, mContext[workerId]);
+                egl->eglDestroySurface(mDisplay, mSurface[workerId]);
+                mContext[workerId] = EGL_NO_CONTEXT;
+                mSurface[workerId] = EGL_NO_SURFACE;
+            }
+            return 0;
+        },
+        "cleanup");
+    DPRINT("signal");
+    mLock.lock();
+    mExiting = true;
+    mCv.signalAndUnlock(&mLock);
+    DPRINT("exit");
+    // Wait for the control thread to exit. We can't destroy the SyncThread
+    // before we wait the control thread.
+    if (!wait(nullptr)) {
+        ERR("Fail to wait the control thread of the SyncThread to exit.");
+    }
+}
+
+// Private methods below////////////////////////////////////////////////////////
+
+intptr_t SyncThread::main() {
+    DPRINT("in sync thread");
+    mLock.lock();
+    mCv.wait(&mLock, [this] { return mExiting; });
+
+    mWorkerThreadPool.done();
+    mWorkerThreadPool.join();
+    DPRINT("exited sync thread");
+    return 0;
+}
+
+int SyncThread::sendAndWaitForResult(std::function<int(WorkerId)> job, std::string description) {
+    DPRINT("sendAndWaitForResult task(%s)", description.c_str());
+    std::packaged_task<int(WorkerId)> task(std::move(job));
+    std::future<int> resFuture = task.get_future();
+    Command command = {
+        .mTask = std::move(task),
+        .mDescription = std::move(description),
+    };
+
+    mWorkerThreadPool.enqueue(std::move(command));
+    auto res = resFuture.get();
+    DPRINT("exit");
+    return res;
+}
+
+void SyncThread::sendAsync(std::function<void(WorkerId)> job, std::string description) {
+    DPRINT("send task(%s)", description.c_str());
+    mWorkerThreadPool.enqueue(Command{
+        .mTask =
+            std::packaged_task<int(WorkerId)>([job = std::move(job)](WorkerId workerId) mutable {
+                job(workerId);
+                return 0;
+            }),
+        .mDescription = std::move(description),
+    });
+    DPRINT("exit");
+}
+
+void SyncThread::doSyncThreadCmd(Command&& command, WorkerId workerId) {
+    std::unique_ptr<std::unordered_map<std::string, std::string>> syncThreadData =
+        std::make_unique<std::unordered_map<std::string, std::string>>();
+    syncThreadData->insert({{"syncthread_cmd_desc", command.mDescription}});
+    auto watchdog = WATCHDOG_BUILDER(mHealthMonitor, "SyncThread task execution")
+                        .setHangType(EventHangMetadata::HangType::kSyncThread)
+                        .setAnnotations(std::move(syncThreadData))
+                        .build();
+    command.mTask(workerId);
+}
+
 void SyncThread::initSyncEGLContext() {
     mWorkerThreadPool.broadcast([this] {
         return Command{
@@ -238,10 +374,9 @@
     DPRINT("wait on sync obj: %p", fenceSync);
     wait_result = fenceSync->wait(kDefaultTimeoutNsecs);
 
-    DPRINT(
-        "done waiting, with wait result=0x%x. "
-        "increment timeline (and signal fence)",
-        wait_result);
+    DPRINT("done waiting, with wait result=0x%x. "
+           "increment timeline (and signal fence)",
+           wait_result);
 
     if (wait_result != EGL_CONDITION_SATISFIED_KHR) {
         EGLint error = gl::s_egl.eglGetError();
@@ -286,154 +421,6 @@
     DPRINT("exit");
 }
 
-#endif
-
-void SyncThread::triggerWaitVk(VkFence vkFence, uint64_t timeline) {
-    std::stringstream ss;
-    ss << "triggerWaitVk vkFence=0x" << std::hex << reinterpret_cast<uintptr_t>(vkFence)
-       << " timeline=0x" << std::hex << timeline;
-    sendAsync(
-        [vkFence, timeline](WorkerId) {
-            doSyncWaitVk(vkFence, [timeline] {
-                DPRINT("vk wait done, use goldfish sync timeline inc");
-                emugl::emugl_sync_timeline_inc(timeline, kTimelineInterval);
-            });
-        },
-        ss.str());
-}
-
-void SyncThread::triggerWaitVkWithCompletionCallback(VkFence vkFence, FenceCompletionCallback cb) {
-    std::stringstream ss;
-    ss << "triggerWaitVkWithCompletionCallback vkFence=0x" << std::hex
-       << reinterpret_cast<uintptr_t>(vkFence);
-    sendAsync([vkFence, cb = std::move(cb)](WorkerId) { doSyncWaitVk(vkFence, std::move(cb)); },
-              ss.str());
-}
-
-void SyncThread::triggerWaitVkQsriWithCompletionCallback(VkImage vkImage, FenceCompletionCallback cb) {
-    std::stringstream ss;
-    ss << "triggerWaitVkQsriWithCompletionCallback vkImage=0x"
-       << reinterpret_cast<uintptr_t>(vkImage);
-    sendAsync(
-        [vkImage, cb = std::move(cb)](WorkerId) {
-            auto decoder = vk::VkDecoderGlobalState::get();
-            auto res = decoder->registerQsriCallback(vkImage, cb);
-            // If registerQsriCallback does not schedule the callback, we still need to complete
-            // the task, otherwise we may hit deadlocks on tasks on the same ring.
-            if (!res.CallbackScheduledOrFired()) {
-                cb();
-            }
-        },
-        ss.str());
-}
-
-void SyncThread::triggerWaitVkQsri(VkImage vkImage, uint64_t timeline) {
-     std::stringstream ss;
-    ss << "triggerWaitVkQsri vkImage=0x" << std::hex << vkImage
-       << " timeline=0x" << std::hex << timeline;
-    sendAsync(
-        [vkImage, timeline](WorkerId) {
-            auto decoder = vk::VkDecoderGlobalState::get();
-            auto res = decoder->registerQsriCallback(vkImage, [timeline](){
-                 emugl::emugl_sync_timeline_inc(timeline, kTimelineInterval);
-            });
-            // If registerQsriCallback does not schedule the callback, we still need to complete
-            // the task, otherwise we may hit deadlocks on tasks on the same ring.
-            if (!res.CallbackScheduledOrFired()) {
-                emugl::emugl_sync_timeline_inc(timeline, kTimelineInterval);
-            }
-        },
-        ss.str());
-}
-
-void SyncThread::triggerGeneral(FenceCompletionCallback cb, std::string description) {
-    std::stringstream ss;
-    ss << "triggerGeneral: " << description;
-    sendAsync(std::bind(std::move(cb)), ss.str());
-}
-
-void SyncThread::cleanup() {
-    sendAndWaitForResult(
-        [this](WorkerId workerId) {
-#if GFXSTREAM_ENABLE_HOST_GLES
-            if (mHasGl) {
-                const EGLDispatch* egl = gl::LazyLoadedEGLDispatch::get();
-
-                egl->eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-
-                egl->eglDestroyContext(mDisplay, mContext[workerId]);
-                egl->eglDestroySurface(mDisplay, mSurface[workerId]);
-                mContext[workerId] = EGL_NO_CONTEXT;
-                mSurface[workerId] = EGL_NO_SURFACE;
-            }
-#endif
-            return 0;
-        },
-        "cleanup");
-    DPRINT("signal");
-    mLock.lock();
-    mExiting = true;
-    mCv.signalAndUnlock(&mLock);
-    DPRINT("exit");
-    // Wait for the control thread to exit. We can't destroy the SyncThread
-    // before we wait the control thread.
-    if (!wait(nullptr)) {
-        ERR("Fail to wait the control thread of the SyncThread to exit.");
-    }
-}
-
-// Private methods below////////////////////////////////////////////////////////
-
-intptr_t SyncThread::main() {
-    DPRINT("in sync thread");
-    mLock.lock();
-    mCv.wait(&mLock, [this] { return mExiting; });
-
-    mWorkerThreadPool.done();
-    mWorkerThreadPool.join();
-    DPRINT("exited sync thread");
-    return 0;
-}
-
-int SyncThread::sendAndWaitForResult(std::function<int(WorkerId)> job, std::string description) {
-    DPRINT("sendAndWaitForResult task(%s)", description.c_str());
-    std::packaged_task<int(WorkerId)> task(std::move(job));
-    std::future<int> resFuture = task.get_future();
-    Command command = {
-        .mTask = std::move(task),
-        .mDescription = std::move(description),
-    };
-
-    mWorkerThreadPool.enqueue(std::move(command));
-    auto res = resFuture.get();
-    DPRINT("exit");
-    return res;
-}
-
-void SyncThread::sendAsync(std::function<void(WorkerId)> job, std::string description) {
-    DPRINT("send task(%s)", description.c_str());
-    mWorkerThreadPool.enqueue(Command{
-        .mTask =
-            std::packaged_task<int(WorkerId)>([job = std::move(job)](WorkerId workerId) mutable {
-                job(workerId);
-                return 0;
-            }),
-        .mDescription = std::move(description),
-    });
-    DPRINT("exit");
-}
-
-void SyncThread::doSyncThreadCmd(Command&& command, WorkerId workerId) {
-    std::unique_ptr<std::unordered_map<std::string, std::string>> syncThreadData =
-        std::make_unique<std::unordered_map<std::string, std::string>>();
-    syncThreadData->insert({{"syncthread_cmd_desc", command.mDescription}});
-    auto watchdog = WATCHDOG_BUILDER(mHealthMonitor, "SyncThread task execution")
-                        .setHangType(EventHangMetadata::HangType::kSyncThread)
-                        .setAnnotations(std::move(syncThreadData))
-                        .build();
-    command.mTask(workerId);
-}
-
 int SyncThread::doSyncWaitVk(VkFence vkFence, std::function<void()> onComplete) {
     DPRINT("enter");
 
@@ -473,4 +460,4 @@
 
 void SyncThread::destroy() { sGlobalSyncThread()->destroy(); }
 
-}  // namespace gfxstream
+}  // namespace gfxstream
\ No newline at end of file
diff --git a/host/SyncThread.h b/host/SyncThread.h
index 1c84301..2710222 100644
--- a/host/SyncThread.h
+++ b/host/SyncThread.h
@@ -16,26 +16,23 @@
 
 #pragma once
 
-#if GFXSTREAM_ENABLE_HOST_GLES
 #include <EGL/egl.h>
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
-#include "gl/EmulatedEglFenceSync.h"
-#endif
-
 #include <functional>
 #include <future>
 #include <string>
 #include <type_traits>
 
-#include "aemu/base/HealthMonitor.h"
-#include "aemu/base/Optional.h"
 #include "aemu/base/synchronization/ConditionVariable.h"
+#include "aemu/base/HealthMonitor.h"
 #include "aemu/base/synchronization/Lock.h"
 #include "aemu/base/synchronization/MessageChannel.h"
+#include "aemu/base/Optional.h"
 #include "aemu/base/threads/Thread.h"
 #include "aemu/base/threads/ThreadPool.h"
+#include "gl/EmulatedEglFenceSync.h"
 #include "render-utils/virtio_gpu_ops.h"
 #include "vulkan/VkDecoderGlobalState.h"
 
@@ -57,6 +54,14 @@
     SyncThread(bool hasGl, HealthMonitor<>* healthMonitor);
     ~SyncThread();
 
+    // |triggerWait|: async wait with a given EmulatedEglFenceSync object.
+    // We use the wait() method to do a eglClientWaitSyncKHR.
+    // After wait is over, the timeline will be incremented,
+    // which should signal the guest-side fence FD.
+    // This method is how the goldfish sync virtual device
+    // knows when to increment timelines / signal native fence FD's.
+    void triggerWait(gl::EmulatedEglFenceSync* fenceSync, uint64_t timeline);
+
     // |triggerWaitVk|: async wait with a given VkFence object.
     // The |vkFence| argument is a *boxed* host Vulkan handle of the fence.
     //
@@ -67,36 +72,17 @@
     // knows when to increment timelines / signal native fence FD's.
     void triggerWaitVk(VkFence vkFence, uint64_t timeline);
 
-#if GFXSTREAM_ENABLE_HOST_GLES
-    // |triggerWait|: async wait with a given EmulatedEglFenceSync object.
-    // We use the wait() method to do a eglClientWaitSyncKHR.
-    // After wait is over, the timeline will be incremented,
-    // which should signal the guest-side fence FD.
-    // This method is how the goldfish sync virtual device
-    // knows when to increment timelines / signal native fence FD's.
-    void triggerWait(gl::EmulatedEglFenceSync* fenceSync, uint64_t timeline);
-
     // for use with the virtio-gpu path; is meant to have a current context
     // while waiting.
     void triggerBlockedWaitNoTimeline(gl::EmulatedEglFenceSync* fenceSync);
+    
+    // This increments the timeline after the QSRI completes.
+    void triggerWaitVkQsri(VkImage vkImage, uint64_t timeline);
 
     // For use with virtio-gpu and async fence completion callback. This is async like triggerWait,
     // but takes a fence completion callback instead of incrementing some timeline directly.
     void triggerWaitWithCompletionCallback(gl::EmulatedEglFenceSync* fenceSync,
                                            FenceCompletionCallback);
-
-    // |initSyncContext| creates an EGL context expressly for calling
-    // eglClientWaitSyncKHR in the processing caused by |triggerWait|.
-    // This is used by the constructor only. It is non-blocking.
-    // - Triggers a |SyncThreadCmd| with op code |SYNC_THREAD_EGL_INIT|
-    void initSyncEGLContext();
-
-    void doSyncWait(gl::EmulatedEglFenceSync* fenceSync, std::function<void()> onComplete);
-#endif
-
-    // This increments the timeline after the QSRI completes.
-    void triggerWaitVkQsri(VkImage vkImage, uint64_t timeline);
-
     void triggerWaitVkWithCompletionCallback(VkFence fenceHandle, FenceCompletionCallback);
     void triggerWaitVkQsriWithCompletionCallback(VkImage image, FenceCompletionCallback);
     void triggerGeneral(FenceCompletionCallback, std::string description);
@@ -125,6 +111,12 @@
     };
     using ThreadPool = android::base::ThreadPool<Command>;
 
+    // |initSyncContext| creates an EGL context expressly for calling
+    // eglClientWaitSyncKHR in the processing caused by |triggerWait|.
+    // This is used by the constructor only. It is non-blocking.
+    // - Triggers a |SyncThreadCmd| with op code |SYNC_THREAD_EGL_INIT|
+    void initSyncEGLContext();
+
     // Thread function.
     // It keeps the workers runner until |mExiting| is set.
     virtual intptr_t main() override final;
@@ -140,17 +132,16 @@
     // |doSyncThreadCmd| execute the actual task. These run on the sync thread.
     void doSyncThreadCmd(Command&& command, ThreadPool::WorkerId);
 
+    void doSyncWait(gl::EmulatedEglFenceSync* fenceSync, std::function<void()> onComplete);
     static int doSyncWaitVk(VkFence, std::function<void()> onComplete);
 
     // EGL objects / object handles specific to
     // a sync thread.
     static const uint32_t kNumWorkerThreads = 4u;
 
-#if GFXSTREAM_ENABLE_HOST_GLES
     EGLDisplay mDisplay = EGL_NO_DISPLAY;
     EGLSurface mSurface[kNumWorkerThreads];
     EGLContext mContext[kNumWorkerThreads];
-#endif
 
     bool mExiting = false;
     android::base::Lock mLock;
diff --git a/host/meson.build b/host/meson.build
index 9a35912..1d9b4c8 100644
--- a/host/meson.build
+++ b/host/meson.build
@@ -94,14 +94,6 @@
   use_magma = host_machine.system() == 'linux'
 endif
 
-gfxstream_host_args += '-DGFXSTREAM_ENABLE_HOST_GLES=@0@'.format(use_gles ? '1' : '0')
-if use_magma
-  gfxstream_host_args += '-DUSE_MAGMA=1'
-  drm_dep = dependency('libdrm')
-else
-  gfxstream_host_args += '-DUSE_MAGMA=0'
-endif
-
 if use_magma
   gfxstream_host_args += '-DGFXSTREAM_ENABLE_HOST_GLES=1'
   drm_dep = dependency('libdrm')
@@ -155,7 +147,7 @@
 inc_gfxstream_backend = [inc_root, inc_include, inc_apigen_codec, inc_utils,
                          inc_gl_host_common, inc_host_include]
 
-link_gfxstream_backend = [lib_gl_host_common, lib_apigen_codec]
+link_gfxstream_backend = [lib_gl_host_common]
 
 files_lib_gfxstream_backend = files(
   'Buffer.cpp',
@@ -173,6 +165,7 @@
   'RenderThreadInfo.cpp',
   'RingStream.cpp',
   'SyncThread.cpp',
+  'RenderControl.cpp',
   'RenderWindow.cpp',
   'RenderLibImpl.cpp',
   'RendererImpl.cpp',
@@ -192,7 +185,6 @@
 
   files_lib_gfxstream_backend += files('PostWorkerGl.cpp')
   files_lib_gfxstream_backend += files('RenderThreadInfoGl.cpp')
-  files_lib_gfxstream_backend += files('RenderControl.cpp')
 
   inc_gfxstream_backend += [inc_gl_server, inc_gl_snapshot, inc_gles_translator]
   link_gfxstream_backend += lib_gl_server
@@ -217,13 +209,11 @@
   link_gfxstream_backend += lib_magma_server
 endif
 
-if not use_gles
-  files_lib_gfxstream_backend += files('NativeSubWindow_stub.cpp')
-elif host_machine.system() == 'darwin'
+if host_machine.system() == 'darwin'
   files_lib_gfxstream_backend += files('NativeSubWindow_cocoa.m')
 elif host_machine.system() == 'windows'
   files_lib_gfxstream_backend += files('NativeSubWindow_win32.cpp')
-elif host_machine.system() == 'linux' and use_gles
+elif host_machine.system() == 'linux'
   files_lib_gfxstream_backend += files('NativeSubWindow_x11.cpp')
 elif host_machine.system() == 'qnx'
   files_lib_gfxstream_backend += files(
diff --git a/host/renderControl_dec/renderControl_types.h b/host/renderControl_dec/renderControl_types.h
index f265e06..fb5ced9 100644
--- a/host/renderControl_dec/renderControl_types.h
+++ b/host/renderControl_dec/renderControl_types.h
@@ -18,4 +18,13 @@
 #include <EGL/egl.h>
 #include "glUtils.h"
 
+// values for 'param' argument of rcGetFBParam
+#define FB_WIDTH    1
+#define FB_HEIGHT   2
+#define FB_XDPI     3
+#define FB_YDPI     4
+#define FB_FPS      5
+#define FB_MIN_SWAP_INTERVAL 6
+#define FB_MAX_SWAP_INTERVAL 7
+
 using RenderControlByte = char;
diff --git a/host/vulkan/emulated_textures/meson.build b/host/vulkan/emulated_textures/meson.build
index d3e6f45..06f8181 100644
--- a/host/vulkan/emulated_textures/meson.build
+++ b/host/vulkan/emulated_textures/meson.build
@@ -17,6 +17,5 @@
   cpp_args: emulated_texture_args + gfxstream_host_args,
   include_directories: [inc_utils, inc_root, inc_vulkan_headers, inc_vulkan_server,
                         inc_include, inc_cereal_common, inc_stream_servers],
-  link_with: [lib_compressed_textures],
   dependencies: [aemu_base_dep, aemu_common_dep]
 )