Some cleanup in API and data structures

bug: 115618941

- Fix glGetStringi bug
- Stop using KeyedVector/String8/Vector in favor
  of STL

Change-Id: I61787b81742c01c84810d856e83304218d7cbcb7

6 files changed, 520 insertions, 320 deletions

diff --git a/shared/OpenglCodecCommon/GLSharedGroup.cpp b/shared/OpenglCodecCommon/GLSharedGroup.cpp
index e2ed6da3..e4bc889d 100755
--- a/shared/OpenglCodecCommon/GLSharedGroup.cpp
+++ b/shared/OpenglCodecCommon/GLSharedGroup.cpp
@@ -16,152 +16,157 @@
 
 #include "GLSharedGroup.h"
 
-/**** KeyedVector utilities ****/
-
-template <typename T>
-static void clearObjectMap(android::DefaultKeyedVector<GLuint, T>& v) {
-    for (size_t i = 0; i < v.size(); i++)
-        delete v.valueAt(i);
-    v.clear();
-}
+#include "KeyedVectorUtils.h"
 
 /**** BufferData ****/
 
 BufferData::BufferData() : m_size(0), m_usage(0), m_mapped(false) {};
-BufferData::BufferData(GLsizeiptr size, const void *data) : m_size(size), m_usage(0), m_mapped(false)
-{
+
+BufferData::BufferData(GLsizeiptr size, const void* data) :
+    m_size(size), m_usage(0), m_mapped(false) {
+
     void * buffer = NULL;
+
     if (size>0) buffer = m_fixedBuffer.alloc(size);
+
     if (data) memcpy(buffer, data, size);
 }
 
 /**** ProgramData ****/
 ProgramData::ProgramData() : m_numIndexes(0),
                              m_initialized(false),
-                             m_locShiftWAR(false)
-{
+                             m_locShiftWAR(false) {
     m_Indexes = NULL;
 }
 
-void ProgramData::initProgramData(GLuint numIndexes)
-{
+void ProgramData::initProgramData(GLuint numIndexes) {
     m_initialized = true;
     m_numIndexes = numIndexes;
-    delete[] m_Indexes;
+
+    delete [] m_Indexes;
+
     m_Indexes = new IndexInfo[numIndexes];
     m_locShiftWAR = false;
 }
 
-bool ProgramData::isInitialized()
-{
+bool ProgramData::isInitialized() {
     return m_initialized;
 }
 
-ProgramData::~ProgramData()
-{
-    delete[] m_Indexes;
+ProgramData::~ProgramData() {
+
+    delete [] m_Indexes;
+
     m_Indexes = NULL;
 }
 
-void ProgramData::setIndexInfo(GLuint index, GLint base, GLint size, GLenum type)
-{
-    if (index>=m_numIndexes)
-        return;
+void ProgramData::setIndexInfo(
+    GLuint index, GLint base, GLint size, GLenum type) {
+
+    if (index >= m_numIndexes) return;
+
     m_Indexes[index].base = base;
     m_Indexes[index].size = size;
     m_Indexes[index].type = type;
+
     if (index > 0) {
         m_Indexes[index].appBase = m_Indexes[index-1].appBase +
                                    m_Indexes[index-1].size;
-    }
-    else {
+    } else {
         m_Indexes[index].appBase = 0;
     }
+
     m_Indexes[index].hostLocsPerElement = 1;
     m_Indexes[index].flags = 0;
     m_Indexes[index].samplerValue = 0;
 }
 
-void ProgramData::setIndexFlags(GLuint index, GLuint flags)
-{
-    if (index >= m_numIndexes)
-        return;
+void ProgramData::setIndexFlags(GLuint index, GLuint flags) {
+
+    if (index >= m_numIndexes) return;
+
     m_Indexes[index].flags |= flags;
 }
 
-GLuint ProgramData::getIndexForLocation(GLint location)
-{
+GLuint ProgramData::getIndexForLocation(GLint location) {
     GLuint index = m_numIndexes;
+
     GLint minDist = -1;
-    for (GLuint i=0;i<m_numIndexes;++i)
-    {
+
+    for (GLuint i = 0; i < m_numIndexes; ++i) {
         GLint dist = location - m_Indexes[i].base;
-        if (dist >= 0 &&
-            (minDist < 0 || dist < minDist)) {
+        if (dist >= 0 && (minDist < 0 || dist < minDist)) {
             index = i;
             minDist = dist;
         }
     }
+
     return index;
 }
 
-GLenum ProgramData::getTypeForLocation(GLint location)
-{
+GLenum ProgramData::getTypeForLocation(GLint location) {
     GLuint index = getIndexForLocation(location);
-    if (index<m_numIndexes) {
+    if (index < m_numIndexes) {
         return m_Indexes[index].type;
     }
     return 0;
 }
 
-void ProgramData::setupLocationShiftWAR()
-{
+void ProgramData::setupLocationShiftWAR() {
     m_locShiftWAR = false;
-    for (GLuint i=0; i<m_numIndexes; i++) {
+    for (GLuint  i= 0; i < m_numIndexes; i++) {
         if (0 != (m_Indexes[i].base & 0xffff)) {
             return;
         }
     }
+
     // if we have one uniform at location 0, we do not need the WAR.
-    if (m_numIndexes > 1) {
-        m_locShiftWAR = true;
-    }
+    if (m_numIndexes > 1) m_locShiftWAR = true;
 }
 
-GLint ProgramData::locationWARHostToApp(GLint hostLoc, GLint arrIndex)
-{
+GLint ProgramData::locationWARHostToApp(GLint hostLoc, GLint arrIndex) {
+
     if (!m_locShiftWAR) return hostLoc;
 
     GLuint index = getIndexForLocation(hostLoc);
-    if (index<m_numIndexes) {
+
+    if (index < m_numIndexes) {
         if (arrIndex > 0) {
             m_Indexes[index].hostLocsPerElement =
-                              (hostLoc - m_Indexes[index].base) / arrIndex;
+                (hostLoc - m_Indexes[index].base) / arrIndex;
         }
         return m_Indexes[index].appBase + arrIndex;
     }
+
     return -1;
 }
 
-GLint ProgramData::locationWARAppToHost(GLint appLoc)
-{
+GLint ProgramData::locationWARAppToHost(GLint appLoc) {
+
     if (!m_locShiftWAR) return appLoc;
 
-    for(GLuint i=0; i<m_numIndexes; i++) {
-        GLint elemIndex = appLoc - m_Indexes[i].appBase;
+    for (GLuint i = 0; i < m_numIndexes; i++) {
+        GLint elemIndex =
+            appLoc - m_Indexes[i].appBase;
+
         if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) {
             return m_Indexes[i].base +
                    elemIndex * m_Indexes[i].hostLocsPerElement;
         }
     }
+
     return -1;
 }
 
-GLint ProgramData::getNextSamplerUniform(GLint index, GLint* val, GLenum* target)
-{
+GLint ProgramData::getNextSamplerUniform(
+    GLint index, GLint* val, GLenum* target) {
+
     for (GLint i = index + 1; i >= 0 && i < (GLint)m_numIndexes; i++) {
+
         if (m_Indexes[i].type == GL_SAMPLER_2D) {
+
             if (val) *val = m_Indexes[i].samplerValue;
+
             if (target) {
                 if (m_Indexes[i].flags & INDEX_FLAG_SAMPLER_EXTERNAL) {
                     *target = GL_TEXTURE_EXTERNAL_OES;
@@ -169,16 +174,21 @@ GLint ProgramData::getNextSamplerUniform(GLint index, GLint* val, GLenum* target
                     *target = GL_TEXTURE_2D;
                 }
             }
+
             return i;
         }
+
     }
+
     return -1;
 }
 
-bool ProgramData::setSamplerUniform(GLint appLoc, GLint val, GLenum* target)
-{
+bool ProgramData::setSamplerUniform(GLint appLoc, GLint val, GLenum* target) {
+
     for (GLuint i = 0; i < m_numIndexes; i++) {
+
         GLint elemIndex = appLoc - m_Indexes[i].appBase;
+
         if (elemIndex >= 0 && elemIndex < m_Indexes[i].size) {
             if (m_Indexes[i].type == GL_SAMPLER_2D) {
                 m_Indexes[i].samplerValue = val;
@@ -187,53 +197,47 @@ bool ProgramData::setSamplerUniform(GLint appLoc, GLint val, GLenum* target)
                         *target = GL_TEXTURE_EXTERNAL_OES;
                     } else {
                         *target = GL_TEXTURE_2D;
+
                     }
                 }
                 return true;
             }
         }
     }
+
     return false;
 }
 
-bool ProgramData::attachShader(GLuint shader)
-{
+bool ProgramData::attachShader(GLuint shader) {
     size_t n = m_shaders.size();
+
     for (size_t i = 0; i < n; i++) {
         if (m_shaders[i] == shader) {
             return false;
         }
     }
-    // AKA m_shaders.push_back(), but that has an ambiguous call to insertAt()
-    // due to the default parameters. This is the desired insertAt() overload.
-    m_shaders.insertAt(shader, m_shaders.size(), 1);
+    m_shaders.push_back(shader);
     return true;
 }
 
-bool ProgramData::detachShader(GLuint shader)
-{
+bool ProgramData::detachShader(GLuint shader) {
     size_t n = m_shaders.size();
+
     for (size_t i = 0; i < n; i++) {
         if (m_shaders[i] == shader) {
-            m_shaders.removeAt(i);
+            m_shaders.erase(m_shaders.begin() + i);
             return true;
         }
     }
+
     return false;
 }
 
 /***** GLSharedGroup ****/
 
-GLSharedGroup::GLSharedGroup() :
-    m_buffers(android::DefaultKeyedVector<GLuint, BufferData*>(NULL)),
-    m_programs(android::DefaultKeyedVector<GLuint, ProgramData*>(NULL)),
-    m_shaders(android::DefaultKeyedVector<GLuint, ShaderData*>(NULL)),
-    m_shaderPrograms(android::DefaultKeyedVector<GLuint, ShaderProgramData*>(NULL))
-{
-}
+GLSharedGroup::GLSharedGroup() { }
 
-GLSharedGroup::~GLSharedGroup()
-{
+GLSharedGroup::~GLSharedGroup() {
     m_buffers.clear();
     m_programs.clear();
     clearObjectMap(m_buffers);
@@ -242,193 +246,227 @@ GLSharedGroup::~GLSharedGroup()
     clearObjectMap(m_shaderPrograms);
 }
 
-bool GLSharedGroup::isShaderOrProgramObject(GLuint obj)
-{
+bool GLSharedGroup::isShaderOrProgramObject(GLuint obj) {
+
     android::AutoMutex _lock(m_lock);
-    return ((m_shaders.valueFor(obj)!=NULL) ||
-            (m_programs.valueFor(obj)!=NULL) ||
-            (m_shaderPrograms.valueFor(m_shaderProgramIdMap[obj]) !=NULL));
+
+    return (findObjectOrDefault(m_shaders, obj) ||
+            findObjectOrDefault(m_programs, obj) ||
+            findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[obj]));
 }
 
-BufferData * GLSharedGroup::getBufferData(GLuint bufferId)
-{
+BufferData* GLSharedGroup::getBufferData(GLuint bufferId) {
+
     android::AutoMutex _lock(m_lock);
-    return m_buffers.valueFor(bufferId);
+
+    return findObjectOrDefault(m_buffers, bufferId);
 }
 
 SharedTextureDataMap* GLSharedGroup::getTextureData() {
     return &m_textureRecs;
 }
 
-void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, const void* data)
-{
+void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, const void* data) {
+
     android::AutoMutex _lock(m_lock);
-    m_buffers.add(bufferId, new BufferData(size, data));
+
+    m_buffers[bufferId] = new BufferData(size, data);
 }
 
-void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, const void* data)
-{
+void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, const void* data) {
+
     android::AutoMutex _lock(m_lock);
-    ssize_t idx = m_buffers.indexOfKey(bufferId);
-    if (idx >= 0) {
-        delete m_buffers.valueAt(idx);
-        m_buffers.editValueAt(idx) = new BufferData(size, data);
-    } else {
-        m_buffers.add(bufferId, new BufferData(size, data));
-    }
+
+    BufferData* currentBuffer = findObjectOrDefault(m_buffers, bufferId);
+
+    if (currentBuffer) delete currentBuffer;
+
+    m_buffers[bufferId] = new BufferData(size, data);
 }
 
 void GLSharedGroup::setBufferUsage(GLuint bufferId, GLenum usage) {
+
     android::AutoMutex _lock(m_lock);
-    ssize_t idx = m_buffers.indexOfKey(bufferId);
-    if (idx >= 0) {
-        m_buffers.editValueAt(idx)->m_usage = usage;
-    }
+
+    BufferData* data = findObjectOrDefault(m_buffers, bufferId);
+
+    if (data) data->m_usage = usage;
 }
 
 void GLSharedGroup::setBufferMapped(GLuint bufferId, bool mapped) {
-    BufferData * buf = m_buffers.valueFor(bufferId);
+    BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
     if (!buf) return;
+
     buf->m_mapped = mapped;
 }
 
 GLenum GLSharedGroup::getBufferUsage(GLuint bufferId) {
-    BufferData * buf = m_buffers.valueFor(bufferId);
+    BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
     if (!buf) return 0;
+
     return buf->m_usage;
 }
 
 bool GLSharedGroup::isBufferMapped(GLuint bufferId) {
-    BufferData * buf = m_buffers.valueFor(bufferId);
+    BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
     if (!buf) return false;
+
     return buf->m_mapped;
 }
 
-GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, const void* data)
-{
+GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, const void* data) {
+
     android::AutoMutex _lock(m_lock);
-    BufferData * buf = m_buffers.valueFor(bufferId);
-    if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) return GL_INVALID_VALUE;
 
-    //it's safe to update now
+    BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+
+    if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) {
+        return GL_INVALID_VALUE;
+    }
+
     memcpy((char*)buf->m_fixedBuffer.ptr() + offset, data, size);
 
     buf->m_indexRangeCache.invalidateRange((size_t)offset, (size_t)size);
     return GL_NO_ERROR;
 }
 
-void GLSharedGroup::deleteBufferData(GLuint bufferId)
-{
+void GLSharedGroup::deleteBufferData(GLuint bufferId) {
+
     android::AutoMutex _lock(m_lock);
-    ssize_t idx = m_buffers.indexOfKey(bufferId);
-    if (idx >= 0) {
-        delete m_buffers.valueAt(idx);
-        m_buffers.removeItemsAt(idx);
+
+    BufferData* buf = findObjectOrDefault(m_buffers, bufferId);
+    if (buf) {
+        delete buf;
+        m_buffers.erase(bufferId);
     }
 }
 
-void GLSharedGroup::addProgramData(GLuint program)
-{
+void GLSharedGroup::addProgramData(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData *pData = m_programs.valueFor(program);
-    if (pData)
-    {
-        m_programs.removeItem(program);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+    if (pData) {
         delete pData;
     }
 
-    m_programs.add(program,new ProgramData());
+    m_programs[program] = new ProgramData();
 }
 
-void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes)
-{
+void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData *pData = m_programs.valueFor(program);
-    if (pData)
-    {
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+    if (pData) {
         pData->initProgramData(numIndexes);
     }
 }
 
-bool GLSharedGroup::isProgramInitialized(GLuint program)
-{
+bool GLSharedGroup::isProgramInitialized(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
-    if (pData)
-    {
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
+    if (pData) {
         return pData->isInitialized();
     }
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) {
-        return spData->programData->isInitialized();
+
+    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) {
+        return false;
+    }
+
+    ShaderProgramData* shaderProgramData =
+        findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (shaderProgramData) {
+        return shaderProgramData->programData.isInitialized();
     }
+
     return false;
 }
 
-void GLSharedGroup::deleteProgramData(GLuint program)
-{
+void GLSharedGroup::deleteProgramData(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData *pData = m_programs.valueFor(program);
-    if (pData) {
-        delete pData;
-    }
-    m_programs.removeItem(program);
 
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) {
-        delete spData;
-    }
-    m_shaderPrograms.removeItem(m_shaderProgramIdMap[program]);
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
+    if (pData) delete pData;
+
+    m_programs.erase(program);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(
+            m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (spData) delete spData;
+
+    m_shaderPrograms.erase(m_shaderProgramIdMap[program]);
     m_shaderProgramIdMap.erase(program);
 }
 
 // No such thing for separable shader programs.
-void GLSharedGroup::attachShader(GLuint program, GLuint shader)
-{
-    android::AutoMutex _lock(m_lock);
-    ProgramData* programData = m_programs.valueFor(program);
-    ssize_t idx = m_shaders.indexOfKey(shader);
-    if (programData && idx >= 0) {
-        if (programData->attachShader(shader)) {
-            refShaderDataLocked(idx);
+void GLSharedGroup::attachShader(GLuint program, GLuint shader) {
+
+    android::AutoMutex _lock(m_lock);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+    ShaderData* sData = findObjectOrDefault(m_shaders, shader);
+
+    if (pData && sData) {
+        if (pData->attachShader(shader)) {
+            refShaderDataLocked(shader);
         }
     }
 }
 
-void GLSharedGroup::detachShader(GLuint program, GLuint shader)
-{
+void GLSharedGroup::detachShader(GLuint program, GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* programData = m_programs.valueFor(program);
-    ssize_t idx = m_shaders.indexOfKey(shader);
-    if (programData && idx >= 0) {
-        if (programData->detachShader(shader)) {
-            unrefShaderDataLocked(idx);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+    ShaderData* sData = findObjectOrDefault(m_shaders, shader);
+    if (pData && sData) {
+        if (pData->detachShader(shader)) {
+            unrefShaderDataLocked(shader);
         }
     }
 }
 
 // Not needed/used for separate shader programs.
-void GLSharedGroup::setProgramIndexInfo(GLuint program, GLuint index, GLint base, GLint size, GLenum type, const char* name)
-{
+void GLSharedGroup::setProgramIndexInfo(
+    GLuint program, GLuint index, GLint base,
+    GLint size, GLenum type, const char* name) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
-    if (pData)
-    {
-        pData->setIndexInfo(index,base,size,type);
 
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
+    if (pData) {
+        pData->setIndexInfo(index,base,size,type);
         if (type == GL_SAMPLER_2D) {
             size_t n = pData->getNumShaders();
             for (size_t i = 0; i < n; i++) {
                 GLuint shaderId = pData->getShader(i);
-                ShaderData* shader = m_shaders.valueFor(shaderId);
+                ShaderData* shader = findObjectOrDefault(m_shaders, shaderId);
                 if (!shader) continue;
-                ShaderData::StringList::iterator nameIter = shader->samplerExternalNames.begin();
-                ShaderData::StringList::iterator nameEnd  = shader->samplerExternalNames.end();
+                ShaderData::StringList::iterator nameIter =
+                    shader->samplerExternalNames.begin();
+                ShaderData::StringList::iterator nameEnd =
+                    shader->samplerExternalNames.end();
                 while (nameIter != nameEnd) {
                     if (*nameIter == name) {
-                        pData->setIndexFlags(index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
+                        pData->setIndexFlags(
+                            index,
+                            ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
                         break;
                     }
                     ++nameIter;
@@ -438,221 +476,319 @@ void GLSharedGroup::setProgramIndexInfo(GLuint program, GLuint index, GLint base
     }
 }
 
-GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location)
-{
+GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
-    GLenum type=0;
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+    GLenum type = 0;
+
     if (pData) {
         type = pData->getTypeForLocation(location);
     }
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return type;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return type;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(
+            m_shaderPrograms, m_shaderProgramIdMap[program]);
+
     if (spData) {
-        type = spData->programData->getTypeForLocation(location);
+        type = spData->programData.getTypeForLocation(location);
     }
+
     return type;
 }
 
-bool  GLSharedGroup::isProgram(GLuint program)
-{
+bool GLSharedGroup::isProgram(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
     if (pData) return true;
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return false;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
     if (spData) return true;
+
     return false;
 }
 
-void GLSharedGroup::setupLocationShiftWAR(GLuint program)
-{
+void GLSharedGroup::setupLocationShiftWAR(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData =
+        findObjectOrDefault(m_programs, program);
+
     if (pData) pData->setupLocationShiftWAR();
 }
 
-GLint GLSharedGroup::locationWARHostToApp(GLuint program, GLint hostLoc, GLint arrIndex)
-{
+GLint GLSharedGroup::locationWARHostToApp(
+    GLuint program, GLint hostLoc, GLint arrIndex) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
     if (pData) return pData->locationWARHostToApp(hostLoc, arrIndex);
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return hostLoc;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) return spData->programData->locationWARHostToApp(hostLoc, arrIndex);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return hostLoc;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (spData) return spData->programData.locationWARHostToApp(hostLoc, arrIndex);
+
     return hostLoc;
 }
 
-GLint GLSharedGroup::locationWARAppToHost(GLuint program, GLint appLoc)
-{
+GLint GLSharedGroup::locationWARAppToHost(GLuint program, GLint appLoc) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData =
+        findObjectOrDefault(m_programs, program);
+
     if (pData) return pData->locationWARAppToHost(appLoc);
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return appLoc;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) return spData->programData->locationWARAppToHost(appLoc);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return appLoc;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(
+            m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (spData) return spData->programData.locationWARAppToHost(appLoc);
+
     return appLoc;
 }
 
-bool GLSharedGroup::needUniformLocationWAR(GLuint program)
-{
+bool GLSharedGroup::needUniformLocationWAR(GLuint program) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData =
+        findObjectOrDefault(m_programs, program);
+
     if (pData) return pData->needUniformLocationWAR();
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) return spData->programData->needUniformLocationWAR();
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return false;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (spData) return spData->programData.needUniformLocationWAR();
+
     return false;
 }
 
-GLint GLSharedGroup::getNextSamplerUniform(GLuint program, GLint index, GLint* val, GLenum* target) const
-{
+GLint GLSharedGroup::getNextSamplerUniform(
+    GLuint program, GLint index, GLint* val, GLenum* target) const {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData = findObjectOrDefault(m_programs, program);
+
     if (pData) return pData->getNextSamplerUniform(index, val, target);
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return -1;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap.find(program)->second);
-    if (spData) return spData->programData->getNextSamplerUniform(index, val, target);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return -1;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(
+            m_shaderPrograms,
+            findObjectOrDefault(m_shaderProgramIdMap, program));
+
+    if (spData) return spData->programData.getNextSamplerUniform(index, val, target);
+
     return -1;
 }
 
-bool GLSharedGroup::setSamplerUniform(GLuint program, GLint appLoc, GLint val, GLenum* target)
-{
+bool GLSharedGroup::setSamplerUniform(
+    GLuint program, GLint appLoc, GLint val, GLenum* target) {
+
     android::AutoMutex _lock(m_lock);
-    ProgramData* pData = m_programs.valueFor(program);
+
+    ProgramData* pData =
+        findObjectOrDefault(m_programs, program);
+
     if (pData) return pData->setSamplerUniform(appLoc, val, target);
-    if (m_shaderProgramIdMap.find(program) == m_shaderProgramIdMap.end()) return false;
-    ShaderProgramData* spData = m_shaderPrograms.valueFor(m_shaderProgramIdMap[program]);
-    if (spData) return spData->programData->setSamplerUniform(appLoc, val, target);
+
+    if (m_shaderProgramIdMap.find(program) ==
+        m_shaderProgramIdMap.end()) return false;
+
+    ShaderProgramData* spData =
+        findObjectOrDefault(m_shaderPrograms, m_shaderProgramIdMap[program]);
+
+    if (spData) return spData->programData.setSamplerUniform(appLoc, val, target);
+
     return false;
 }
 
-bool  GLSharedGroup::isShader(GLuint shader)
-{
+bool GLSharedGroup::isShader(GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
-    ShaderData* pData = m_shaders.valueFor(shader);
-    return (pData!=NULL);
+
+    ShaderData* pData = findObjectOrDefault(m_shaders, shader);
+
+    return pData != NULL;
 }
 
-bool GLSharedGroup::addShaderData(GLuint shader)
-{
+bool GLSharedGroup::addShaderData(GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
+
     ShaderData* data = new ShaderData;
+
     if (data) {
-        if (m_shaders.add(shader, data) < 0) {
-            delete data;
-            data = NULL;
-        }
+        m_shaders[shader] = data;
         data->refcount = 1;
     }
+
     return data != NULL;
 }
 
-ShaderData* GLSharedGroup::getShaderData(GLuint shader)
-{
+ShaderData* GLSharedGroup::getShaderData(GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
-    return m_shaders.valueFor(shader);
+
+    return findObjectOrDefault(m_shaders, shader);
 }
 
-void GLSharedGroup::unrefShaderData(GLuint shader)
-{
+void GLSharedGroup::unrefShaderData(GLuint shader) {
+
     android::AutoMutex _lock(m_lock);
-    ssize_t idx = m_shaders.indexOfKey(shader);
-    if (idx >= 0) {
-        unrefShaderDataLocked(idx);
-    }
+
+    unrefShaderDataLocked(shader);
 }
 
-void GLSharedGroup::refShaderDataLocked(ssize_t shaderIdx)
-{
-    assert(shaderIdx >= 0 && shaderIdx <= m_shaders.size());
-    ShaderData* data = m_shaders.valueAt(shaderIdx);
+void GLSharedGroup::refShaderDataLocked(GLuint shaderId) {
+    ShaderData* data = findObjectOrDefault(m_shaders, shaderId);
     data->refcount++;
 }
 
-void GLSharedGroup::unrefShaderDataLocked(ssize_t shaderIdx)
-{
-    assert(shaderIdx >= 0 && shaderIdx <= m_shaders.size());
-    ShaderData* data = m_shaders.valueAt(shaderIdx);
-    if (--data->refcount == 0) {
+void GLSharedGroup::unrefShaderDataLocked(GLuint shaderId) {
+    ShaderData* data = findObjectOrDefault(m_shaders, shaderId);
+
+    if (data && --data->refcount == 0) {
+
         delete data;
-        m_shaders.removeItemsAt(shaderIdx);
+
+        m_shaders.erase(shaderId);
     }
 }
 
 uint32_t GLSharedGroup::addNewShaderProgramData() {
+
     android::AutoMutex _lock(m_lock);
+
     ShaderProgramData* data = new ShaderProgramData;
     uint32_t currId = m_shaderProgramId;
+
     ALOGD("%s: new data %p id %u", __FUNCTION__, data, currId);
-    m_shaderPrograms.add(currId, data);
+
+    m_shaderPrograms[currId] = data;
     m_shaderProgramId++;
     return currId;
 }
 
-void GLSharedGroup::associateGLShaderProgram(GLuint shaderProgramName, uint32_t shaderProgramId) {
+void GLSharedGroup::associateGLShaderProgram(
+    GLuint shaderProgramName, uint32_t shaderProgramId) {
+
     android::AutoMutex _lock(m_lock);
+
     m_shaderProgramIdMap[shaderProgramName] = shaderProgramId;
 }
 
 ShaderProgramData* GLSharedGroup::getShaderProgramDataById(uint32_t id) {
+
     android::AutoMutex _lock(m_lock);
-    ShaderProgramData* res = m_shaderPrograms.valueFor(id);
+
+    ShaderProgramData* res = findObjectOrDefault(m_shaderPrograms, id);
+
     ALOGD("%s: id=%u res=%p", __FUNCTION__, id, res);
+
     return res;
 }
 
-ShaderProgramData* GLSharedGroup::getShaderProgramData(GLuint shaderProgramName) {
+ShaderProgramData* GLSharedGroup::getShaderProgramData(
+    GLuint shaderProgramName) {
+
     android::AutoMutex _lock(m_lock);
-    return m_shaderPrograms.valueFor(m_shaderProgramIdMap[shaderProgramName]);
+
+    return findObjectOrDefault(m_shaderPrograms,
+                               m_shaderProgramIdMap[shaderProgramName]);
 }
 
 void GLSharedGroup::deleteShaderProgramDataById(uint32_t id) {
+
     android::AutoMutex _lock(m_lock);
-    ShaderProgramData* data = m_shaderPrograms.valueFor(id);
+
+    ShaderProgramData* data =
+        findObjectOrDefault(m_shaderPrograms, id);
+
     delete data;
-    m_shaderPrograms.removeItemsAt(id);
+
+    m_shaderPrograms.erase(id);
 }
 
 
 void GLSharedGroup::deleteShaderProgramData(GLuint shaderProgramName) {
+
     android::AutoMutex _lock(m_lock);
+
     uint32_t id = m_shaderProgramIdMap[shaderProgramName];
-    ShaderProgramData* data = m_shaderPrograms.valueFor(id);
+    ShaderProgramData* data = findObjectOrDefault(m_shaderPrograms, id);
+
     delete data;
-    m_shaderPrograms.removeItemsAt(id);
+
+    m_shaderPrograms.erase(id);
     m_shaderProgramIdMap.erase(shaderProgramName);
 }
 
 void GLSharedGroup::initShaderProgramData(GLuint shaderProgram, GLuint numIndices) {
     ShaderProgramData* spData = getShaderProgramData(shaderProgram);
-    spData->programData->initProgramData(numIndices);
+    spData->programData.initProgramData(numIndices);
 }
 
-void GLSharedGroup::setShaderProgramIndexInfo(GLuint shaderProgram, GLuint index, GLint base, GLint size, GLenum type, const char* name) {
+void GLSharedGroup::setShaderProgramIndexInfo(
+    GLuint shaderProgram, GLuint index, GLint base,
+    GLint size, GLenum type, const char* name) {
+
     ShaderProgramData* spData = getShaderProgramData(shaderProgram);
-    ProgramData* pData = spData->programData;
-    ShaderData* sData = spData->shaderData;
+    ProgramData& pData = spData->programData;
+    ShaderData& sData = spData->shaderData;
 
-    if (pData)
-    {
-        pData->setIndexInfo(index, base, size, type);
+    pData.setIndexInfo(index, base, size, type);
 
-        if (type == GL_SAMPLER_2D) {
-            ShaderData::StringList::iterator nameIter = sData->samplerExternalNames.begin();
-            ShaderData::StringList::iterator nameEnd  = sData->samplerExternalNames.end();
-            while (nameIter != nameEnd) {
-                if (*nameIter == name) {
-                    pData->setIndexFlags(index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
-                    break;
-                }
-                ++nameIter;
+    if (type == GL_SAMPLER_2D) {
+
+        ShaderData::StringList::iterator nameIter =
+            sData.samplerExternalNames.begin();
+        ShaderData::StringList::iterator nameEnd =
+            sData.samplerExternalNames.end();
+
+        while (nameIter != nameEnd) {
+            if (*nameIter == name) {
+                pData.setIndexFlags(
+                    index, ProgramData::INDEX_FLAG_SAMPLER_EXTERNAL);
+                break;
             }
+            ++nameIter;
         }
     }
 }
 
 void GLSharedGroup::setupShaderProgramLocationShiftWAR(GLuint shaderProgram) {
     ShaderProgramData* spData = getShaderProgramData(shaderProgram);
-    spData->programData->setupLocationShiftWAR();
+    spData->programData.setupLocationShiftWAR();
 }
diff --git a/shared/OpenglCodecCommon/GLSharedGroup.h b/shared/OpenglCodecCommon/GLSharedGroup.h
index 2d680be8..0bb3bfaa 100755
--- a/shared/OpenglCodecCommon/GLSharedGroup.h
+++ b/shared/OpenglCodecCommon/GLSharedGroup.h
@@ -36,9 +36,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "ErrorLog.h"
-#include <utils/KeyedVector.h>
-#include <utils/List.h>
-#include <utils/String8.h>
 #include <utils/threads.h>
 #include "FixedBuffer.h"
 #include "IndexRangeCache.h"
@@ -80,7 +77,7 @@ private:
     bool m_initialized;
     bool m_locShiftWAR;
 
-    android::Vector<GLuint> m_shaders;
+    std::vector<GLuint> m_shaders;
 
 public:
     enum {
@@ -111,7 +108,7 @@ public:
 };
 
 struct ShaderData {
-    typedef android::List<android::String8> StringList;
+    typedef std::vector<std::string> StringList;
     StringList samplerExternalNames;
     int refcount;
     std::vector<std::string> sources;
@@ -119,31 +116,23 @@ struct ShaderData {
 
 class ShaderProgramData {
 public:
-    ShaderProgramData() {
-        shaderData = new ShaderData();
-        programData = new ProgramData();
-    }
-    ~ShaderProgramData() {
-        delete shaderData;
-        delete programData;
-    }
-    ShaderData* shaderData;
-    ProgramData* programData;
+    ShaderData shaderData;
+    ProgramData programData;
 };
 
 class GLSharedGroup {
 private:
     SharedTextureDataMap m_textureRecs;
-    android::DefaultKeyedVector<GLuint, BufferData*> m_buffers;
-    android::DefaultKeyedVector<GLuint, ProgramData*> m_programs;
-    android::DefaultKeyedVector<GLuint, ShaderData*> m_shaders;
-    android::DefaultKeyedVector<uint32_t, ShaderProgramData*> m_shaderPrograms;
+    std::map<GLuint, BufferData*> m_buffers;
+    std::map<GLuint, ProgramData*> m_programs;
+    std::map<GLuint, ShaderData*> m_shaders;
+    std::map<uint32_t, ShaderProgramData*> m_shaderPrograms;
     std::map<GLuint, uint32_t> m_shaderProgramIdMap;
 
     mutable android::Mutex m_lock;
 
-    void refShaderDataLocked(ssize_t shaderIdx);
-    void unrefShaderDataLocked(ssize_t shaderIdx);
+    void refShaderDataLocked(GLuint shader);
+    void unrefShaderDataLocked(GLuint shader);
 
     uint32_t m_shaderProgramId;
 
diff --git a/shared/OpenglCodecCommon/KeyedVectorUtils.h b/shared/OpenglCodecCommon/KeyedVectorUtils.h
new file mode 100644
index 00000000..97dc9f14
--- /dev/null
+++ b/shared/OpenglCodecCommon/KeyedVectorUtils.h
@@ -0,0 +1,38 @@
+/*
+* 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.
+*/
+#pragma once
+
+#include <map>
+
+template <typename T>
+void clearObjectMap(std::map<GLuint, T>& v) {
+    typename std::map<GLuint, T>::iterator it = v.begin();
+    for (; it != v.end(); ++it) {
+        delete it->second;
+    }
+    v.clear();
+}
+
+template <typename K, typename V>
+V findObjectOrDefault(const std::map<K, V>& m, K key, V defaultValue = 0) {
+    typename std::map<K, V>::const_iterator it = m.find(key);
+
+    if (it == m.end()) {
+        return defaultValue;
+    }
+
+    return it->second;
+}
diff --git a/system/GLESv2_enc/GL2Encoder.cpp b/system/GLESv2_enc/GL2Encoder.cpp
index b20c225e..68d35480 100755
--- a/system/GLESv2_enc/GL2Encoder.cpp
+++ b/system/GLESv2_enc/GL2Encoder.cpp
@@ -1414,8 +1414,10 @@ static bool replaceExternalSamplerUniformDefinition(char* str, const std::string
         do {
             c++;
         } while (isalnum(*c) || *c == '_');
+
+        size_t len = (size_t)(c - name_start);
         data->samplerExternalNames.push_back(
-                android::String8(name_start, c - name_start));
+            std::string(name_start, len));
 
         // We only need to perform a string replacement for the original
         // occurrence of samplerExternalOES if a #define was used.
@@ -4021,9 +4023,9 @@ const GLubyte* GL2Encoder::s_glGetStringi(void* self, GLenum name, GLuint index)
         retval);
 
     RET_AND_SET_ERROR_IF(
-        name == GL_VENDOR ||
-        name == GL_RENDERER ||
-        name == GL_VERSION ||
+        (name == GL_VENDOR ||
+         name == GL_RENDERER ||
+         name == GL_VERSION) &&
         index != 0,
         GL_INVALID_VALUE,
         retval);
@@ -4522,9 +4524,8 @@ GLuint GL2Encoder::s_glCreateShaderProgramv(void* self, GLenum type, GLsizei cou
     // Phase 1: create a ShaderData and initialize with replaceSamplerExternalWith2D()
     uint32_t spDataId = ctx->m_shared->addNewShaderProgramData();
     ShaderProgramData* spData = ctx->m_shared->getShaderProgramDataById(spDataId);
-    ShaderData* sData = spData->shaderData;
 
-    if (!replaceSamplerExternalWith2D(str, sData)) {
+    if (!replaceSamplerExternalWith2D(str, &spData->shaderData)) {
         delete [] str;
         ctx->setError(GL_OUT_OF_MEMORY);
         ctx->m_shared->deleteShaderProgramDataById(spDataId);
diff --git a/system/egl/eglDisplay.cpp b/system/egl/eglDisplay.cpp
index f5935981..27b8f66e 100644
--- a/system/egl/eglDisplay.cpp
+++ b/system/egl/eglDisplay.cpp
@@ -19,6 +19,8 @@
 
 #include <string>
 
+#include "KeyedVectorUtils.h"
+
 static const int systemEGLVersionMajor = 1;
 static const int systemEGLVersionMinor = 4;
 static const char systemEGLVendor[] = "Google Android emulator";
@@ -60,7 +62,7 @@ eglDisplay::eglDisplay() :
     m_hostRendererVersion(0),
     m_numConfigs(0),
     m_numConfigAttribs(0),
-    m_attribs(DefaultKeyedVector<EGLint, EGLint>(ATTRIBUTE_NONE)),
+    m_attribs(),
     m_configs(NULL),
     m_gles_iface(NULL),
     m_gles2_iface(NULL),
@@ -186,21 +188,20 @@ bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
             return false;
         }
 
-        //EGLint n = rcEnc->rcGetConfigs(rcEnc, nInts*sizeof(EGLint), m_configs);
         EGLint n = rcEnc->rcGetConfigs(rcEnc, nInts*sizeof(EGLint), (GLuint*)tmp_buf);
         if (n != m_numConfigs) {
             pthread_mutex_unlock(&m_lock);
             return false;
         }
 
-        //Fill the attributes vector.
-        //The first m_numConfigAttribs values of tmp_buf are the actual attributes enums.
+        // Fill the attributes vector.
+        // The first m_numConfigAttribs values of tmp_buf are the actual attributes enums.
         for (int i=0; i<m_numConfigAttribs; i++) {
-            m_attribs.add(tmp_buf[i], i);
+            m_attribs[tmp_buf[i]] = i;
         }
 
-        //Copy the actual configs data to m_configs
-        memcpy(m_configs, tmp_buf + m_numConfigAttribs, m_numConfigs*m_numConfigAttribs*sizeof(EGLint));
+        memcpy(m_configs, tmp_buf + m_numConfigAttribs,
+               m_numConfigs*m_numConfigAttribs*sizeof(EGLint));
 
         m_initialized = true;
     }
@@ -215,7 +216,6 @@ void eglDisplay::processConfigs()
 {
     for (intptr_t i=0; i<m_numConfigs; i++) {
         EGLConfig config = (EGLConfig)i;
-        //Setup the EGL_NATIVE_VISUAL_ID attribute
         PixelFormat format;
         if (getConfigNativePixelFormat(config, &format)) {
             setConfigAttrib(config, EGL_NATIVE_VISUAL_ID, format);
@@ -462,7 +462,12 @@ EGLBoolean eglDisplay::getConfigAttrib(EGLConfig config, EGLint attrib, EGLint *
     }
     //Though it seems that valueFor() is thread-safe, we don't take chanses
     pthread_mutex_lock(&m_lock);
-    EGLBoolean ret = getAttribValue(config, m_attribs.valueFor(attrib), value);
+    EGLBoolean ret =
+        getAttribValue(
+            config,
+            findObjectOrDefault(
+                m_attribs, attrib, EGL_DONT_CARE),
+            value);
     pthread_mutex_unlock(&m_lock);
     return ret;
 }
@@ -495,7 +500,14 @@ EGLBoolean eglDisplay::setConfigAttrib(EGLConfig config, EGLint attrib, EGLint v
 {
     //Though it seems that valueFor() is thread-safe, we don't take chanses
     pthread_mutex_lock(&m_lock);
-    EGLBoolean ret = setAttribValue(config, m_attribs.valueFor(attrib), value);
+    EGLBoolean ret =
+        setAttribValue(
+            config,
+            findObjectOrDefault(
+                m_attribs,
+                attrib,
+                EGL_DONT_CARE),
+            value);
     pthread_mutex_unlock(&m_lock);
     return ret;
 }
@@ -505,11 +517,23 @@ EGLBoolean eglDisplay::getConfigNativePixelFormat(EGLConfig config, PixelFormat
 {
     EGLint redSize, blueSize, greenSize, alphaSize;
 
-    if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) )
-    {
+    if (!(
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_RED_SIZE, EGL_DONT_CARE),
+                &redSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_BLUE_SIZE, EGL_DONT_CARE),
+                &blueSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_GREEN_SIZE, EGL_DONT_CARE),
+                &greenSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_ALPHA_SIZE, EGL_DONT_CARE),
+                &alphaSize))) {
         ALOGE("Couldn't find value for one of the pixel format attributes");
         return EGL_FALSE;
     }
@@ -529,11 +553,23 @@ EGLBoolean eglDisplay::getConfigGLPixelFormat(EGLConfig config, GLenum * format)
 {
     EGLint redSize, blueSize, greenSize, alphaSize;
 
-    if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) &&
-        getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) )
-    {
+    if (!(
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_RED_SIZE, EGL_DONT_CARE),
+                &redSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_BLUE_SIZE, EGL_DONT_CARE),
+                &blueSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_GREEN_SIZE, EGL_DONT_CARE),
+                &greenSize) &&
+            getAttribValue(
+                config,
+                findObjectOrDefault(m_attribs, EGL_ALPHA_SIZE, EGL_DONT_CARE),
+                &alphaSize))) {
         ALOGE("Couldn't find value for one of the pixel format attributes");
         return EGL_FALSE;
     }
diff --git a/system/egl/eglDisplay.h b/system/egl/eglDisplay.h
index 9fb6f074..9fae1f1c 100644
--- a/system/egl/eglDisplay.h
+++ b/system/egl/eglDisplay.h
@@ -21,7 +21,6 @@
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 #include "EGLClientIface.h"
-#include <utils/KeyedVector.h>
 
 #if __cplusplus >= 201103L
 #include <unordered_set>
@@ -29,6 +28,7 @@
 #include <hash_set>
 #endif
 
+#include <map>
 
 #include <ui/PixelFormat.h>
 
@@ -88,7 +88,7 @@ private:
     int  m_numConfigAttribs;
 
     /* This is the mapping between an attribute name to it's index in any given config */
-    DefaultKeyedVector<EGLint, EGLint>    m_attribs;
+    std::map<EGLint, EGLint>    m_attribs;
     /* This is an array of all config's attributes values stored in the following sequencial fasion (read: v[c,a] = the value of attribute <a> of config <c>)
      * v[0,0],..,v[0,m_numConfigAttribs-1],
      *...