Revert "Rootless Debug for GLES"
This reverts commit d9f0ec416aa89d8213effa8b983de974b2c667bd.
Bug: 110883880
Test: Chrome no longer crashes
Change-Id: I57d08a33a392394bd0a2cf4d7af97a3cce7ed8f5
diff --git a/libs/graphicsenv/Android.bp b/libs/graphicsenv/Android.bp
index bab87ac..4da30e9 100644
--- a/libs/graphicsenv/Android.bp
+++ b/libs/graphicsenv/Android.bp
@@ -23,7 +23,6 @@
shared_libs: [
"liblog",
- "libcutils",
],
export_include_dirs: ["include"],
diff --git a/libs/graphicsenv/GraphicsEnv.cpp b/libs/graphicsenv/GraphicsEnv.cpp
index 3328ad7..2a7d76e 100644
--- a/libs/graphicsenv/GraphicsEnv.cpp
+++ b/libs/graphicsenv/GraphicsEnv.cpp
@@ -18,12 +18,9 @@
#define LOG_TAG "GraphicsEnv"
#include <graphicsenv/GraphicsEnv.h>
-#include <sys/prctl.h>
-
#include <mutex>
#include <android/dlext.h>
-#include <cutils/properties.h>
#include <log/log.h>
// TODO(b/37049319) Get this from a header once one exists
@@ -49,14 +46,6 @@
return env;
}
-int GraphicsEnv::getCanLoadSystemLibraries() {
- if (property_get_bool("ro.debuggable", false) && prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
- // Return an integer value since this crosses library boundaries
- return 1;
- }
- return 0;
-}
-
void GraphicsEnv::setDriverPath(const std::string path) {
if (!mDriverPath.empty()) {
ALOGV("ignoring attempt to change driver path from '%s' to '%s'",
@@ -192,10 +181,4 @@
const char* android_getAngleAppPref() {
return android::GraphicsEnv::getInstance().getAngleAppPref();
}
-const char* android_getLayerPaths() {
- return android::GraphicsEnv::getInstance().getLayerPaths().c_str();
-}
-const char* android_getDebugLayers() {
- return android::GraphicsEnv::getInstance().getDebugLayers().c_str();
-}
}
diff --git a/libs/graphicsenv/include/graphicsenv/GraphicsEnv.h b/libs/graphicsenv/include/graphicsenv/GraphicsEnv.h
index 1783429..00e8fc0 100644
--- a/libs/graphicsenv/include/graphicsenv/GraphicsEnv.h
+++ b/libs/graphicsenv/include/graphicsenv/GraphicsEnv.h
@@ -29,8 +29,6 @@
public:
static GraphicsEnv& getInstance();
- int getCanLoadSystemLibraries();
-
// Set a search path for loading graphics drivers. The path is a list of
// directories separated by ':'. A directory can be contained in a zip file
// (drivers must be stored uncompressed and page aligned); such elements
@@ -87,13 +85,11 @@
* will be removed soon.
*/
extern "C" {
- android_namespace_t* android_getDriverNamespace();
- android_namespace_t* android_getAngleNamespace();
- const char* android_getAngleAppName();
- const char* android_getAngleAppPref();
- bool android_getAngleDeveloperOptIn();
- const char* android_getLayerPaths();
- const char* android_getDebugLayers();
+android_namespace_t* android_getDriverNamespace();
+android_namespace_t* android_getAngleNamespace();
+const char* android_getAngleAppName();
+const char* android_getAngleAppPref();
+bool android_getAngleDeveloperOptIn();
}
#endif // ANDROID_UI_GRAPHICS_ENV_H
diff --git a/opengl/libs/Android.bp b/opengl/libs/Android.bp
index 583aec9..fb6a221 100644
--- a/opengl/libs/Android.bp
+++ b/opengl/libs/Android.bp
@@ -140,7 +140,6 @@
"EGL/egl_cache.cpp",
"EGL/egl_display.cpp",
"EGL/egl_object.cpp",
- "EGL/egl_layers.cpp",
"EGL/egl.cpp",
"EGL/eglApi.cpp",
"EGL/egl_platform_entries.cpp",
@@ -151,11 +150,8 @@
"libvndksupport",
"android.hardware.configstore@1.0",
"android.hardware.configstore-utils",
- "libbase",
"libhidlbase",
"libhidltransport",
- "libnativebridge",
- "libnativeloader",
"libutils",
],
static_libs: [
diff --git a/opengl/libs/EGL/egl.cpp b/opengl/libs/EGL/egl.cpp
index 8870d5f..1229bc2 100644
--- a/opengl/libs/EGL/egl.cpp
+++ b/opengl/libs/EGL/egl.cpp
@@ -30,10 +30,11 @@
#include "egl_tls.h"
#include "egl_display.h"
#include "egl_object.h"
-#include "egl_layers.h"
#include "CallStack.h"
#include "Loader.h"
+typedef __eglMustCastToProperFunctionPointerType EGLFuncPointer;
+
// ----------------------------------------------------------------------------
namespace android {
// ----------------------------------------------------------------------------
@@ -195,14 +196,6 @@
cnx->dso = loader.open(cnx);
}
- // Check to see if any layers are enabled and route functions through them
- if (cnx->dso) {
- // Layers can be enabled long after the drivers have been loaded.
- // They will only be initialized once.
- LayerLoader& layer_loader(LayerLoader::getInstance());
- layer_loader.InitLayers(cnx);
- }
-
return cnx->dso ? EGL_TRUE : EGL_FALSE;
}
diff --git a/opengl/libs/EGL/egl_layers.cpp b/opengl/libs/EGL/egl_layers.cpp
deleted file mode 100644
index 6900b8b..0000000
--- a/opengl/libs/EGL/egl_layers.cpp
+++ /dev/null
@@ -1,433 +0,0 @@
-/*
- ** Copyright 2018, 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 "egl_layers.h"
-
-#include <EGL/egl.h>
-#include <android-base/file.h>
-#include <android-base/strings.h>
-#include <android/dlext.h>
-#include <cutils/properties.h>
-#include <dlfcn.h>
-#include <graphicsenv/GraphicsEnv.h>
-#include <log/log.h>
-#include <nativebridge/native_bridge.h>
-#include <nativeloader/native_loader.h>
-#include <sys/prctl.h>
-
-namespace android {
-
-// GLES Layers
-//
-// - Layer discovery -
-// 1. Check for debug layer list from GraphicsEnv
-// 2. If none enabled, check system properties
-//
-// - Layer initializing -
-// TODO: ADD DETAIL ABOUT NEW INTERFACES
-// - InitializeLayer (provided by layer, called by loader)
-// - GetLayerProcAddress (provided by layer, called by loader)
-// - getNextLayerProcAddress (provided by loader, called by layer)
-//
-// 1. Walk through defs for egl and each gl version
-// 2. Call GetLayerProcAddress passing the name and the target hook entry point
-// - This tells the layer the next point in the chain it should call
-// 3. Replace the hook with the layer's entry point
-// - All entryoints will be present, anything unsupported by the driver will
-// have gl_unimplemented
-//
-// - Extension layering -
-// Not all functions are known to Android, so libEGL handles extensions.
-// They are looked up by applications using eglGetProcAddress
-// Layers can look them up with getNextLayerProcAddress
-
-const int kFuncCount = sizeof(platform_impl_t) / sizeof(char*) + sizeof(egl_t) / sizeof(char*) +
- sizeof(gl_hooks_t) / sizeof(char*);
-
-typedef struct FunctionTable {
- EGLFuncPointer x[kFuncCount];
- EGLFuncPointer& operator[](int i) { return x[i]; }
-} FunctionTable;
-
-// TODO: Move these to class
-std::unordered_map<std::string, int> func_indices;
-// func_indices.reserve(kFuncCount);
-
-std::unordered_map<int, std::string> func_names;
-// func_names.reserve(kFuncCount);
-
-std::vector<FunctionTable> layer_functions;
-
-const void* getNextLayerProcAddress(void* layer_id, const char* name) {
- // Use layer_id to find funcs for layer below current
- // This is the same key provided in InitializeLayer
- auto next_layer_funcs = reinterpret_cast<FunctionTable*>(layer_id);
- EGLFuncPointer val;
-
- if (func_indices.find(name) == func_indices.end()) {
- // No entry for this function - it is an extension
- // call down the GPA chain directly to the impl
- ALOGV("getNextLayerProcAddress servicing %s", name);
-
- // Look up which GPA we should use
- int gpaIndex = func_indices["eglGetProcAddress"];
- EGLFuncPointer gpaNext = (*next_layer_funcs)[gpaIndex];
-
- ALOGV("Calling down the GPA chain (%llu) for %s", (unsigned long long)gpaNext, name);
-
- // Call it for the requested function
- typedef void* (*PFNEGLGETPROCADDRESSPROC)(const char*);
- PFNEGLGETPROCADDRESSPROC next = reinterpret_cast<PFNEGLGETPROCADDRESSPROC>(gpaNext);
-
- val = reinterpret_cast<EGLFuncPointer>(next(name));
- ALOGV("Got back %llu for %s", (unsigned long long)val, name);
-
- // We should store it now, but to do that, we need to move func_idx to the class so we can
- // increment it separately
- // TODO: Move func_idx to class and store the result of GPA
- return reinterpret_cast<void*>(val);
- }
-
- // int index = func_indices[name];
- // val = (*next_layer_funcs)[index];
- // return reinterpret_cast<void*>(val);
- return reinterpret_cast<void*>((*next_layer_funcs)[func_indices[name]]);
-}
-
-void SetupFuncMaps(FunctionTable& functions, char const* const* entries, EGLFuncPointer* curr,
- int& func_idx) {
- while (*entries) {
- const char* name = *entries;
-
- // Some names overlap, only fill with initial entry
- // This does mean that some indices will not be used
- if (func_indices.find(name) == func_indices.end()) {
- func_names[func_idx] = name;
- func_indices[name] = func_idx;
- }
-
- // Populate layer_functions once with initial value
- // These values will arrive in priority order, starting with platform entries
- if (functions[func_idx] == nullptr) {
- functions[func_idx] = *curr;
- }
-
- entries++;
- curr++;
- func_idx++;
- }
-}
-
-LayerLoader& LayerLoader::getInstance() {
- // This function is mutex protected in egl_init_drivers_locked and eglGetProcAddressImpl
- static LayerLoader layer_loader;
-
- if (!layer_loader.layers_loaded_) layer_loader.LoadLayers();
-
- return layer_loader;
-}
-
-const char kSystemLayerLibraryDir[] = "/data/local/debug/gles";
-
-std::string LayerLoader::GetDebugLayers() {
- // Layers can be specified at the Java level in GraphicsEnvironemnt
- // gpu_debug_layers = layer1:layer2:layerN
- std::string debug_layers = android_getDebugLayers();
-
- if (debug_layers.empty()) {
- // Only check system properties if Java settings are empty
- char prop[PROPERTY_VALUE_MAX];
- property_get("debug.gles.layers", prop, "");
- debug_layers = prop;
- }
-
- return debug_layers;
-}
-
-EGLFuncPointer LayerLoader::ApplyLayer(layer_setup_func layer_setup, const char* name,
- EGLFuncPointer next) {
- // Walk through our list of LayerSetup functions (they will already be in reverse order) to
- // build up a call chain from the driver
-
- EGLFuncPointer layer_entry = next;
-
- layer_entry = layer_setup(name, layer_entry);
-
- if (next != layer_entry) {
- ALOGV("We succeeded, replacing hook (%llu) with layer entry (%llu), for %s",
- (unsigned long long)next, (unsigned long long)layer_entry, name);
- }
-
- return layer_entry;
-}
-
-EGLFuncPointer LayerLoader::ApplyLayers(const char* name, EGLFuncPointer next) {
- if (!layers_loaded_ || layer_setup_.empty()) return next;
-
- ALOGV("ApplyLayers called for %s with next (%llu), current_layer_ (%i)", name,
- (unsigned long long)next, current_layer_);
-
- EGLFuncPointer val = next;
-
- // Only ApplyLayers for layers that have been setup, not all layers yet
- for (unsigned i = 0; i < current_layer_; i++) {
- ALOGV("ApplyLayers: Calling ApplyLayer with i = %i for %s with next (%llu)", i, name,
- (unsigned long long)next);
- val = ApplyLayer(layer_setup_[i], name, val);
- }
-
- ALOGV("ApplyLayers returning %llu for %s", (unsigned long long)val, name);
-
- return val;
-}
-
-void LayerLoader::LayerPlatformEntries(layer_setup_func layer_setup, EGLFuncPointer* curr,
- char const* const* entries) {
- while (*entries) {
- char const* name = *entries;
-
- EGLFuncPointer prev = *curr;
-
- // Pass the existing entry point into the layer, replace the call with return value
- *curr = ApplyLayer(layer_setup, name, *curr);
-
- if (prev != *curr) {
- ALOGV("LayerPlatformEntries: Replaced (%llu) with platform entry (%llu), for %s",
- (unsigned long long)prev, (unsigned long long)*curr, name);
- } else {
- ALOGV("LayerPlatformEntries: No change(%llu) for %s, which means layer did not "
- "intercept",
- (unsigned long long)prev, name);
- }
-
- curr++;
- entries++;
- }
-}
-
-void LayerLoader::LayerDriverEntries(layer_setup_func layer_setup, EGLFuncPointer* curr,
- char const* const* entries) {
- while (*entries) {
- char const* name = *entries;
- EGLFuncPointer prev = *curr;
-
- // Only apply layers to driver entries if not handled by the platform
- if (FindPlatformImplAddr(name) == nullptr) {
- // Pass the existing entry point into the layer, replace the call with return value
- *curr = ApplyLayer(layer_setup, name, *prev);
-
- if (prev != *curr) {
- ALOGV("LayerDriverEntries: Replaced (%llu) with platform entry (%llu), for %s",
- (unsigned long long)prev, (unsigned long long)*curr, name);
- }
-
- } else {
- ALOGV("LayerDriverEntries: Skipped (%llu) for %s", (unsigned long long)prev, name);
- }
-
- curr++;
- entries++;
- }
-}
-
-bool LayerLoader::Initialized() {
- return initialized_;
-}
-
-void LayerLoader::InitLayers(egl_connection_t* cnx) {
- if (!layers_loaded_) return;
-
- if (initialized_) return;
-
- if (layer_setup_.empty()) {
- initialized_ = true;
- return;
- }
-
- // Include the driver in layer_functions
- layer_functions.resize(layer_setup_.size() + 1);
-
- // Walk through the initial lists and create layer_functions[0]
- int func_idx = 0;
- char const* const* entries;
- EGLFuncPointer* curr;
-
- entries = platform_names;
- curr = reinterpret_cast<EGLFuncPointer*>(&cnx->platform);
- SetupFuncMaps(layer_functions[0], entries, curr, func_idx);
- ALOGV("InitLayers: func_idx after platform_names: %i", func_idx);
-
- entries = egl_names;
- curr = reinterpret_cast<EGLFuncPointer*>(&cnx->egl);
- SetupFuncMaps(layer_functions[0], entries, curr, func_idx);
- ALOGV("InitLayers: func_idx after egl_names: %i", func_idx);
-
- entries = gl_names;
- curr = reinterpret_cast<EGLFuncPointer*>(&cnx->hooks[egl_connection_t::GLESv2_INDEX]->gl);
- SetupFuncMaps(layer_functions[0], entries, curr, func_idx);
- ALOGV("InitLayers: func_idx after gl_names: %i", func_idx);
-
- // Walk through each layer's entry points per API, starting just above the driver
- for (current_layer_ = 0; current_layer_ < layer_setup_.size(); current_layer_++) {
- // Init the layer with a key that points to layer just below it
- layer_init_[current_layer_](reinterpret_cast<void*>(&layer_functions[current_layer_]),
- reinterpret_cast<PFNEGLGETNEXTLAYERPROCADDRESSPROC>(
- getNextLayerProcAddress));
-
- // Check functions implemented by the platform
- func_idx = 0;
- entries = platform_names;
- curr = reinterpret_cast<EGLFuncPointer*>(&cnx->platform);
- LayerPlatformEntries(layer_setup_[current_layer_], curr, entries);
-
- // Populate next function table after layers have been applied
- SetupFuncMaps(layer_functions[current_layer_ + 1], entries, curr, func_idx);
-
- // EGL
- entries = egl_names;
- curr = reinterpret_cast<EGLFuncPointer*>(&cnx->egl);
- LayerDriverEntries(layer_setup_[current_layer_], curr, entries);
-
- // Populate next function table after layers have been applied
- SetupFuncMaps(layer_functions[current_layer_ + 1], entries, curr, func_idx);
-
- // GLES 2+
- // NOTE: We route calls to GLESv2 hooks, not GLESv1, so layering does not support GLES 1.x
- // If it were added in the future, a different layer initialization model would be needed,
- // that defers loading GLES entrypoints until after eglMakeCurrent, so two phase
- // initialization.
- entries = gl_names;
- curr = reinterpret_cast<EGLFuncPointer*>(&cnx->hooks[egl_connection_t::GLESv2_INDEX]->gl);
- LayerDriverEntries(layer_setup_[current_layer_], curr, entries);
-
- // Populate next function table after layers have been applied
- SetupFuncMaps(layer_functions[current_layer_ + 1], entries, curr, func_idx);
- }
-
- // We only want to apply layers once
- initialized_ = true;
-}
-
-void LayerLoader::LoadLayers() {
- std::string debug_layers = GetDebugLayers();
-
- // If no layers are specified, we're done
- if (debug_layers.empty()) return;
-
- // Only enable the system search path for non-user builds
- std::string system_path;
- if (property_get_bool("ro.debuggable", false) && prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
- system_path = kSystemLayerLibraryDir;
- }
-
- ALOGI("Debug layer list: %s", debug_layers.c_str());
- std::vector<std::string> layers = android::base::Split(debug_layers, ":");
-
- // Load the layers in reverse order so we start with the driver's entrypoint and work our way up
- for (int32_t i = layers.size() - 1; i >= 0; i--) {
- // Check each layer path for the layer
- std::vector<std::string> paths = android::base::Split(android_getLayerPaths(), ":");
-
- if (!system_path.empty()) {
- // Prepend the system paths so they override other layers
- auto it = paths.begin();
- paths.insert(it, system_path);
- }
-
- bool layer_found = false;
- for (uint32_t j = 0; j < paths.size() && !layer_found; j++) {
- std::string layer;
-
- ALOGI("Searching %s for GLES layers", paths[j].c_str());
-
- // Realpath will return null for non-existent files
- android::base::Realpath(paths[j] + "/" + layers[i], &layer);
-
- if (!layer.empty()) {
- layer_found = true;
- ALOGI("GLES layer found: %s", layer.c_str());
-
- // Load the layer
- //
- // TODO: This code is common with Vulkan loader, refactor
- //
- // Libraries in the system layer library dir can't be loaded into
- // the application namespace. That causes compatibility problems, since
- // any symbol dependencies will be resolved by system libraries. They
- // can't safely use libc++_shared, for example. Which is one reason
- // (among several) we only allow them in non-user builds.
- void* handle = nullptr;
- auto app_namespace = android::GraphicsEnv::getInstance().getAppNamespace();
- if (app_namespace && !android::base::StartsWith(layer, kSystemLayerLibraryDir)) {
- bool native_bridge = false;
- std::string error_message;
- handle = OpenNativeLibrary(app_namespace, layer.c_str(), &native_bridge,
- &error_message);
- if (!handle) {
- ALOGE("Failed to load layer %s with error: %s", layer.c_str(),
- error_message.c_str());
- return;
- }
-
- } else {
- handle = dlopen(layer.c_str(), RTLD_NOW | RTLD_LOCAL);
- }
-
- if (handle) {
- ALOGV("Loaded layer handle (%llu) for layer %s", (unsigned long long)handle,
- layers[i].c_str());
- } else {
- // If the layer is found but can't be loaded, try setenforce 0
- const char* dlsym_error = dlerror();
- ALOGE("Failed to load layer %s with error: %s", layer.c_str(), dlsym_error);
- return;
- }
-
- // Find the layer's Initialize function
- std::string init_func = "InitializeLayer";
- ALOGV("Looking for entrypoint %s", init_func.c_str());
-
- layer_init_func LayerInit =
- reinterpret_cast<layer_init_func>(dlsym(handle, init_func.c_str()));
- if (LayerInit) {
- ALOGV("Found %s for layer %s", init_func.c_str(), layer.c_str());
- layer_init_.push_back(LayerInit);
- } else {
- ALOGE("Failed to dlsym %s for layer %s", init_func.c_str(), layer.c_str());
- return;
- }
-
- // Find the layer's setup function
- std::string setup_func = "GetLayerProcAddress";
- ALOGV("Looking for entrypoint %s", setup_func.c_str());
-
- layer_setup_func LayerSetup =
- reinterpret_cast<layer_setup_func>(dlsym(handle, setup_func.c_str()));
- if (LayerSetup) {
- ALOGV("Found %s for layer %s", setup_func.c_str(), layer.c_str());
- layer_setup_.push_back(LayerSetup);
- } else {
- ALOGE("Failed to dlsym %s for layer %s", setup_func.c_str(), layer.c_str());
- return;
- }
- }
- }
- }
- // Track this so we only attempt to load these once
- layers_loaded_ = true;
-}
-
-} // namespace android
diff --git a/opengl/libs/EGL/egl_layers.h b/opengl/libs/EGL/egl_layers.h
deleted file mode 100644
index e401b44..0000000
--- a/opengl/libs/EGL/egl_layers.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2018 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 ANDROID_EGL_LAYERS_H
-#define ANDROID_EGL_LAYERS_H
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include <EGL/egldefs.h>
-
-#include "egl_platform_entries.h"
-
-typedef __eglMustCastToProperFunctionPointerType EGLFuncPointer;
-
-namespace android {
-
-class LayerLoader {
-public:
- static LayerLoader& getInstance();
- ~LayerLoader(){};
-
- typedef void* (*PFNEGLGETNEXTLAYERPROCADDRESSPROC)(void*, const char*);
- typedef EGLFuncPointer (*layer_init_func)(
- const void* layer_id, PFNEGLGETNEXTLAYERPROCADDRESSPROC get_next_layer_proc_address);
- typedef EGLFuncPointer (*layer_setup_func)(const char* name, EGLFuncPointer next);
-
- void LoadLayers();
- void InitLayers(egl_connection_t*);
- void LayerPlatformEntries(layer_setup_func layer_setup, EGLFuncPointer*, char const* const*);
- void LayerDriverEntries(layer_setup_func layer_setup, EGLFuncPointer*, char const* const*);
- bool Initialized();
- std::string GetDebugLayers();
-
- EGLFuncPointer GetGpaNext(unsigned i);
- EGLFuncPointer ApplyLayer(layer_setup_func layer_setup, const char* name, EGLFuncPointer next);
- EGLFuncPointer ApplyLayers(const char* name, EGLFuncPointer next);
-
- std::vector<layer_init_func> layer_init_;
- std::vector<layer_setup_func> layer_setup_;
-
-private:
- LayerLoader() : layers_loaded_(false), initialized_(false), current_layer_(0){};
- bool layers_loaded_;
- bool initialized_;
- unsigned current_layer_;
-};
-
-}; // namespace android
-
-#endif // ANDROID_EGL_LAYERS_H
diff --git a/opengl/libs/EGL/egl_platform_entries.cpp b/opengl/libs/EGL/egl_platform_entries.cpp
index 0d69a65..296ee44 100644
--- a/opengl/libs/EGL/egl_platform_entries.cpp
+++ b/opengl/libs/EGL/egl_platform_entries.cpp
@@ -30,8 +30,6 @@
#include <EGL/eglext_angle.h>
#include <android/hardware_buffer.h>
-#include <android-base/strings.h>
-#include <graphicsenv/GraphicsEnv.h>
#include <private/android/AHardwareBufferHelpers.h>
#include <cutils/compiler.h>
@@ -49,7 +47,6 @@
#include "egl_display.h"
#include "egl_object.h"
-#include "egl_layers.h"
#include "egl_tls.h"
#include "egl_trace.h"
@@ -1161,71 +1158,54 @@
// this protects accesses to sGLExtentionMap and sGLExtentionSlot
pthread_mutex_lock(&sExtensionMapMutex);
- /*
- * Since eglGetProcAddress() is not associated to anything, it needs
- * to return a function pointer that "works" regardless of what
- * the current context is.
- *
- * For this reason, we return a "forwarder", a small stub that takes
- * care of calling the function associated with the context
- * currently bound.
- *
- * We first look for extensions we've already resolved, if we're seeing
- * this extension for the first time, we go through all our
- * implementations and call eglGetProcAddress() and record the
- * result in the appropriate implementation hooks and return the
- * address of the forwarder corresponding to that hook set.
- *
- */
+ /*
+ * Since eglGetProcAddress() is not associated to anything, it needs
+ * to return a function pointer that "works" regardless of what
+ * the current context is.
+ *
+ * For this reason, we return a "forwarder", a small stub that takes
+ * care of calling the function associated with the context
+ * currently bound.
+ *
+ * We first look for extensions we've already resolved, if we're seeing
+ * this extension for the first time, we go through all our
+ * implementations and call eglGetProcAddress() and record the
+ * result in the appropriate implementation hooks and return the
+ * address of the forwarder corresponding to that hook set.
+ *
+ */
- const std::string name(procname);
+ const std::string name(procname);
auto& extentionMap = sGLExtentionMap;
auto pos = extentionMap.find(name);
- addr = (pos != extentionMap.end()) ? pos->second : nullptr;
- const int slot = sGLExtentionSlot;
+ addr = (pos != extentionMap.end()) ? pos->second : nullptr;
+ const int slot = sGLExtentionSlot;
- ALOGE_IF(slot >= MAX_NUMBER_OF_GL_EXTENSIONS,
- "no more slots for eglGetProcAddress(\"%s\")",
- procname);
+ ALOGE_IF(slot >= MAX_NUMBER_OF_GL_EXTENSIONS,
+ "no more slots for eglGetProcAddress(\"%s\")",
+ procname);
- egl_connection_t* const cnx = &gEGLImpl;
- LayerLoader& layer_loader(LayerLoader::getInstance());
+ if (!addr && (slot < MAX_NUMBER_OF_GL_EXTENSIONS)) {
+ bool found = false;
- if (!addr && (slot < MAX_NUMBER_OF_GL_EXTENSIONS)) {
-
- if (cnx->dso && cnx->egl.eglGetProcAddress) {
-
- // Extensions are independent of the bound context
- addr = cnx->egl.eglGetProcAddress(procname);
- if (addr) {
-
- // purposefully track the bottom of the stack in extensionMap
- extentionMap[name] = addr;
-
- // Apply layers
- addr = layer_loader.ApplyLayers(procname, addr);
-
- // Track the top most entry point
+ egl_connection_t* const cnx = &gEGLImpl;
+ if (cnx->dso && cnx->egl.eglGetProcAddress) {
+ // Extensions are independent of the bound context
+ addr =
cnx->hooks[egl_connection_t::GLESv1_INDEX]->ext.extensions[slot] =
- cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] = addr;
+ cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] =
+ cnx->egl.eglGetProcAddress(procname);
+ if (addr) found = true;
+ }
+
+ if (found) {
addr = gExtensionForwarders[slot];
+ extentionMap[name] = addr;
sGLExtentionSlot++;
}
}
- } else if (slot < MAX_NUMBER_OF_GL_EXTENSIONS) {
-
- // We've seen this func before, but we tracked the bottom, so re-apply layers
- // More layers might have been enabled
- addr = layer_loader.ApplyLayers(procname, addr);
-
- // Track the top most entry point
- cnx->hooks[egl_connection_t::GLESv1_INDEX]->ext.extensions[slot] =
- cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] = addr;
- addr = gExtensionForwarders[slot];
- }
-
pthread_mutex_unlock(&sExtensionMapMutex);
return addr;
}