[core] s/GLObjectStore/ObjectStore/

67 files changed, 266 insertions, 266 deletions

diff --git a/src/mbgl/geometry/buffer.hpp b/src/mbgl/geometry/buffer.hpp
index 80fde61702..2c4601eec1 100644
--- a/src/mbgl/geometry/buffer.hpp
+++ b/src/mbgl/geometry/buffer.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <mbgl/gl/gl.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 #include <mbgl/platform/log.hpp>
 #include <mbgl/util/noncopyable.hpp>
 
@@ -35,11 +35,11 @@ public:
     }
 
     // Transfers this buffer to the GPU and binds the buffer to the GL context.
-    void bind(gl::GLObjectStore& glObjectStore) {
+    void bind(gl::ObjectStore& store) {
         if (buffer.created()) {
             MBGL_CHECK_ERROR(glBindBuffer(bufferType, getID()));
         } else {
-            buffer.create(glObjectStore);
+            buffer.create(store);
             MBGL_CHECK_ERROR(glBindBuffer(bufferType, getID()));
             if (array == nullptr) {
                 Log::Debug(Event::OpenGL, "Buffer doesn't contain elements");
@@ -64,9 +64,9 @@ public:
     }
 
     // Uploads the buffer to the GPU to be available when we need it.
-    inline void upload(gl::GLObjectStore& glObjectStore) {
+    inline void upload(gl::ObjectStore& store) {
         if (!buffer.created()) {
-            bind(glObjectStore);
+            bind(store);
         }
     }
 
diff --git a/src/mbgl/geometry/glyph_atlas.cpp b/src/mbgl/geometry/glyph_atlas.cpp
index 1b0f4bc7e4..836155479e 100644
--- a/src/mbgl/geometry/glyph_atlas.cpp
+++ b/src/mbgl/geometry/glyph_atlas.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/geometry/glyph_atlas.hpp>
 
 #include <mbgl/gl/gl.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 #include <mbgl/platform/log.hpp>
 #include <mbgl/platform/platform.hpp>
 
@@ -142,10 +142,10 @@ void GlyphAtlas::removeGlyphs(uintptr_t tileUID) {
     }
 }
 
-void GlyphAtlas::upload(gl::GLObjectStore& glObjectStore) {
+void GlyphAtlas::upload(gl::ObjectStore& store) {
     if (dirty) {
         const bool first = !texture.created();
-        bind(glObjectStore);
+        bind(store);
 
         std::lock_guard<std::mutex> lock(mtx);
 
@@ -183,9 +183,9 @@ void GlyphAtlas::upload(gl::GLObjectStore& glObjectStore) {
     }
 }
 
-void GlyphAtlas::bind(gl::GLObjectStore& glObjectStore) {
+void GlyphAtlas::bind(gl::ObjectStore& store) {
     if (!texture.created()) {
-        texture.create(glObjectStore);
+        texture.create(store);
         MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture.getID()));
 #ifndef GL_ES_VERSION_2_0
         MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
diff --git a/src/mbgl/geometry/glyph_atlas.hpp b/src/mbgl/geometry/glyph_atlas.hpp
index 20ba5890ef..cfe81f9991 100644
--- a/src/mbgl/geometry/glyph_atlas.hpp
+++ b/src/mbgl/geometry/glyph_atlas.hpp
@@ -4,7 +4,7 @@
 #include <mbgl/text/glyph_store.hpp>
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/gl/gl.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 
 #include <string>
 #include <set>
@@ -27,11 +27,11 @@ public:
     void removeGlyphs(uintptr_t tileUID);
 
     // Binds the atlas texture to the GPU, and uploads data if it is out of date.
-    void bind(gl::GLObjectStore&);
+    void bind(gl::ObjectStore&);
 
     // Uploads the texture to the GPU to be available when we need it. This is a lazy operation;
     // the texture is only bound when the data is out of date (=dirty).
-    void upload(gl::GLObjectStore&);
+    void upload(gl::ObjectStore&);
 
     const GLsizei width;
     const GLsizei height;
diff --git a/src/mbgl/geometry/line_atlas.cpp b/src/mbgl/geometry/line_atlas.cpp
index 614e3280c7..7069b5f678 100644
--- a/src/mbgl/geometry/line_atlas.cpp
+++ b/src/mbgl/geometry/line_atlas.cpp
@@ -1,6 +1,6 @@
 #include <mbgl/geometry/line_atlas.hpp>
 #include <mbgl/gl/gl.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 #include <mbgl/platform/log.hpp>
 #include <mbgl/platform/platform.hpp>
 
@@ -21,7 +21,7 @@ LineAtlas::LineAtlas(GLsizei w, GLsizei h)
 LineAtlas::~LineAtlas() {
 }
 
-LinePatternPos LineAtlas::getDashPosition(const std::vector<float> &dasharray, bool round, gl::GLObjectStore& glObjectStore) {
+LinePatternPos LineAtlas::getDashPosition(const std::vector<float> &dasharray, bool round, gl::ObjectStore& store) {
     size_t key = round ? std::numeric_limits<size_t>::min() : std::numeric_limits<size_t>::max();
     for (const float part : dasharray) {
         boost::hash_combine<float>(key, part);
@@ -30,7 +30,7 @@ LinePatternPos LineAtlas::getDashPosition(const std::vector<float> &dasharray, b
     // Note: We're not handling hash collisions here.
     const auto it = positions.find(key);
     if (it == positions.end()) {
-        auto inserted = positions.emplace(key, addDash(dasharray, round, glObjectStore));
+        auto inserted = positions.emplace(key, addDash(dasharray, round, store));
         assert(inserted.second);
         return inserted.first->second;
     } else {
@@ -38,7 +38,7 @@ LinePatternPos LineAtlas::getDashPosition(const std::vector<float> &dasharray, b
     }
 }
 
-LinePatternPos LineAtlas::addDash(const std::vector<float> &dasharray, bool round, gl::GLObjectStore& glObjectStore) {
+LinePatternPos LineAtlas::addDash(const std::vector<float> &dasharray, bool round, gl::ObjectStore& store) {
 
     int n = round ? 7 : 0;
     int dashheight = 2 * n + 1;
@@ -116,21 +116,21 @@ LinePatternPos LineAtlas::addDash(const std::vector<float> &dasharray, bool roun
     nextRow += dashheight;
 
     dirty = true;
-    bind(glObjectStore);
+    bind(store);
 
     return position;
 };
 
-void LineAtlas::upload(gl::GLObjectStore& glObjectStore) {
+void LineAtlas::upload(gl::ObjectStore& store) {
     if (dirty) {
-        bind(glObjectStore);
+        bind(store);
     }
 }
 
-void LineAtlas::bind(gl::GLObjectStore& glObjectStore) {
+void LineAtlas::bind(gl::ObjectStore& store) {
     bool first = false;
     if (!texture.created()) {
-        texture.create(glObjectStore);
+        texture.create(store);
         MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture.getID()));
         MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
         MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
diff --git a/src/mbgl/geometry/line_atlas.hpp b/src/mbgl/geometry/line_atlas.hpp
index 15eb415414..8cff19eacf 100644
--- a/src/mbgl/geometry/line_atlas.hpp
+++ b/src/mbgl/geometry/line_atlas.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <mbgl/gl/gl.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 
 #include <vector>
 #include <map>
@@ -20,14 +20,14 @@ public:
     ~LineAtlas();
 
     // Binds the atlas texture to the GPU, and uploads data if it is out of date.
-    void bind(gl::GLObjectStore&);
+    void bind(gl::ObjectStore&);
 
     // Uploads the texture to the GPU to be available when we need it. This is a lazy operation;
     // the texture is only bound when the data is out of date (=dirty).
-    void upload(gl::GLObjectStore&);
+    void upload(gl::ObjectStore&);
 
-    LinePatternPos getDashPosition(const std::vector<float>&, bool, gl::GLObjectStore&);
-    LinePatternPos addDash(const std::vector<float> &dasharray, bool round, gl::GLObjectStore&);
+    LinePatternPos getDashPosition(const std::vector<float>&, bool, gl::ObjectStore&);
+    LinePatternPos addDash(const std::vector<float> &dasharray, bool round, gl::ObjectStore&);
 
     const GLsizei width;
     const GLsizei height;
diff --git a/src/mbgl/geometry/vao.cpp b/src/mbgl/geometry/vao.cpp
index c438fbd2e6..4bfe6b4909 100644
--- a/src/mbgl/geometry/vao.cpp
+++ b/src/mbgl/geometry/vao.cpp
@@ -1,6 +1,6 @@
 #include <mbgl/geometry/vao.hpp>
 #include <mbgl/platform/log.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 #include <mbgl/util/string.hpp>
 
 namespace mbgl {
@@ -16,7 +16,7 @@ VertexArrayObject::VertexArrayObject() {
 VertexArrayObject::~VertexArrayObject() {
 }
 
-void VertexArrayObject::bindVertexArrayObject(gl::GLObjectStore& glObjectStore) {
+void VertexArrayObject::bindVertexArrayObject(gl::ObjectStore& store) {
     if (!gl::GenVertexArrays || !gl::BindVertexArray) {
         static bool reported = false;
         if (!reported) {
@@ -27,7 +27,7 @@ void VertexArrayObject::bindVertexArrayObject(gl::GLObjectStore& glObjectStore)
     }
 
     if (!vao.created()) {
-        vao.create(glObjectStore);
+        vao.create(store);
     }
     MBGL_CHECK_ERROR(gl::BindVertexArray(vao.getID()));
 }
diff --git a/src/mbgl/geometry/vao.hpp b/src/mbgl/geometry/vao.hpp
index 8bc3750590..8c1edb4d29 100644
--- a/src/mbgl/geometry/vao.hpp
+++ b/src/mbgl/geometry/vao.hpp
@@ -2,7 +2,7 @@
 
 #include <mbgl/shader/shader.hpp>
 #include <mbgl/gl/gl.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 #include <mbgl/util/noncopyable.hpp>
 
 #include <stdexcept>
@@ -19,10 +19,10 @@ public:
     ~VertexArrayObject();
 
     template <typename Shader, typename VertexBuffer>
-    inline void bind(Shader& shader, VertexBuffer &vertexBuffer, GLbyte *offset, gl::GLObjectStore& glObjectStore) {
-        bindVertexArrayObject(glObjectStore);
+    inline void bind(Shader& shader, VertexBuffer &vertexBuffer, GLbyte *offset, gl::ObjectStore& store) {
+        bindVertexArrayObject(store);
         if (bound_shader == 0) {
-            vertexBuffer.bind(glObjectStore);
+            vertexBuffer.bind(store);
             shader.bind(offset);
             if (vao.created()) {
                 storeBinding(shader, vertexBuffer.getID(), 0, offset);
@@ -33,11 +33,11 @@ public:
     }
 
     template <typename Shader, typename VertexBuffer, typename ElementsBuffer>
-    inline void bind(Shader& shader, VertexBuffer &vertexBuffer, ElementsBuffer &elementsBuffer, GLbyte *offset, gl::GLObjectStore& glObjectStore) {
-        bindVertexArrayObject(glObjectStore);
+    inline void bind(Shader& shader, VertexBuffer &vertexBuffer, ElementsBuffer &elementsBuffer, GLbyte *offset, gl::ObjectStore& store) {
+        bindVertexArrayObject(store);
         if (bound_shader == 0) {
-            vertexBuffer.bind(glObjectStore);
-            elementsBuffer.bind(glObjectStore);
+            vertexBuffer.bind(store);
+            elementsBuffer.bind(store);
             shader.bind(offset);
             if (vao.created()) {
                 storeBinding(shader, vertexBuffer.getID(), elementsBuffer.getID(), offset);
@@ -52,7 +52,7 @@ public:
     }
 
 private:
-    void bindVertexArrayObject(gl::GLObjectStore&);
+    void bindVertexArrayObject(gl::ObjectStore&);
     void storeBinding(Shader &shader, GLuint vertexBuffer, GLuint elementsBuffer, GLbyte *offset);
     void verifyBinding(Shader &shader, GLuint vertexBuffer, GLuint elementsBuffer, GLbyte *offset);
 
diff --git a/src/mbgl/gl/gl_object_store.cpp b/src/mbgl/gl/object_store.cpp
index 040109d011..f52cc26f85 100644
--- a/src/mbgl/gl/gl_object_store.cpp
+++ b/src/mbgl/gl/object_store.cpp
@@ -1,11 +1,11 @@
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 
 #include <cassert>
 
 namespace mbgl {
 namespace gl {
 
-void ProgramHolder::create(GLObjectStore& objectStore_) {
+void ProgramHolder::create(ObjectStore& objectStore_) {
     if (created()) return;
     objectStore = &objectStore_;
     id = MBGL_CHECK_ERROR(glCreateProgram());
@@ -17,7 +17,7 @@ void ProgramHolder::reset() {
     id = 0;
 }
 
-void ShaderHolder::create(GLObjectStore& objectStore_) {
+void ShaderHolder::create(ObjectStore& objectStore_) {
     if (created()) return;
     objectStore = &objectStore_;
     id = MBGL_CHECK_ERROR(glCreateShader(type));
@@ -29,7 +29,7 @@ void ShaderHolder::reset() {
     id = 0;
 }
 
-void BufferHolder::create(GLObjectStore& objectStore_) {
+void BufferHolder::create(ObjectStore& objectStore_) {
     if (created()) return;
     objectStore = &objectStore_;
     MBGL_CHECK_ERROR(glGenBuffers(1, &id));
@@ -41,7 +41,7 @@ void BufferHolder::reset() {
     id = 0;
 }
 
-void TextureHolder::create(GLObjectStore& objectStore_) {
+void TextureHolder::create(ObjectStore& objectStore_) {
     if (created()) return;
     objectStore = &objectStore_;
     MBGL_CHECK_ERROR(glGenTextures(1, &id));
@@ -53,7 +53,7 @@ void TextureHolder::reset() {
     id = 0;
 }
 
-void TexturePoolHolder::create(GLObjectStore& objectStore_) {
+void TexturePoolHolder::create(ObjectStore& objectStore_) {
     if (created()) return;
     objectStore = &objectStore_;
     MBGL_CHECK_ERROR(glGenTextures(TextureMax, ids.data()));
@@ -68,7 +68,7 @@ void TexturePoolHolder::reset() {
     };
 }
 
-void VAOHolder::create(GLObjectStore& objectStore_) {
+void VAOHolder::create(ObjectStore& objectStore_) {
     if (created()) return;
     objectStore = &objectStore_;
     MBGL_CHECK_ERROR(gl::GenVertexArrays(1, &id));
@@ -80,7 +80,7 @@ void VAOHolder::reset() {
     id = 0;
 }
 
-GLObjectStore::~GLObjectStore() {
+ObjectStore::~ObjectStore() {
     assert(abandonedPrograms.empty());
     assert(abandonedShaders.empty());
     assert(abandonedBuffers.empty());
@@ -88,7 +88,7 @@ GLObjectStore::~GLObjectStore() {
     assert(abandonedVAOs.empty());
 }
 
-void GLObjectStore::performCleanup() {
+void ObjectStore::performCleanup() {
     for (GLuint id : abandonedPrograms) {
         MBGL_CHECK_ERROR(glDeleteProgram(id));
     }
diff --git a/src/mbgl/gl/gl_object_store.hpp b/src/mbgl/gl/object_store.hpp
index 2527bbf332..a92f082b76 100644
--- a/src/mbgl/gl/gl_object_store.hpp
+++ b/src/mbgl/gl/object_store.hpp
@@ -11,9 +11,9 @@
 namespace mbgl {
 namespace gl {
 
-class GLObjectStore : private util::noncopyable {
+class ObjectStore : private util::noncopyable {
 public:
-    ~GLObjectStore();
+    ~ObjectStore();
 
     // Actually remove the objects we marked as abandoned with the above methods.
     // Only call this while the OpenGL context is exclusive to this thread.
@@ -46,7 +46,7 @@ public:
 
 protected:
     GLuint id = 0;
-    GLObjectStore* objectStore = nullptr;
+    ObjectStore* objectStore = nullptr;
 };
 
 class ProgramHolder : public GLHolder {
@@ -57,7 +57,7 @@ public:
     ProgramHolder(ProgramHolder&& o) noexcept : GLHolder(std::move(o)) {}
     ProgramHolder& operator=(ProgramHolder&& o) noexcept { GLHolder::operator=(std::move(o)); return *this; }
 
-    void create(GLObjectStore&);
+    void create(ObjectStore&);
     void reset();
 };
 
@@ -69,7 +69,7 @@ public:
     ShaderHolder(ShaderHolder&& o) noexcept : GLHolder(std::move(o)), type(o.type) {}
     ShaderHolder& operator=(ShaderHolder&& o) noexcept { GLHolder::operator=(std::move(o)); type = o.type; return *this; }
 
-    void create(GLObjectStore&);
+    void create(ObjectStore&);
     void reset();
 
 private:
@@ -84,7 +84,7 @@ public:
     BufferHolder(BufferHolder&& o) noexcept : GLHolder(std::move(o)) {}
     BufferHolder& operator=(BufferHolder&& o) noexcept { GLHolder::operator=(std::move(o)); return *this; }
 
-    void create(GLObjectStore&);
+    void create(ObjectStore&);
     void reset();
 };
 
@@ -96,7 +96,7 @@ public:
     TextureHolder(TextureHolder&& o) noexcept : GLHolder(std::move(o)) {}
     TextureHolder& operator=(TextureHolder&& o) noexcept { GLHolder::operator=(std::move(o)); return *this; }
 
-    void create(GLObjectStore&);
+    void create(ObjectStore&);
     void reset();
 };
 
@@ -114,12 +114,12 @@ public:
     const std::array<GLuint, TextureMax>& getIDs() const { return ids; }
     const GLuint& operator[](size_t pos) { return ids[pos]; }
 
-    void create(GLObjectStore&);
+    void create(ObjectStore&);
     void reset();
 
 private:
     std::array<GLuint, TextureMax> ids;
-    GLObjectStore* objectStore = nullptr;
+    ObjectStore* objectStore = nullptr;
 };
 
 class VAOHolder : public GLHolder {
@@ -130,7 +130,7 @@ public:
     VAOHolder(VAOHolder&& o) noexcept : GLHolder(std::move(o)) {}
     VAOHolder& operator=(VAOHolder&& o) noexcept { GLHolder::operator=(std::move(o)); return *this; }
 
-    void create(GLObjectStore&);
+    void create(ObjectStore&);
     void reset();
 };
 
diff --git a/src/mbgl/gl/texture_pool.cpp b/src/mbgl/gl/texture_pool.cpp
index a875f4d579..c04f781daa 100644
--- a/src/mbgl/gl/texture_pool.cpp
+++ b/src/mbgl/gl/texture_pool.cpp
@@ -1,12 +1,12 @@
 #include <mbgl/gl/texture_pool.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 
 #include <vector>
 
 namespace mbgl {
 namespace gl {
 
-GLuint TexturePool::getTextureID(gl::GLObjectStore& glObjectStore) {
+GLuint TexturePool::getTextureID(gl::ObjectStore& store) {
     for (auto& impl : pools) {
         if (impl.ids.empty()) continue;
         auto it = impl.ids.begin();
@@ -16,7 +16,7 @@ GLuint TexturePool::getTextureID(gl::GLObjectStore& glObjectStore) {
     }
 
     // All texture IDs are in use.
-    pools.emplace_back(Impl(glObjectStore));
+    pools.emplace_back(Impl(store));
     auto it = pools.back().ids.begin();
     GLuint id = *it;
     pools.back().ids.erase(it);
diff --git a/src/mbgl/gl/texture_pool.hpp b/src/mbgl/gl/texture_pool.hpp
index 10894f146e..2c5610cf4a 100644
--- a/src/mbgl/gl/texture_pool.hpp
+++ b/src/mbgl/gl/texture_pool.hpp
@@ -2,7 +2,7 @@
 
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/gl/gl.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 
 #include <algorithm>
 #include <memory>
@@ -13,14 +13,14 @@ namespace gl {
 
 class TexturePool : private util::noncopyable {
 public:
-    GLuint getTextureID(gl::GLObjectStore&);
+    GLuint getTextureID(gl::ObjectStore&);
     void releaseTextureID(GLuint);
 
 private:
     class Impl : private util::noncopyable {
     public:
-        Impl(gl::GLObjectStore& glObjectStore) : ids(gl::TexturePoolHolder::TextureMax) {
-            pool.create(glObjectStore);
+        Impl(gl::ObjectStore& store) : ids(gl::TexturePoolHolder::TextureMax) {
+            pool.create(store);
             std::copy(pool.getIDs().begin(), pool.getIDs().end(), ids.begin());
         }
 
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 298255adac..b7b8b584ec 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -17,7 +17,7 @@
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/storage/resource.hpp>
 #include <mbgl/storage/response.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 #include <mbgl/gl/texture_pool.hpp>
 #include <mbgl/util/projection.hpp>
 #include <mbgl/util/math.hpp>
@@ -58,7 +58,7 @@ public:
 
     MapDebugOptions debugOptions { MapDebugOptions::NoDebug };
 
-    gl::GLObjectStore glObjectStore;
+    gl::ObjectStore store;
     Update updateFlags = Update::Nothing;
     util::AsyncTask asyncUpdate;
 
@@ -109,13 +109,13 @@ Map::~Map() {
     impl->styleRequest = nullptr;
 
     // Explicit resets currently necessary because these abandon resources that need to be
-    // cleaned up by glObjectStore.performCleanup();
+    // cleaned up by store.performCleanup();
     impl->style.reset();
     impl->painter.reset();
     impl->texturePool.reset();
     impl->annotationManager.reset();
 
-    impl->glObjectStore.performCleanup();
+    impl->store.performCleanup();
 
     impl->view.deactivate();
 }
@@ -251,7 +251,7 @@ void Map::Impl::update() {
 
 void Map::Impl::render() {
     if (!painter) {
-        painter = std::make_unique<Painter>(transform.getState(), glObjectStore);
+        painter = std::make_unique<Painter>(transform.getState(), store);
     }
 
     FrameData frameData { view.getFramebufferSize(),
@@ -270,7 +270,7 @@ void Map::Impl::render() {
         callback = nullptr;
     }
 
-    glObjectStore.performCleanup();
+    store.performCleanup();
 
     if (style->hasTransitions()) {
         updateFlags |= Update::RecalculateStyle;
diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp
index d7286b0b45..cffc0ba8df 100644
--- a/src/mbgl/renderer/bucket.hpp
+++ b/src/mbgl/renderer/bucket.hpp
@@ -18,7 +18,7 @@ class UnwrappedTileID;
 class CollisionTile;
 
 namespace gl {
-class GLObjectStore;
+class ObjectStore;
 }
 
 class Bucket : private util::noncopyable {
@@ -27,7 +27,7 @@ public:
 
     // As long as this bucket has a Prepare render pass, this function is getting called. Typically,
     // this only happens once when the bucket is being rendered for the first time.
-    virtual void upload(gl::GLObjectStore&) = 0;
+    virtual void upload(gl::ObjectStore&) = 0;
 
     // Every time this bucket is getting rendered, this function is called. This happens either
     // once or twice (for Opaque and Transparent render passes).
diff --git a/src/mbgl/renderer/circle_bucket.cpp b/src/mbgl/renderer/circle_bucket.cpp
index 19ebf8e78b..6df186f2d0 100644
--- a/src/mbgl/renderer/circle_bucket.cpp
+++ b/src/mbgl/renderer/circle_bucket.cpp
@@ -14,9 +14,9 @@ CircleBucket::~CircleBucket() {
     // Do not remove. header file only contains forward definitions to unique pointers.
 }
 
-void CircleBucket::upload(gl::GLObjectStore& glObjectStore) {
-    vertexBuffer_.upload(glObjectStore);
-    elementsBuffer_.upload(glObjectStore);
+void CircleBucket::upload(gl::ObjectStore& store) {
+    vertexBuffer_.upload(store);
+    elementsBuffer_.upload(store);
     uploaded = true;
 }
 
@@ -80,7 +80,7 @@ void CircleBucket::addGeometry(const GeometryCollection& geometryCollection) {
     }
 }
 
-void CircleBucket::drawCircles(CircleShader& shader, gl::GLObjectStore& glObjectStore) {
+void CircleBucket::drawCircles(CircleShader& shader, gl::ObjectStore& store) {
     GLbyte* vertexIndex = BUFFER_OFFSET(0);
     GLbyte* elementsIndex = BUFFER_OFFSET(0);
 
@@ -89,7 +89,7 @@ void CircleBucket::drawCircles(CircleShader& shader, gl::GLObjectStore& glObject
 
         if (!group->elements_length) continue;
 
-        group->array[0].bind(shader, vertexBuffer_, elementsBuffer_, vertexIndex, glObjectStore);
+        group->array[0].bind(shader, vertexBuffer_, elementsBuffer_, vertexIndex, store);
 
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT, elementsIndex));
 
diff --git a/src/mbgl/renderer/circle_bucket.hpp b/src/mbgl/renderer/circle_bucket.hpp
index 681334f8a4..b0349c7426 100644
--- a/src/mbgl/renderer/circle_bucket.hpp
+++ b/src/mbgl/renderer/circle_bucket.hpp
@@ -18,14 +18,14 @@ public:
     CircleBucket(const MapMode);
     ~CircleBucket() override;
 
-    void upload(gl::GLObjectStore&) override;
+    void upload(gl::ObjectStore&) override;
     void render(Painter&, const StyleLayer&, const UnwrappedTileID&, const mat4&) override;
 
     bool hasData() const override;
     bool needsClipping() const override;
     void addGeometry(const GeometryCollection&);
 
-    void drawCircles(CircleShader&, gl::GLObjectStore&);
+    void drawCircles(CircleShader&, gl::ObjectStore&);
 
 private:
     CircleVertexBuffer vertexBuffer_;
diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp
index 765d0c1e76..8c7a25c675 100644
--- a/src/mbgl/renderer/debug_bucket.cpp
+++ b/src/mbgl/renderer/debug_bucket.cpp
@@ -38,16 +38,16 @@ DebugBucket::DebugBucket(const OverscaledTileID& id,
     }
 }
 
-void DebugBucket::drawLines(PlainShader& shader, gl::GLObjectStore& glObjectStore) {
+void DebugBucket::drawLines(PlainShader& shader, gl::ObjectStore& store) {
     if (!fontBuffer.empty()) {
-        array.bind(shader, fontBuffer, BUFFER_OFFSET_0, glObjectStore);
+        array.bind(shader, fontBuffer, BUFFER_OFFSET_0, store);
         MBGL_CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)(fontBuffer.index())));
     }
 }
 
-void DebugBucket::drawPoints(PlainShader& shader, gl::GLObjectStore& glObjectStore) {
+void DebugBucket::drawPoints(PlainShader& shader, gl::ObjectStore& store) {
     if (!fontBuffer.empty()) {
-        array.bind(shader, fontBuffer, BUFFER_OFFSET_0, glObjectStore);
+        array.bind(shader, fontBuffer, BUFFER_OFFSET_0, store);
         MBGL_CHECK_ERROR(glDrawArrays(GL_POINTS, 0, (GLsizei)(fontBuffer.index())));
     }
 }
diff --git a/src/mbgl/renderer/debug_bucket.hpp b/src/mbgl/renderer/debug_bucket.hpp
index f71d4cffee..d69014bb8b 100644
--- a/src/mbgl/renderer/debug_bucket.hpp
+++ b/src/mbgl/renderer/debug_bucket.hpp
@@ -11,7 +11,7 @@ namespace mbgl {
 class PlainShader;
 
 namespace gl {
-class GLObjectStore;
+class ObjectStore;
 }
 
 class DebugBucket : private util::noncopyable {
@@ -23,8 +23,8 @@ public:
                 optional<Timestamp> expires,
                 MapDebugOptions);
 
-    void drawLines(PlainShader&, gl::GLObjectStore&);
-    void drawPoints(PlainShader&, gl::GLObjectStore&);
+    void drawLines(PlainShader&, gl::ObjectStore&);
+    void drawPoints(PlainShader&, gl::ObjectStore&);
 
     const bool renderable;
     const bool complete;
diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp
index 967a2df8c3..78d4c40a97 100644
--- a/src/mbgl/renderer/fill_bucket.cpp
+++ b/src/mbgl/renderer/fill_bucket.cpp
@@ -94,10 +94,10 @@ void FillBucket::addGeometry(const GeometryCollection& geometry) {
     }
 }
 
-void FillBucket::upload(gl::GLObjectStore& glObjectStore) {
-    vertexBuffer.upload(glObjectStore);
-    triangleElementsBuffer.upload(glObjectStore);
-    lineElementsBuffer.upload(glObjectStore);
+void FillBucket::upload(gl::ObjectStore& store) {
+    vertexBuffer.upload(store);
+    triangleElementsBuffer.upload(store);
+    lineElementsBuffer.upload(store);
 
     // From now on, we're going to render during the opaque and translucent pass.
     uploaded = true;
@@ -118,48 +118,48 @@ bool FillBucket::needsClipping() const {
     return true;
 }
 
-void FillBucket::drawElements(PlainShader& shader, gl::GLObjectStore& glObjectStore) {
+void FillBucket::drawElements(PlainShader& shader, gl::ObjectStore& store) {
     GLbyte* vertex_index = BUFFER_OFFSET(0);
     GLbyte* elements_index = BUFFER_OFFSET(0);
     for (auto& group : triangleGroups) {
         assert(group);
-        group->array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, glObjectStore);
+        group->array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group->vertex_length * vertexBuffer.itemSize;
         elements_index += group->elements_length * triangleElementsBuffer.itemSize;
     }
 }
 
-void FillBucket::drawElements(PatternShader& shader, gl::GLObjectStore& glObjectStore) {
+void FillBucket::drawElements(PatternShader& shader, gl::ObjectStore& store) {
     GLbyte* vertex_index = BUFFER_OFFSET(0);
     GLbyte* elements_index = BUFFER_OFFSET(0);
     for (auto& group : triangleGroups) {
         assert(group);
-        group->array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, glObjectStore);
+        group->array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group->vertex_length * vertexBuffer.itemSize;
         elements_index += group->elements_length * triangleElementsBuffer.itemSize;
     }
 }
 
-void FillBucket::drawVertices(OutlineShader& shader, gl::GLObjectStore& glObjectStore) {
+void FillBucket::drawVertices(OutlineShader& shader, gl::ObjectStore& store) {
     GLbyte* vertex_index = BUFFER_OFFSET(0);
     GLbyte* elements_index = BUFFER_OFFSET(0);
     for (auto& group : lineGroups) {
         assert(group);
-        group->array[0].bind(shader, vertexBuffer, lineElementsBuffer, vertex_index, glObjectStore);
+        group->array[0].bind(shader, vertexBuffer, lineElementsBuffer, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawElements(GL_LINES, group->elements_length * 2, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group->vertex_length * vertexBuffer.itemSize;
         elements_index += group->elements_length * lineElementsBuffer.itemSize;
     }
 }
 
-void FillBucket::drawVertices(OutlinePatternShader& shader, gl::GLObjectStore& glObjectStore) {
+void FillBucket::drawVertices(OutlinePatternShader& shader, gl::ObjectStore& store) {
     GLbyte* vertex_index = BUFFER_OFFSET(0);
     GLbyte* elements_index = BUFFER_OFFSET(0);
     for (auto& group : lineGroups) {
         assert(group);
-        group->array[1].bind(shader, vertexBuffer, lineElementsBuffer, vertex_index, glObjectStore);
+        group->array[1].bind(shader, vertexBuffer, lineElementsBuffer, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawElements(GL_LINES, group->elements_length * 2, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group->vertex_length * vertexBuffer.itemSize;
         elements_index += group->elements_length * lineElementsBuffer.itemSize;
diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp
index 1ffe27db1b..f1b137893c 100644
--- a/src/mbgl/renderer/fill_bucket.hpp
+++ b/src/mbgl/renderer/fill_bucket.hpp
@@ -20,17 +20,17 @@ public:
     FillBucket();
     ~FillBucket() override;
 
-    void upload(gl::GLObjectStore&) override;
+    void upload(gl::ObjectStore&) override;
     void render(Painter&, const StyleLayer&, const UnwrappedTileID&, const mat4&) override;
     bool hasData() const override;
     bool needsClipping() const override;
 
     void addGeometry(const GeometryCollection&);
 
-    void drawElements(PlainShader&, gl::GLObjectStore&);
-    void drawElements(PatternShader&, gl::GLObjectStore&);
-    void drawVertices(OutlineShader&, gl::GLObjectStore&);
-    void drawVertices(OutlinePatternShader&, gl::GLObjectStore&);
+    void drawElements(PlainShader&, gl::ObjectStore&);
+    void drawElements(PatternShader&, gl::ObjectStore&);
+    void drawVertices(OutlineShader&, gl::ObjectStore&);
+    void drawVertices(OutlinePatternShader&, gl::ObjectStore&);
 
 private:
     FillVertexBuffer vertexBuffer;
diff --git a/src/mbgl/renderer/frame_history.cpp b/src/mbgl/renderer/frame_history.cpp
index 09337c87a0..95d971dfde 100644
--- a/src/mbgl/renderer/frame_history.cpp
+++ b/src/mbgl/renderer/frame_history.cpp
@@ -57,11 +57,11 @@ bool FrameHistory::needsAnimation(const Duration& duration) const {
     return (time - previousTime) < duration;
 }
 
-void FrameHistory::upload(gl::GLObjectStore& glObjectStore) {
+void FrameHistory::upload(gl::ObjectStore& store) {
 
     if (changed) {
         const bool first = !texture.created();
-        bind(glObjectStore);
+        bind(store);
 
         if (first) {
             MBGL_CHECK_ERROR(glTexImage2D(
@@ -94,9 +94,9 @@ void FrameHistory::upload(gl::GLObjectStore& glObjectStore) {
     }
 }
 
-void FrameHistory::bind(gl::GLObjectStore& glObjectStore) {
+void FrameHistory::bind(gl::ObjectStore& store) {
     if (!texture.created()) {
-        texture.create(glObjectStore);
+        texture.create(store);
         MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture.getID()));
 #ifndef GL_ES_VERSION_2_0
         MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
diff --git a/src/mbgl/renderer/frame_history.hpp b/src/mbgl/renderer/frame_history.hpp
index c523a8531f..16f30fe8d0 100644
--- a/src/mbgl/renderer/frame_history.hpp
+++ b/src/mbgl/renderer/frame_history.hpp
@@ -3,7 +3,7 @@
 #include <array>
 
 #include <mbgl/platform/platform.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 #include <mbgl/util/chrono.hpp>
 
 namespace mbgl {
@@ -14,8 +14,8 @@ public:
     void record(const TimePoint&, float zoom, const Duration&);
 
     bool needsAnimation(const Duration&) const;
-    void bind(gl::GLObjectStore&);
-    void upload(gl::GLObjectStore&);
+    void bind(gl::ObjectStore&);
+    void upload(gl::ObjectStore&);
 
 private:
     const int width = 256;
diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp
index 5bbf1916bb..c308f02588 100644
--- a/src/mbgl/renderer/line_bucket.cpp
+++ b/src/mbgl/renderer/line_bucket.cpp
@@ -435,9 +435,9 @@ void LineBucket::addPieSliceVertex(const GeometryCoordinate& currentVertex,
     }
 }
 
-void LineBucket::upload(gl::GLObjectStore& glObjectStore) {
-    vertexBuffer.upload(glObjectStore);
-    triangleElementsBuffer.upload(glObjectStore);
+void LineBucket::upload(gl::ObjectStore& store) {
+    vertexBuffer.upload(store);
+    triangleElementsBuffer.upload(store);
 
     // From now on, we're only going to render during the translucent pass.
     uploaded = true;
@@ -458,7 +458,7 @@ bool LineBucket::needsClipping() const {
     return true;
 }
 
-void LineBucket::drawLines(LineShader& shader, gl::GLObjectStore& glObjectStore) {
+void LineBucket::drawLines(LineShader& shader, gl::ObjectStore& store) {
     GLbyte* vertex_index = BUFFER_OFFSET(0);
     GLbyte* elements_index = BUFFER_OFFSET(0);
     for (auto& group : triangleGroups) {
@@ -466,7 +466,7 @@ void LineBucket::drawLines(LineShader& shader, gl::GLObjectStore& glObjectStore)
         if (!group->elements_length) {
             continue;
         }
-        group->array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, glObjectStore);
+        group->array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
         vertex_index += group->vertex_length * vertexBuffer.itemSize;
@@ -474,7 +474,7 @@ void LineBucket::drawLines(LineShader& shader, gl::GLObjectStore& glObjectStore)
     }
 }
 
-void LineBucket::drawLineSDF(LineSDFShader& shader, gl::GLObjectStore& glObjectStore) {
+void LineBucket::drawLineSDF(LineSDFShader& shader, gl::ObjectStore& store) {
     GLbyte* vertex_index = BUFFER_OFFSET(0);
     GLbyte* elements_index = BUFFER_OFFSET(0);
     for (auto& group : triangleGroups) {
@@ -482,7 +482,7 @@ void LineBucket::drawLineSDF(LineSDFShader& shader, gl::GLObjectStore& glObjectS
         if (!group->elements_length) {
             continue;
         }
-        group->array[2].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, glObjectStore);
+        group->array[2].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
         vertex_index += group->vertex_length * vertexBuffer.itemSize;
@@ -490,7 +490,7 @@ void LineBucket::drawLineSDF(LineSDFShader& shader, gl::GLObjectStore& glObjectS
     }
 }
 
-void LineBucket::drawLinePatterns(LinepatternShader& shader, gl::GLObjectStore& glObjectStore) {
+void LineBucket::drawLinePatterns(LinepatternShader& shader, gl::ObjectStore& store) {
     GLbyte* vertex_index = BUFFER_OFFSET(0);
     GLbyte* elements_index = BUFFER_OFFSET(0);
     for (auto& group : triangleGroups) {
@@ -498,7 +498,7 @@ void LineBucket::drawLinePatterns(LinepatternShader& shader, gl::GLObjectStore&
         if (!group->elements_length) {
             continue;
         }
-        group->array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, glObjectStore);
+        group->array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
         vertex_index += group->vertex_length * vertexBuffer.itemSize;
diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp
index 8c9e38fb30..8b60be5f00 100644
--- a/src/mbgl/renderer/line_bucket.hpp
+++ b/src/mbgl/renderer/line_bucket.hpp
@@ -25,7 +25,7 @@ public:
     LineBucket(uint32_t overscaling);
     ~LineBucket() override;
 
-    void upload(gl::GLObjectStore&) override;
+    void upload(gl::ObjectStore&) override;
     void render(Painter&, const StyleLayer&, const UnwrappedTileID&, const mat4&) override;
     bool hasData() const override;
     bool needsClipping() const override;
@@ -33,9 +33,9 @@ public:
     void addGeometry(const GeometryCollection&);
     void addGeometry(const GeometryCoordinates& line);
 
-    void drawLines(LineShader&, gl::GLObjectStore&);
-    void drawLineSDF(LineSDFShader&, gl::GLObjectStore&);
-    void drawLinePatterns(LinepatternShader&, gl::GLObjectStore&);
+    void drawLines(LineShader&, gl::ObjectStore&);
+    void drawLineSDF(LineSDFShader&, gl::ObjectStore&);
+    void drawLinePatterns(LinepatternShader&, gl::ObjectStore&);
 
 private:
     struct TriangleElement {
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 1e1b37ef44..486865dc78 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -47,24 +47,24 @@
 
 using namespace mbgl;
 
-Painter::Painter(const TransformState& state_, gl::GLObjectStore& glObjectStore_)
+Painter::Painter(const TransformState& state_, gl::ObjectStore& store_)
     : state(state_),
-      glObjectStore(glObjectStore_) {
+      store(store_) {
     gl::debugging::enable();
 
-    plainShader = std::make_unique<PlainShader>(glObjectStore);
-    outlineShader = std::make_unique<OutlineShader>(glObjectStore);
-    outlinePatternShader = std::make_unique<OutlinePatternShader>(glObjectStore);
-    lineShader = std::make_unique<LineShader>(glObjectStore);
-    linesdfShader = std::make_unique<LineSDFShader>(glObjectStore);
-    linepatternShader = std::make_unique<LinepatternShader>(glObjectStore);
-    patternShader = std::make_unique<PatternShader>(glObjectStore);
-    iconShader = std::make_unique<IconShader>(glObjectStore);
-    rasterShader = std::make_unique<RasterShader>(glObjectStore);
-    sdfGlyphShader = std::make_unique<SDFGlyphShader>(glObjectStore);
-    sdfIconShader = std::make_unique<SDFIconShader>(glObjectStore);
-    collisionBoxShader = std::make_unique<CollisionBoxShader>(glObjectStore);
-    circleShader = std::make_unique<CircleShader>(glObjectStore);
+    plainShader = std::make_unique<PlainShader>(store);
+    outlineShader = std::make_unique<OutlineShader>(store);
+    outlinePatternShader = std::make_unique<OutlinePatternShader>(store);
+    lineShader = std::make_unique<LineShader>(store);
+    linesdfShader = std::make_unique<LineSDFShader>(store);
+    linepatternShader = std::make_unique<LinepatternShader>(store);
+    patternShader = std::make_unique<PatternShader>(store);
+    iconShader = std::make_unique<IconShader>(store);
+    rasterShader = std::make_unique<RasterShader>(store);
+    sdfGlyphShader = std::make_unique<SDFGlyphShader>(store);
+    sdfIconShader = std::make_unique<SDFIconShader>(store);
+    collisionBoxShader = std::make_unique<CollisionBoxShader>(store);
+    circleShader = std::make_unique<CircleShader>(store);
 
     // Reset GL values
     config.reset();
@@ -115,17 +115,17 @@ void Painter::render(const Style& style, const FrameData& frame_, SpriteAtlas& a
     {
         MBGL_DEBUG_GROUP("upload");
 
-        tileStencilBuffer.upload(glObjectStore);
-        tileBorderBuffer.upload(glObjectStore);
-        spriteAtlas->upload(glObjectStore);
-        lineAtlas->upload(glObjectStore);
-        glyphAtlas->upload(glObjectStore);
-        frameHistory.upload(glObjectStore);
-        annotationSpriteAtlas.upload(glObjectStore);
+        tileStencilBuffer.upload(store);
+        tileBorderBuffer.upload(store);
+        spriteAtlas->upload(store);
+        lineAtlas->upload(store);
+        glyphAtlas->upload(store);
+        frameHistory.upload(store);
+        annotationSpriteAtlas.upload(store);
 
         for (const auto& item : order) {
             if (item.bucket && item.bucket->needsUpload()) {
-                item.bucket->upload(glObjectStore);
+                item.bucket->upload(store);
             }
         }
     }
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index 4401a95d6e..70d5312b38 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -70,7 +70,7 @@ class CollisionBoxShader;
 struct ClipID;
 
 namespace util {
-class GLObjectStore;
+class ObjectStore;
 }
 
 struct FrameData {
@@ -84,7 +84,7 @@ struct FrameData {
 
 class Painter : private util::noncopyable {
 public:
-    Painter(const TransformState&, gl::GLObjectStore&);
+    Painter(const TransformState&, gl::ObjectStore&);
     ~Painter();
 
     void render(const Style& style,
@@ -136,7 +136,7 @@ private:
                    float scaleDivisor,
                    std::array<float, 2> texsize,
                    SDFShader& sdfShader,
-                   void (SymbolBucket::*drawSDF)(SDFShader&, gl::GLObjectStore&),
+                   void (SymbolBucket::*drawSDF)(SDFShader&, gl::ObjectStore&),
 
                    // Layout
                    RotationAlignmentType rotationAlignment,
@@ -174,7 +174,7 @@ private:
     }();
 
     const TransformState& state;
-    gl::GLObjectStore& glObjectStore;
+    gl::ObjectStore& store;
 
     FrameData frame;
 
diff --git a/src/mbgl/renderer/painter_background.cpp b/src/mbgl/renderer/painter_background.cpp
index 9f5e83d38c..3f01b74403 100644
--- a/src/mbgl/renderer/painter_background.cpp
+++ b/src/mbgl/renderer/painter_background.cpp
@@ -37,8 +37,8 @@ void Painter::renderBackground(const BackgroundLayer& layer) {
         patternShader->u_mix = properties.backgroundPattern.value.t;
         patternShader->u_opacity = properties.backgroundOpacity;
 
-        spriteAtlas->bind(true, glObjectStore);
-        backgroundPatternArray.bind(*patternShader, tileStencilBuffer, BUFFER_OFFSET(0), glObjectStore);
+        spriteAtlas->bind(true, store);
+        backgroundPatternArray.bind(*patternShader, tileStencilBuffer, BUFFER_OFFSET(0), store);
 
     } else {
         if (wireframe) {
@@ -50,7 +50,7 @@ void Painter::renderBackground(const BackgroundLayer& layer) {
         }
 
         config.program = plainShader->getID();
-        backgroundArray.bind(*plainShader, tileStencilBuffer, BUFFER_OFFSET(0), glObjectStore);
+        backgroundArray.bind(*plainShader, tileStencilBuffer, BUFFER_OFFSET(0), store);
     }
 
     config.stencilTest = GL_FALSE;
diff --git a/src/mbgl/renderer/painter_circle.cpp b/src/mbgl/renderer/painter_circle.cpp
index d748811e1a..fe4348c362 100644
--- a/src/mbgl/renderer/painter_circle.cpp
+++ b/src/mbgl/renderer/painter_circle.cpp
@@ -40,5 +40,5 @@ void Painter::renderCircle(CircleBucket& bucket,
     circleShader->u_blur = std::max<float>(properties.circleBlur, antialiasing);
     circleShader->u_opacity = properties.circleOpacity;
 
-    bucket.drawCircles(*circleShader, glObjectStore);
+    bucket.drawCircles(*circleShader, store);
 }
diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp
index 37e06922c1..f0fd498267 100644
--- a/src/mbgl/renderer/painter_clipping.cpp
+++ b/src/mbgl/renderer/painter_clipping.cpp
@@ -22,7 +22,7 @@ void Painter::drawClippingMasks(const std::map<UnwrappedTileID, ClipID>& stencil
     config.colorMask = { GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE };
     config.stencilMask = mask;
 
-    coveringPlainArray.bind(*plainShader, tileStencilBuffer, BUFFER_OFFSET_0, glObjectStore);
+    coveringPlainArray.bind(*plainShader, tileStencilBuffer, BUFFER_OFFSET_0, store);
 
     for (const auto& stencil : stencils) {
         const auto& id = stencil.first;
diff --git a/src/mbgl/renderer/painter_debug.cpp b/src/mbgl/renderer/painter_debug.cpp
index 09dcbe3b90..b55a3c1628 100644
--- a/src/mbgl/renderer/painter_debug.cpp
+++ b/src/mbgl/renderer/painter_debug.cpp
@@ -45,18 +45,18 @@ void Painter::renderDebugText(TileData& tileData, const mat4 &matrix) {
     // Draw white outline
     plainShader->u_color = {{ 1.0f, 1.0f, 1.0f, 1.0f }};
     config.lineWidth = 4.0f * frame.pixelRatio;
-    tileData.debugBucket->drawLines(*plainShader, glObjectStore);
+    tileData.debugBucket->drawLines(*plainShader, store);
 
 #ifndef GL_ES_VERSION_2_0
     // Draw line "end caps"
     MBGL_CHECK_ERROR(glPointSize(2));
-    tileData.debugBucket->drawPoints(*plainShader, glObjectStore);
+    tileData.debugBucket->drawPoints(*plainShader, store);
 #endif
 
     // Draw black text.
     plainShader->u_color = {{ 0.0f, 0.0f, 0.0f, 1.0f }};
     config.lineWidth = 2.0f * frame.pixelRatio;
-    tileData.debugBucket->drawLines(*plainShader, glObjectStore);
+    tileData.debugBucket->drawLines(*plainShader, store);
 
     config.depthFunc.reset();
     config.depthTest = GL_TRUE;
@@ -76,7 +76,7 @@ void Painter::renderDebugFrame(const mat4 &matrix) {
     plainShader->u_matrix = matrix;
 
     // draw tile outline
-    tileBorderArray.bind(*plainShader, tileBorderBuffer, BUFFER_OFFSET_0, glObjectStore);
+    tileBorderArray.bind(*plainShader, tileBorderBuffer, BUFFER_OFFSET_0, store);
     plainShader->u_color = {{ 1.0f, 0.0f, 0.0f, 1.0f }};
     config.lineWidth = 4.0f * frame.pixelRatio;
     MBGL_CHECK_ERROR(glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)tileBorderBuffer.index()));
diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp
index ed0b3eec53..51cfa1b068 100644
--- a/src/mbgl/renderer/painter_fill.cpp
+++ b/src/mbgl/renderer/painter_fill.cpp
@@ -61,7 +61,7 @@ void Painter::renderFill(FillBucket& bucket,
             static_cast<float>(frame.framebufferSize[1])
         }};
         setDepthSublayer(0);
-        bucket.drawVertices(*outlineShader, glObjectStore);
+        bucket.drawVertices(*outlineShader, store);
     }
 
     if (pattern) {
@@ -112,11 +112,11 @@ void Painter::renderFill(FillBucket& bucket,
             patternShader->u_offset_b = std::array<float, 2>{{offsetBx, offsetBy}};
 
             config.activeTexture = GL_TEXTURE0;
-            spriteAtlas->bind(true, glObjectStore);
+            spriteAtlas->bind(true, store);
 
             // Draw the actual triangles into the color & stencil buffer.
             setDepthSublayer(0);
-            bucket.drawElements(*patternShader, glObjectStore);
+            bucket.drawElements(*patternShader, store);
 
             if (properties.fillAntialias && stroke_color == fill_color) {
                 config.program = outlinePatternShader->getID();
@@ -150,10 +150,10 @@ void Painter::renderFill(FillBucket& bucket,
                 outlinePatternShader->u_offset_b = std::array<float, 2>{{offsetBx, offsetBy}};
 
                 config.activeTexture = GL_TEXTURE0;
-                spriteAtlas->bind(true, glObjectStore);
+                spriteAtlas->bind(true, store);
 
                 setDepthSublayer(2);
-                bucket.drawVertices(*outlinePatternShader, glObjectStore);
+                bucket.drawVertices(*outlinePatternShader, store);
             }
         }
     } else if (!wireframe) {
@@ -170,7 +170,7 @@ void Painter::renderFill(FillBucket& bucket,
 
             // Draw the actual triangles into the color & stencil buffer.
             setDepthSublayer(1);
-            bucket.drawElements(*plainShader, glObjectStore);
+            bucket.drawElements(*plainShader, store);
         }
     }
 
@@ -191,6 +191,6 @@ void Painter::renderFill(FillBucket& bucket,
         }};
 
         setDepthSublayer(2);
-        bucket.drawVertices(*outlineShader, glObjectStore);
+        bucket.drawVertices(*outlineShader, store);
     }
 }
diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp
index e0592b4bc1..d9e3d4037b 100644
--- a/src/mbgl/renderer/painter_line.cpp
+++ b/src/mbgl/renderer/painter_line.cpp
@@ -72,8 +72,8 @@ void Painter::renderLine(LineBucket& bucket,
         linesdfShader->u_color = color;
         linesdfShader->u_opacity = opacity;
 
-        LinePatternPos posA = lineAtlas->getDashPosition(properties.lineDasharray.value.from, layout.lineCap == LineCapType::Round, glObjectStore);
-        LinePatternPos posB = lineAtlas->getDashPosition(properties.lineDasharray.value.to, layout.lineCap == LineCapType::Round, glObjectStore);
+        LinePatternPos posA = lineAtlas->getDashPosition(properties.lineDasharray.value.from, layout.lineCap == LineCapType::Round, store);
+        LinePatternPos posB = lineAtlas->getDashPosition(properties.lineDasharray.value.to, layout.lineCap == LineCapType::Round, store);
 
         const float widthA = posA.width * properties.lineDasharray.value.fromScale * layer.dashLineWidth;
         const float widthB = posB.width * properties.lineDasharray.value.toScale * layer.dashLineWidth;
@@ -95,9 +95,9 @@ void Painter::renderLine(LineBucket& bucket,
 
         linesdfShader->u_image = 0;
         config.activeTexture = GL_TEXTURE0;
-        lineAtlas->bind(glObjectStore);
+        lineAtlas->bind(store);
 
-        bucket.drawLineSDF(*linesdfShader, glObjectStore);
+        bucket.drawLineSDF(*linesdfShader, store);
 
     } else if (!properties.linePattern.value.from.empty()) {
         optional<SpriteAtlasPosition> imagePosA = spriteAtlas->getPosition(properties.linePattern.value.from, true);
@@ -137,9 +137,9 @@ void Painter::renderLine(LineBucket& bucket,
 
         linepatternShader->u_image = 0;
         config.activeTexture = GL_TEXTURE0;
-        spriteAtlas->bind(true, glObjectStore);
+        spriteAtlas->bind(true, store);
 
-        bucket.drawLinePatterns(*linepatternShader, glObjectStore);
+        bucket.drawLinePatterns(*linepatternShader, store);
 
     } else {
         config.program = lineShader->getID();
@@ -157,6 +157,6 @@ void Painter::renderLine(LineBucket& bucket,
         lineShader->u_color = color;
         lineShader->u_opacity = opacity;
 
-        bucket.drawLines(*lineShader, glObjectStore);
+        bucket.drawLines(*lineShader, store);
     }
 }
diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp
index f00f2ebcbd..7f55e23ac2 100644
--- a/src/mbgl/renderer/painter_raster.cpp
+++ b/src/mbgl/renderer/painter_raster.cpp
@@ -34,7 +34,7 @@ void Painter::renderRaster(RasterBucket& bucket,
         config.depthTest = GL_TRUE;
         config.depthMask = GL_FALSE;
         setDepthSublayer(0);
-        bucket.drawRaster(*rasterShader, tileStencilBuffer, coveringRasterArray, glObjectStore);
+        bucket.drawRaster(*rasterShader, tileStencilBuffer, coveringRasterArray, store);
     }
 }
 
diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp
index d19d7bc498..55d2e27c11 100644
--- a/src/mbgl/renderer/painter_symbol.cpp
+++ b/src/mbgl/renderer/painter_symbol.cpp
@@ -18,7 +18,7 @@ void Painter::renderSDF(SymbolBucket &bucket,
                         float sdfFontSize,
                         std::array<float, 2> texsize,
                         SDFShader& sdfShader,
-                        void (SymbolBucket::*drawSDF)(SDFShader&, gl::GLObjectStore&),
+                        void (SymbolBucket::*drawSDF)(SDFShader&, gl::ObjectStore&),
 
                         // Layout
                         RotationAlignmentType rotationAlignment,
@@ -66,7 +66,7 @@ void Painter::renderSDF(SymbolBucket &bucket,
     sdfShader.u_zoom = (state.getZoom() - zoomAdjust) * 10; // current zoom level
 
     config.activeTexture = GL_TEXTURE1;
-    frameHistory.bind(glObjectStore);
+    frameHistory.bind(store);
     sdfShader.u_fadetexture = 1;
 
     // The default gamma value has to be adjust for the current pixelratio so that we're not
@@ -86,7 +86,7 @@ void Painter::renderSDF(SymbolBucket &bucket,
         sdfShader.u_buffer = (haloOffset - haloWidth / fontScale) / sdfPx;
 
         setDepthSublayer(0);
-        (bucket.*drawSDF)(sdfShader, glObjectStore);
+        (bucket.*drawSDF)(sdfShader, store);
     }
 
     // Then, we draw the text/icon over the halo
@@ -97,7 +97,7 @@ void Painter::renderSDF(SymbolBucket &bucket,
         sdfShader.u_buffer = (256.0f - 64.0f) / 256.0f;
 
         setDepthSublayer(1);
-        (bucket.*drawSDF)(sdfShader, glObjectStore);
+        (bucket.*drawSDF)(sdfShader, store);
     }
 }
 
@@ -153,7 +153,7 @@ void Painter::renderSymbol(SymbolBucket& bucket,
         const bool iconScaled = fontScale != 1 || frame.pixelRatio != activeSpriteAtlas->getPixelRatio() || bucket.iconsNeedLinear;
         const bool iconTransformed = layout.iconRotationAlignment == RotationAlignmentType::Map || angleOffset != 0 || state.getPitch() != 0;
         config.activeTexture = GL_TEXTURE0;
-        activeSpriteAtlas->bind(sdf || state.isChanging() || iconScaled || iconTransformed, glObjectStore);
+        activeSpriteAtlas->bind(sdf || state.isChanging() || iconScaled || iconTransformed, store);
 
         if (sdf) {
             renderSDF(bucket,
@@ -200,11 +200,11 @@ void Painter::renderSymbol(SymbolBucket& bucket,
             iconShader->u_opacity = paint.iconOpacity;
 
             config.activeTexture = GL_TEXTURE1;
-            frameHistory.bind(glObjectStore);
+            frameHistory.bind(store);
             iconShader->u_fadetexture = 1;
 
             setDepthSublayer(0);
-            bucket.drawIcons(*iconShader, glObjectStore);
+            bucket.drawIcons(*iconShader, store);
         }
     }
 
@@ -217,7 +217,7 @@ void Painter::renderSymbol(SymbolBucket& bucket,
         }
 
         config.activeTexture = GL_TEXTURE0;
-        glyphAtlas->bind(glObjectStore);
+        glyphAtlas->bind(store);
 
         renderSDF(bucket,
                   tileID,
@@ -251,7 +251,7 @@ void Painter::renderSymbol(SymbolBucket& bucket,
         config.lineWidth = 1.0f;
 
         setDepthSublayer(0);
-        bucket.drawCollisionBoxes(*collisionBoxShader, glObjectStore);
+        bucket.drawCollisionBoxes(*collisionBoxShader, store);
 
     }
 
diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp
index 18c18923f6..d6786969c9 100644
--- a/src/mbgl/renderer/raster_bucket.cpp
+++ b/src/mbgl/renderer/raster_bucket.cpp
@@ -9,9 +9,9 @@ RasterBucket::RasterBucket(gl::TexturePool& texturePool)
 : raster(texturePool) {
 }
 
-void RasterBucket::upload(gl::GLObjectStore& glObjectStore) {
+void RasterBucket::upload(gl::ObjectStore& store) {
     if (hasData()) {
-        raster.upload(glObjectStore);
+        raster.upload(store);
         uploaded = true;
     }
 }
@@ -27,9 +27,9 @@ void RasterBucket::setImage(PremultipliedImage image) {
     raster.load(std::move(image));
 }
 
-void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array, gl::GLObjectStore& glObjectStore) {
-    raster.bind(true, glObjectStore);
-    array.bind(shader, vertices, BUFFER_OFFSET_0, glObjectStore);
+void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array, gl::ObjectStore& store) {
+    raster.bind(true, store);
+    array.bind(shader, vertices, BUFFER_OFFSET_0, store);
     MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index()));
 }
 
diff --git a/src/mbgl/renderer/raster_bucket.hpp b/src/mbgl/renderer/raster_bucket.hpp
index da503dee0c..33956fedcd 100644
--- a/src/mbgl/renderer/raster_bucket.hpp
+++ b/src/mbgl/renderer/raster_bucket.hpp
@@ -13,14 +13,14 @@ class RasterBucket : public Bucket {
 public:
     RasterBucket(gl::TexturePool&);
 
-    void upload(gl::GLObjectStore&) override;
+    void upload(gl::ObjectStore&) override;
     void render(Painter&, const StyleLayer&, const UnwrappedTileID&, const mat4&) override;
     bool hasData() const override;
     bool needsClipping() const override;
 
     void setImage(PremultipliedImage);
 
-    void drawRaster(RasterShader&, StaticVertexBuffer&, VertexArrayObject&, gl::GLObjectStore&);
+    void drawRaster(RasterShader&, StaticVertexBuffer&, VertexArrayObject&, gl::ObjectStore&);
 
     Raster raster;
 };
diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp
index aaaa6d21de..2f5af330a4 100644
--- a/src/mbgl/renderer/symbol_bucket.cpp
+++ b/src/mbgl/renderer/symbol_bucket.cpp
@@ -71,14 +71,14 @@ SymbolBucket::~SymbolBucket() {
     // Do not remove. header file only contains forward definitions to unique pointers.
 }
 
-void SymbolBucket::upload(gl::GLObjectStore& glObjectStore) {
+void SymbolBucket::upload(gl::ObjectStore& store) {
     if (hasTextData()) {
-        renderData->text.vertices.upload(glObjectStore);
-        renderData->text.triangles.upload(glObjectStore);
+        renderData->text.vertices.upload(store);
+        renderData->text.triangles.upload(store);
     }
     if (hasIconData()) {
-        renderData->icon.vertices.upload(glObjectStore);
-        renderData->icon.triangles.upload(glObjectStore);
+        renderData->icon.vertices.upload(store);
+        renderData->icon.triangles.upload(store);
     }
 
     uploaded = true;
@@ -596,50 +596,50 @@ void SymbolBucket::swapRenderData() {
     }
 }
 
-void SymbolBucket::drawGlyphs(SDFShader& shader, gl::GLObjectStore& glObjectStore) {
+void SymbolBucket::drawGlyphs(SDFShader& shader, gl::ObjectStore& store) {
     GLbyte *vertex_index = BUFFER_OFFSET_0;
     GLbyte *elements_index = BUFFER_OFFSET_0;
     auto& text = renderData->text;
     for (auto &group : text.groups) {
         assert(group);
-        group->array[0].bind(shader, text.vertices, text.triangles, vertex_index, glObjectStore);
+        group->array[0].bind(shader, text.vertices, text.triangles, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group->vertex_length * text.vertices.itemSize;
         elements_index += group->elements_length * text.triangles.itemSize;
     }
 }
 
-void SymbolBucket::drawIcons(SDFShader& shader, gl::GLObjectStore& glObjectStore) {
+void SymbolBucket::drawIcons(SDFShader& shader, gl::ObjectStore& store) {
     GLbyte *vertex_index = BUFFER_OFFSET_0;
     GLbyte *elements_index = BUFFER_OFFSET_0;
     auto& icon = renderData->icon;
     for (auto &group : icon.groups) {
         assert(group);
-        group->array[0].bind(shader, icon.vertices, icon.triangles, vertex_index, glObjectStore);
+        group->array[0].bind(shader, icon.vertices, icon.triangles, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group->vertex_length * icon.vertices.itemSize;
         elements_index += group->elements_length * icon.triangles.itemSize;
     }
 }
 
-void SymbolBucket::drawIcons(IconShader& shader, gl::GLObjectStore& glObjectStore) {
+void SymbolBucket::drawIcons(IconShader& shader, gl::ObjectStore& store) {
     GLbyte *vertex_index = BUFFER_OFFSET_0;
     GLbyte *elements_index = BUFFER_OFFSET_0;
     auto& icon = renderData->icon;
     for (auto &group : icon.groups) {
         assert(group);
-        group->array[1].bind(shader, icon.vertices, icon.triangles, vertex_index, glObjectStore);
+        group->array[1].bind(shader, icon.vertices, icon.triangles, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
         vertex_index += group->vertex_length * icon.vertices.itemSize;
         elements_index += group->elements_length * icon.triangles.itemSize;
     }
 }
 
-void SymbolBucket::drawCollisionBoxes(CollisionBoxShader& shader, gl::GLObjectStore& glObjectStore) {
+void SymbolBucket::drawCollisionBoxes(CollisionBoxShader& shader, gl::ObjectStore& store) {
     GLbyte *vertex_index = BUFFER_OFFSET_0;
     auto& collisionBox = renderData->collisionBox;
     for (auto &group : collisionBox.groups) {
-        group->array[0].bind(shader, collisionBox.vertices, vertex_index, glObjectStore);
+        group->array[0].bind(shader, collisionBox.vertices, vertex_index, store);
         MBGL_CHECK_ERROR(glDrawArrays(GL_LINES, 0, group->vertex_length));
     }
 }
diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp
index a826ff0614..268bcb7c77 100644
--- a/src/mbgl/renderer/symbol_bucket.hpp
+++ b/src/mbgl/renderer/symbol_bucket.hpp
@@ -69,7 +69,7 @@ public:
     SymbolBucket(uint32_t overscaling, float zoom, const MapMode, const std::string& bucketName_, const std::string& sourceLayerName_);
     ~SymbolBucket() override;
 
-    void upload(gl::GLObjectStore&) override;
+    void upload(gl::ObjectStore&) override;
     void render(Painter&, const StyleLayer&, const UnwrappedTileID&, const mat4&) override;
     bool hasData() const override;
     bool hasTextData() const;
@@ -82,10 +82,10 @@ public:
                      GlyphAtlas&,
                      GlyphStore&);
 
-    void drawGlyphs(SDFShader&, gl::GLObjectStore&);
-    void drawIcons(SDFShader&, gl::GLObjectStore&);
-    void drawIcons(IconShader&, gl::GLObjectStore&);
-    void drawCollisionBoxes(CollisionBoxShader&, gl::GLObjectStore&);
+    void drawGlyphs(SDFShader&, gl::ObjectStore&);
+    void drawIcons(SDFShader&, gl::ObjectStore&);
+    void drawIcons(IconShader&, gl::ObjectStore&);
+    void drawCollisionBoxes(CollisionBoxShader&, gl::ObjectStore&);
 
     void parseFeatures(const GeometryTileLayer&, const Filter&);
     bool needsDependencies(GlyphStore&, SpriteStore&);
diff --git a/src/mbgl/shader/circle_shader.cpp b/src/mbgl/shader/circle_shader.cpp
index 3ec822747f..2865769ee2 100644
--- a/src/mbgl/shader/circle_shader.cpp
+++ b/src/mbgl/shader/circle_shader.cpp
@@ -7,8 +7,8 @@
 
 using namespace mbgl;
 
-CircleShader::CircleShader(gl::GLObjectStore& glObjectStore)
-    : Shader("circle", shaders::circle::vertex, shaders::circle::fragment, glObjectStore) {
+CircleShader::CircleShader(gl::ObjectStore& store)
+    : Shader("circle", shaders::circle::vertex, shaders::circle::fragment, store) {
 }
 
 void CircleShader::bind(GLbyte* offset) {
diff --git a/src/mbgl/shader/circle_shader.hpp b/src/mbgl/shader/circle_shader.hpp
index db465f4197..cd22d4c9b1 100644
--- a/src/mbgl/shader/circle_shader.hpp
+++ b/src/mbgl/shader/circle_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class CircleShader : public Shader {
 public:
-    CircleShader(gl::GLObjectStore&);
+    CircleShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/collision_box_shader.cpp b/src/mbgl/shader/collision_box_shader.cpp
index a459729c93..cf4ff81e96 100644
--- a/src/mbgl/shader/collision_box_shader.cpp
+++ b/src/mbgl/shader/collision_box_shader.cpp
@@ -7,8 +7,8 @@
 
 using namespace mbgl;
 
-CollisionBoxShader::CollisionBoxShader(gl::GLObjectStore& glObjectStore)
-    : Shader("collisionbox", shaders::collisionbox::vertex, shaders::collisionbox::fragment, glObjectStore)
+CollisionBoxShader::CollisionBoxShader(gl::ObjectStore& store)
+    : Shader("collisionbox", shaders::collisionbox::vertex, shaders::collisionbox::fragment, store)
     , a_extrude(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_extrude")))
     , a_data(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data"))) {
 }
diff --git a/src/mbgl/shader/collision_box_shader.hpp b/src/mbgl/shader/collision_box_shader.hpp
index 5867a4896d..a9b38a9849 100644
--- a/src/mbgl/shader/collision_box_shader.hpp
+++ b/src/mbgl/shader/collision_box_shader.hpp
@@ -8,7 +8,7 @@ namespace mbgl {
 
 class CollisionBoxShader : public Shader {
 public:
-    CollisionBoxShader(gl::GLObjectStore&);
+    CollisionBoxShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/icon_shader.cpp b/src/mbgl/shader/icon_shader.cpp
index 7c60f07efa..7fb0335dc8 100644
--- a/src/mbgl/shader/icon_shader.cpp
+++ b/src/mbgl/shader/icon_shader.cpp
@@ -7,8 +7,8 @@
 
 using namespace mbgl;
 
-IconShader::IconShader(gl::GLObjectStore& glObjectStore)
-    : Shader("icon", shaders::icon::vertex, shaders::icon::fragment, glObjectStore)
+IconShader::IconShader(gl::ObjectStore& store)
+    : Shader("icon", shaders::icon::vertex, shaders::icon::fragment, store)
     , a_offset(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_offset")))
     , a_data1(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data1")))
     , a_data2(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data2"))) {
diff --git a/src/mbgl/shader/icon_shader.hpp b/src/mbgl/shader/icon_shader.hpp
index 3388720da9..b8cfcabb10 100644
--- a/src/mbgl/shader/icon_shader.hpp
+++ b/src/mbgl/shader/icon_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class IconShader : public Shader {
 public:
-    IconShader(gl::GLObjectStore&);
+    IconShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/line_shader.cpp b/src/mbgl/shader/line_shader.cpp
index 82c36c2b49..f21384082f 100644
--- a/src/mbgl/shader/line_shader.cpp
+++ b/src/mbgl/shader/line_shader.cpp
@@ -7,8 +7,8 @@
 
 using namespace mbgl;
 
-LineShader::LineShader(gl::GLObjectStore& glObjectStore)
-    : Shader("line", shaders::line::vertex, shaders::line::fragment, glObjectStore)
+LineShader::LineShader(gl::ObjectStore& store)
+    : Shader("line", shaders::line::vertex, shaders::line::fragment, store)
     , a_data(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data"))) {
 }
 
diff --git a/src/mbgl/shader/line_shader.hpp b/src/mbgl/shader/line_shader.hpp
index 7e38db1656..e0d14094a6 100644
--- a/src/mbgl/shader/line_shader.hpp
+++ b/src/mbgl/shader/line_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class LineShader : public Shader {
 public:
-    LineShader(gl::GLObjectStore&);
+    LineShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/linepattern_shader.cpp b/src/mbgl/shader/linepattern_shader.cpp
index dcb0bf2ff5..a9923233af 100644
--- a/src/mbgl/shader/linepattern_shader.cpp
+++ b/src/mbgl/shader/linepattern_shader.cpp
@@ -7,8 +7,8 @@
 
 using namespace mbgl;
 
-LinepatternShader::LinepatternShader(gl::GLObjectStore& glObjectStore)
-    : Shader("linepattern", shaders::linepattern::vertex, shaders::linepattern::fragment, glObjectStore)
+LinepatternShader::LinepatternShader(gl::ObjectStore& store)
+    : Shader("linepattern", shaders::linepattern::vertex, shaders::linepattern::fragment, store)
     , a_data(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data"))) {
 }
 
diff --git a/src/mbgl/shader/linepattern_shader.hpp b/src/mbgl/shader/linepattern_shader.hpp
index 3cb91eae9d..c34c1a5292 100644
--- a/src/mbgl/shader/linepattern_shader.hpp
+++ b/src/mbgl/shader/linepattern_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class LinepatternShader : public Shader {
 public:
-    LinepatternShader(gl::GLObjectStore&);
+    LinepatternShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/linesdf_shader.cpp b/src/mbgl/shader/linesdf_shader.cpp
index ad4d43013b..b316d2562d 100644
--- a/src/mbgl/shader/linesdf_shader.cpp
+++ b/src/mbgl/shader/linesdf_shader.cpp
@@ -7,8 +7,8 @@
 
 using namespace mbgl;
 
-LineSDFShader::LineSDFShader(gl::GLObjectStore& glObjectStore)
-    : Shader("linesdfpattern", shaders::linesdfpattern::vertex, shaders::linesdfpattern::fragment, glObjectStore)
+LineSDFShader::LineSDFShader(gl::ObjectStore& store)
+    : Shader("linesdfpattern", shaders::linesdfpattern::vertex, shaders::linesdfpattern::fragment, store)
     , a_data(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data"))) {
 }
 
diff --git a/src/mbgl/shader/linesdf_shader.hpp b/src/mbgl/shader/linesdf_shader.hpp
index 8465952dac..8791f243c0 100644
--- a/src/mbgl/shader/linesdf_shader.hpp
+++ b/src/mbgl/shader/linesdf_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class LineSDFShader : public Shader {
 public:
-    LineSDFShader(gl::GLObjectStore&);
+    LineSDFShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/outline_shader.cpp b/src/mbgl/shader/outline_shader.cpp
index 8c7458327f..58a647f375 100644
--- a/src/mbgl/shader/outline_shader.cpp
+++ b/src/mbgl/shader/outline_shader.cpp
@@ -7,8 +7,8 @@
 
 using namespace mbgl;
 
-OutlineShader::OutlineShader(gl::GLObjectStore& glObjectStore)
-    : Shader("outline", shaders::outline::vertex, shaders::outline::fragment, glObjectStore) {
+OutlineShader::OutlineShader(gl::ObjectStore& store)
+    : Shader("outline", shaders::outline::vertex, shaders::outline::fragment, store) {
 }
 
 void OutlineShader::bind(GLbyte* offset) {
diff --git a/src/mbgl/shader/outline_shader.hpp b/src/mbgl/shader/outline_shader.hpp
index ba6937bb9f..22b9013afd 100644
--- a/src/mbgl/shader/outline_shader.hpp
+++ b/src/mbgl/shader/outline_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class OutlineShader : public Shader {
 public:
-    OutlineShader(gl::GLObjectStore&);
+    OutlineShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/outlinepattern_shader.cpp b/src/mbgl/shader/outlinepattern_shader.cpp
index 44b76b74c0..5ffa458a4f 100644
--- a/src/mbgl/shader/outlinepattern_shader.cpp
+++ b/src/mbgl/shader/outlinepattern_shader.cpp
@@ -7,11 +7,11 @@
 
 using namespace mbgl;
 
-OutlinePatternShader::OutlinePatternShader(gl::GLObjectStore& glObjectStore)
+OutlinePatternShader::OutlinePatternShader(gl::ObjectStore& store)
     : Shader(
         "outlinepattern",
         shaders::outlinepattern::vertex, shaders::outlinepattern::fragment,
-        glObjectStore
+        store
     ) {
 }
 
diff --git a/src/mbgl/shader/outlinepattern_shader.hpp b/src/mbgl/shader/outlinepattern_shader.hpp
index c0fc5242d1..e124923b6f 100644
--- a/src/mbgl/shader/outlinepattern_shader.hpp
+++ b/src/mbgl/shader/outlinepattern_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class OutlinePatternShader : public Shader {
 public:
-    OutlinePatternShader(gl::GLObjectStore&);
+    OutlinePatternShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/pattern_shader.cpp b/src/mbgl/shader/pattern_shader.cpp
index 4f52df59fb..64a72d1451 100644
--- a/src/mbgl/shader/pattern_shader.cpp
+++ b/src/mbgl/shader/pattern_shader.cpp
@@ -7,11 +7,11 @@
 
 using namespace mbgl;
 
-PatternShader::PatternShader(gl::GLObjectStore& glObjectStore)
+PatternShader::PatternShader(gl::ObjectStore& store)
     : Shader(
         "pattern",
         shaders::pattern::vertex, shaders::pattern::fragment,
-        glObjectStore
+        store
     ) {
 }
 
diff --git a/src/mbgl/shader/pattern_shader.hpp b/src/mbgl/shader/pattern_shader.hpp
index b0d075247e..ae515c1948 100644
--- a/src/mbgl/shader/pattern_shader.hpp
+++ b/src/mbgl/shader/pattern_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class PatternShader : public Shader {
 public:
-    PatternShader(gl::GLObjectStore&);
+    PatternShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/plain_shader.cpp b/src/mbgl/shader/plain_shader.cpp
index 49d26ffa3c..c030a2d7b3 100644
--- a/src/mbgl/shader/plain_shader.cpp
+++ b/src/mbgl/shader/plain_shader.cpp
@@ -7,8 +7,8 @@
 
 using namespace mbgl;
 
-PlainShader::PlainShader(gl::GLObjectStore& glObjectStore)
-    : Shader("fill", shaders::fill::vertex, shaders::fill::fragment, glObjectStore) {
+PlainShader::PlainShader(gl::ObjectStore& store)
+    : Shader("fill", shaders::fill::vertex, shaders::fill::fragment, store) {
 }
 
 void PlainShader::bind(GLbyte* offset) {
diff --git a/src/mbgl/shader/plain_shader.hpp b/src/mbgl/shader/plain_shader.hpp
index bb6a81b7eb..7edf4b4b19 100644
--- a/src/mbgl/shader/plain_shader.hpp
+++ b/src/mbgl/shader/plain_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class PlainShader : public Shader {
 public:
-    PlainShader(gl::GLObjectStore&);
+    PlainShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/raster_shader.cpp b/src/mbgl/shader/raster_shader.cpp
index 77bcf40008..e5e290bedd 100644
--- a/src/mbgl/shader/raster_shader.cpp
+++ b/src/mbgl/shader/raster_shader.cpp
@@ -7,8 +7,8 @@
 
 using namespace mbgl;
 
-RasterShader::RasterShader(gl::GLObjectStore& glObjectStore)
-    : Shader("raster", shaders::raster::vertex, shaders::raster::fragment, glObjectStore) {
+RasterShader::RasterShader(gl::ObjectStore& store)
+    : Shader("raster", shaders::raster::vertex, shaders::raster::fragment, store) {
 }
 
 void RasterShader::bind(GLbyte* offset) {
diff --git a/src/mbgl/shader/raster_shader.hpp b/src/mbgl/shader/raster_shader.hpp
index 0e445d5cc2..ee53385a0b 100644
--- a/src/mbgl/shader/raster_shader.hpp
+++ b/src/mbgl/shader/raster_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class RasterShader : public Shader {
 public:
-    RasterShader(gl::GLObjectStore&);
+    RasterShader(gl::ObjectStore&);
 
     void bind(GLbyte *offset) final;
 
diff --git a/src/mbgl/shader/sdf_shader.cpp b/src/mbgl/shader/sdf_shader.cpp
index 25b9f764d7..76ea1e3b4d 100644
--- a/src/mbgl/shader/sdf_shader.cpp
+++ b/src/mbgl/shader/sdf_shader.cpp
@@ -7,8 +7,8 @@
 
 using namespace mbgl;
 
-SDFShader::SDFShader(gl::GLObjectStore& glObjectStore)
-    : Shader("sdf", shaders::sdf::vertex, shaders::sdf::fragment, glObjectStore)
+SDFShader::SDFShader(gl::ObjectStore& store)
+    : Shader("sdf", shaders::sdf::vertex, shaders::sdf::fragment, store)
     , a_offset(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_offset")))
     , a_data1(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data1")))
     , a_data2(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data2"))) {
diff --git a/src/mbgl/shader/sdf_shader.hpp b/src/mbgl/shader/sdf_shader.hpp
index c98734c0a4..f067c30aeb 100644
--- a/src/mbgl/shader/sdf_shader.hpp
+++ b/src/mbgl/shader/sdf_shader.hpp
@@ -7,7 +7,7 @@ namespace mbgl {
 
 class SDFShader : public Shader {
 public:
-    SDFShader(gl::GLObjectStore&);
+    SDFShader(gl::ObjectStore&);
 
     UniformMatrix<4>                u_matrix        = {"u_matrix",        *this};
     Uniform<std::array<GLfloat, 2>> u_extrude_scale = {"u_extrude_scale", *this};
@@ -29,13 +29,13 @@ protected:
 
 class SDFGlyphShader : public SDFShader {
 public:
-    SDFGlyphShader(gl::GLObjectStore& glObjectStore) : SDFShader(glObjectStore) {}
+    SDFGlyphShader(gl::ObjectStore& store) : SDFShader(store) {}
     void bind(GLbyte *offset) final;
 };
 
 class SDFIconShader : public SDFShader {
 public:
-    SDFIconShader(gl::GLObjectStore& glObjectStore) : SDFShader(glObjectStore) {}
+    SDFIconShader(gl::ObjectStore& store) : SDFShader(store) {}
     void bind(GLbyte *offset) final;
 };
 
diff --git a/src/mbgl/shader/shader.cpp b/src/mbgl/shader/shader.cpp
index b0536cda94..a4c6719bba 100644
--- a/src/mbgl/shader/shader.cpp
+++ b/src/mbgl/shader/shader.cpp
@@ -13,19 +13,19 @@
 
 namespace mbgl {
 
-Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSource, gl::GLObjectStore& glObjectStore)
+Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSource, gl::ObjectStore& store)
     : name(name_)
 {
     util::stopwatch stopwatch("shader compilation", Event::Shader);
 
-    program.create(glObjectStore);
-    vertexShader.create(glObjectStore);
+    program.create(store);
+    vertexShader.create(store);
     if (!compileShader(vertexShader, &vertSource)) {
         Log::Error(Event::Shader, "Vertex shader %s failed to compile: %s", name, vertSource);
         throw util::ShaderException(std::string { "Vertex shader " } + name + " failed to compile");
     }
 
-    fragmentShader.create(glObjectStore);
+    fragmentShader.create(store);
     if (!compileShader(fragmentShader, &fragSource)) {
         Log::Error(Event::Shader, "Fragment shader %s failed to compile: %s", name, fragSource);
         throw util::ShaderException(std::string { "Fragment shader " } + name + " failed to compile");
diff --git a/src/mbgl/shader/shader.hpp b/src/mbgl/shader/shader.hpp
index fd000e9cdd..b9ca09e61b 100644
--- a/src/mbgl/shader/shader.hpp
+++ b/src/mbgl/shader/shader.hpp
@@ -1,14 +1,14 @@
 #pragma once
 
 #include <mbgl/gl/gl.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 #include <mbgl/util/noncopyable.hpp>
 
 namespace mbgl {
 
 class Shader : private util::noncopyable {
 public:
-    Shader(const GLchar *name, const GLchar *vertex, const GLchar *fragment, gl::GLObjectStore&);
+    Shader(const GLchar *name, const GLchar *vertex, const GLchar *fragment, gl::ObjectStore&);
 
     ~Shader();
     const GLchar *name;
diff --git a/src/mbgl/sprite/sprite_atlas.cpp b/src/mbgl/sprite/sprite_atlas.cpp
index 6595d7137d..d4d462b339 100644
--- a/src/mbgl/sprite/sprite_atlas.cpp
+++ b/src/mbgl/sprite/sprite_atlas.cpp
@@ -142,9 +142,9 @@ void SpriteAtlas::copy(const Holder& holder, const bool wrap) {
     dirty = true;
 }
 
-void SpriteAtlas::upload(gl::GLObjectStore& glObjectStore) {
+void SpriteAtlas::upload(gl::ObjectStore& store) {
     if (dirty) {
-        bind(false, glObjectStore);
+        bind(false, store);
     }
 }
 
@@ -179,13 +179,13 @@ void SpriteAtlas::updateDirty() {
     }
 }
 
-void SpriteAtlas::bind(bool linear, gl::GLObjectStore& glObjectStore) {
+void SpriteAtlas::bind(bool linear, gl::ObjectStore& store) {
     if (!data) {
         return; // Empty atlas
     }
 
     if (!texture.created()) {
-        texture.create(glObjectStore);
+        texture.create(store);
         MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture.getID()));
 #ifndef GL_ES_VERSION_2_0
         MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
diff --git a/src/mbgl/sprite/sprite_atlas.hpp b/src/mbgl/sprite/sprite_atlas.hpp
index 891f48fa24..6bbdee190d 100644
--- a/src/mbgl/sprite/sprite_atlas.hpp
+++ b/src/mbgl/sprite/sprite_atlas.hpp
@@ -2,7 +2,7 @@
 
 #include <mbgl/geometry/binpack.hpp>
 #include <mbgl/gl/gl.hpp>
-#include <mbgl/gl/gl_object_store.hpp>
+#include <mbgl/gl/object_store.hpp>
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/ptr.hpp>
 #include <mbgl/util/optional.hpp>
@@ -51,14 +51,14 @@ public:
     optional<SpriteAtlasPosition> getPosition(const std::string& name, bool repeating = false);
 
     // Binds the atlas texture to the GPU, and uploads data if it is out of date.
-    void bind(bool linear, gl::GLObjectStore&);
+    void bind(bool linear, gl::ObjectStore&);
 
     // Updates sprites in the atlas texture that may have changed in the source SpriteStore object.
     void updateDirty();
 
     // Uploads the texture to the GPU to be available when we need it. This is a lazy operation;
     // the texture is only bound when the data is out of date (=dirty).
-    void upload(gl::GLObjectStore&);
+    void upload(gl::ObjectStore&);
 
     inline dimension getWidth() const { return width; }
     inline dimension getHeight() const { return height; }
diff --git a/src/mbgl/util/raster.cpp b/src/mbgl/util/raster.cpp
index a74b73a016..1bcb2f27eb 100644
--- a/src/mbgl/util/raster.cpp
+++ b/src/mbgl/util/raster.cpp
@@ -37,14 +37,14 @@ void Raster::load(PremultipliedImage image) {
 }
 
 
-void Raster::bind(bool linear, gl::GLObjectStore& glObjectStore) {
+void Raster::bind(bool linear, gl::ObjectStore& store) {
     if (!width || !height) {
         Log::Error(Event::OpenGL, "trying to bind texture without dimension");
         return;
     }
 
     if (img.data && !textured) {
-        upload(glObjectStore);
+        upload(store);
     } else if (textured) {
         MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, textureID));
     }
@@ -57,9 +57,9 @@ void Raster::bind(bool linear, gl::GLObjectStore& glObjectStore) {
     }
 }
 
-void Raster::upload(gl::GLObjectStore& glObjectStore) {
+void Raster::upload(gl::ObjectStore& store) {
     if (img.data && !textured) {
-        textureID = texturePool.getTextureID(glObjectStore);
+        textureID = texturePool.getTextureID(store);
         MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, textureID));
 #ifndef GL_ES_VERSION_2_0
         MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
diff --git a/src/mbgl/util/raster.hpp b/src/mbgl/util/raster.hpp
index 8eef8d6c75..ff16112d90 100644
--- a/src/mbgl/util/raster.hpp
+++ b/src/mbgl/util/raster.hpp
@@ -20,10 +20,10 @@ public:
     void load(PremultipliedImage);
 
     // bind current texture
-    void bind(bool linear, gl::GLObjectStore&);
+    void bind(bool linear, gl::ObjectStore&);
 
     // uploads the texture if it hasn't been uploaded yet.
-    void upload(gl::GLObjectStore&);
+    void upload(gl::ObjectStore&);
 
     // loaded status
     bool isLoaded() const;