[core] Thread GLObjectStore through to Holder objects

This eliminates the reliance on ThreadContext to provide GLObjectStore, and statically enforces that GL cleanup functions happen only when GLObjectStore::performCleanup is called.

With the elimination of the Map thread, this becomes important because there may be multiple GLObjectStore's per-thread, and Map will need to ensure that the correct context is active when calling GLObjectStore::performCleanup.

22 files changed, 135 insertions, 119 deletions

diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp
index e50345d0eb..85f97688dd 100644
--- a/src/mbgl/renderer/bucket.hpp
+++ b/src/mbgl/renderer/bucket.hpp
@@ -18,13 +18,17 @@ class StyleLayer;
 class TileID;
 class CollisionTile;
 
+namespace gl {
+class GLObjectStore;
+}
+
 class Bucket : private util::noncopyable {
 public:
     Bucket() : uploaded(false) {}
 
     // 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() = 0;
+    virtual void upload(gl::GLObjectStore&) = 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 1ebe8ffaf3..fcead38c33 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() {
-    vertexBuffer_.upload();
-    elementsBuffer_.upload();
+void CircleBucket::upload(gl::GLObjectStore& glObjectStore) {
+    vertexBuffer_.upload(glObjectStore);
+    elementsBuffer_.upload(glObjectStore);
     uploaded = true;
 }
 
@@ -73,7 +73,7 @@ void CircleBucket::addGeometry(const GeometryCollection& geometryCollection) {
     }
 }
 
-void CircleBucket::drawCircles(CircleShader& shader) {
+void CircleBucket::drawCircles(CircleShader& shader, gl::GLObjectStore& glObjectStore) {
     GLbyte* vertexIndex = BUFFER_OFFSET(0);
     GLbyte* elementsIndex = BUFFER_OFFSET(0);
 
@@ -82,7 +82,7 @@ void CircleBucket::drawCircles(CircleShader& shader) {
 
         if (!group->elements_length) continue;
 
-        group->array[0].bind(shader, vertexBuffer_, elementsBuffer_, vertexIndex);
+        group->array[0].bind(shader, vertexBuffer_, elementsBuffer_, vertexIndex, glObjectStore);
 
         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 d098a7a686..875e5bb4a9 100644
--- a/src/mbgl/renderer/circle_bucket.hpp
+++ b/src/mbgl/renderer/circle_bucket.hpp
@@ -20,13 +20,13 @@ public:
     CircleBucket();
     ~CircleBucket() override;
 
-    void upload() override;
+    void upload(gl::GLObjectStore&) override;
     void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override;
 
     bool hasData() const override;
     void addGeometry(const GeometryCollection&);
 
-    void drawCircles(CircleShader& shader);
+    void drawCircles(CircleShader&, gl::GLObjectStore&);
 
 private:
     CircleVertexBuffer vertexBuffer_;
diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp
index 909316a343..947783ddb8 100644
--- a/src/mbgl/renderer/debug_bucket.cpp
+++ b/src/mbgl/renderer/debug_bucket.cpp
@@ -30,12 +30,12 @@ DebugBucket::DebugBucket(const TileID id, const TileData::State state_, optional
     }
 }
 
-void DebugBucket::drawLines(PlainShader& shader) {
-    array.bind(shader, fontBuffer, BUFFER_OFFSET_0);
+void DebugBucket::drawLines(PlainShader& shader, gl::GLObjectStore& glObjectStore) {
+    array.bind(shader, fontBuffer, BUFFER_OFFSET_0, glObjectStore);
     MBGL_CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)(fontBuffer.index())));
 }
 
-void DebugBucket::drawPoints(PlainShader& shader) {
-    array.bind(shader, fontBuffer, BUFFER_OFFSET_0);
+void DebugBucket::drawPoints(PlainShader& shader, gl::GLObjectStore& glObjectStore) {
+    array.bind(shader, fontBuffer, BUFFER_OFFSET_0, glObjectStore);
     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 9338f65157..f12452751c 100644
--- a/src/mbgl/renderer/debug_bucket.hpp
+++ b/src/mbgl/renderer/debug_bucket.hpp
@@ -11,6 +11,10 @@ namespace mbgl {
 
 class PlainShader;
 
+namespace util {
+class GLObjectStore;
+}
+
 class DebugBucket : private util::noncopyable {
 public:
     DebugBucket(TileID id, TileData::State,
@@ -18,8 +22,8 @@ public:
                 optional<SystemTimePoint> expires,
                 MapDebugOptions);
 
-    void drawLines(PlainShader& shader);
-    void drawPoints(PlainShader& shader);
+    void drawLines(PlainShader&, gl::GLObjectStore&);
+    void drawPoints(PlainShader&, gl::GLObjectStore&);
 
     const TileData::State state;
     const optional<SystemTimePoint> modified;
diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp
index a8b63f58dd..d3a4bc2b57 100644
--- a/src/mbgl/renderer/fill_bucket.cpp
+++ b/src/mbgl/renderer/fill_bucket.cpp
@@ -186,10 +186,10 @@ void FillBucket::tessellate() {
     lineGroup.vertex_length += total_vertex_count;
 }
 
-void FillBucket::upload() {
-    vertexBuffer.upload();
-    triangleElementsBuffer.upload();
-    lineElementsBuffer.upload();
+void FillBucket::upload(gl::GLObjectStore& glObjectStore) {
+    vertexBuffer.upload(glObjectStore);
+    triangleElementsBuffer.upload(glObjectStore);
+    lineElementsBuffer.upload(glObjectStore);
 
     // From now on, we're going to render during the opaque and translucent pass.
     uploaded = true;
@@ -206,36 +206,36 @@ bool FillBucket::hasData() const {
     return !triangleGroups.empty() || !lineGroups.empty();
 }
 
-void FillBucket::drawElements(PlainShader& shader) {
+void FillBucket::drawElements(PlainShader& shader, gl::GLObjectStore& glObjectStore) {
     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);
+        group->array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, glObjectStore);
         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) {
+void FillBucket::drawElements(PatternShader& shader, gl::GLObjectStore& glObjectStore) {
     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);
+        group->array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, glObjectStore);
         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) {
+void FillBucket::drawVertices(OutlineShader& shader, gl::GLObjectStore& glObjectStore) {
     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);
+        group->array[0].bind(shader, vertexBuffer, lineElementsBuffer, vertex_index, glObjectStore);
         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 9b2022af50..b3b46f030b 100644
--- a/src/mbgl/renderer/fill_bucket.hpp
+++ b/src/mbgl/renderer/fill_bucket.hpp
@@ -32,16 +32,16 @@ public:
     FillBucket();
     ~FillBucket() override;
 
-    void upload() override;
+    void upload(gl::GLObjectStore&) override;
     void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override;
     bool hasData() const override;
 
     void addGeometry(const GeometryCollection&);
     void tessellate();
 
-    void drawElements(PlainShader& shader);
-    void drawElements(PatternShader& shader);
-    void drawVertices(OutlineShader& shader);
+    void drawElements(PlainShader&, gl::GLObjectStore&);
+    void drawElements(PatternShader&, gl::GLObjectStore&);
+    void drawVertices(OutlineShader&, gl::GLObjectStore&);
 
 private:
     TESSalloc *allocator;
diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp
index 51b735daa0..ba50e6b1f0 100644
--- a/src/mbgl/renderer/line_bucket.cpp
+++ b/src/mbgl/renderer/line_bucket.cpp
@@ -418,9 +418,9 @@ void LineBucket::addPieSliceVertex(const Coordinate& currentVertex,
     }
 }
 
-void LineBucket::upload() {
-    vertexBuffer.upload();
-    triangleElementsBuffer.upload();
+void LineBucket::upload(gl::GLObjectStore& glObjectStore) {
+    vertexBuffer.upload(glObjectStore);
+    triangleElementsBuffer.upload(glObjectStore);
 
     // From now on, we're only going to render during the translucent pass.
     uploaded = true;
@@ -437,7 +437,7 @@ bool LineBucket::hasData() const {
     return !triangleGroups.empty();
 }
 
-void LineBucket::drawLines(LineShader& shader) {
+void LineBucket::drawLines(LineShader& shader, gl::GLObjectStore& glObjectStore) {
     GLbyte* vertex_index = BUFFER_OFFSET(0);
     GLbyte* elements_index = BUFFER_OFFSET(0);
     for (auto& group : triangleGroups) {
@@ -445,7 +445,7 @@ void LineBucket::drawLines(LineShader& shader) {
         if (!group->elements_length) {
             continue;
         }
-        group->array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
+        group->array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, glObjectStore);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
         vertex_index += group->vertex_length * vertexBuffer.itemSize;
@@ -453,7 +453,7 @@ void LineBucket::drawLines(LineShader& shader) {
     }
 }
 
-void LineBucket::drawLineSDF(LineSDFShader& shader) {
+void LineBucket::drawLineSDF(LineSDFShader& shader, gl::GLObjectStore& glObjectStore) {
     GLbyte* vertex_index = BUFFER_OFFSET(0);
     GLbyte* elements_index = BUFFER_OFFSET(0);
     for (auto& group : triangleGroups) {
@@ -461,7 +461,7 @@ void LineBucket::drawLineSDF(LineSDFShader& shader) {
         if (!group->elements_length) {
             continue;
         }
-        group->array[2].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
+        group->array[2].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, glObjectStore);
         MBGL_CHECK_ERROR(glDrawElements(GL_TRIANGLES, group->elements_length * 3, GL_UNSIGNED_SHORT,
                                         elements_index));
         vertex_index += group->vertex_length * vertexBuffer.itemSize;
@@ -469,7 +469,7 @@ void LineBucket::drawLineSDF(LineSDFShader& shader) {
     }
 }
 
-void LineBucket::drawLinePatterns(LinepatternShader& shader) {
+void LineBucket::drawLinePatterns(LinepatternShader& shader, gl::GLObjectStore& glObjectStore) {
     GLbyte* vertex_index = BUFFER_OFFSET(0);
     GLbyte* elements_index = BUFFER_OFFSET(0);
     for (auto& group : triangleGroups) {
@@ -477,7 +477,7 @@ void LineBucket::drawLinePatterns(LinepatternShader& shader) {
         if (!group->elements_length) {
             continue;
         }
-        group->array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
+        group->array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index, glObjectStore);
         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 883f446b4a..dd0ce4ff29 100644
--- a/src/mbgl/renderer/line_bucket.hpp
+++ b/src/mbgl/renderer/line_bucket.hpp
@@ -27,16 +27,16 @@ public:
     LineBucket(float overscaling);
     ~LineBucket() override;
 
-    void upload() override;
+    void upload(gl::GLObjectStore&) override;
     void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override;
     bool hasData() const override;
 
     void addGeometry(const GeometryCollection&);
     void addGeometry(const std::vector<Coordinate>& line);
 
-    void drawLines(LineShader& shader);
-    void drawLineSDF(LineSDFShader& shader);
-    void drawLinePatterns(LinepatternShader& shader);
+    void drawLines(LineShader&, gl::GLObjectStore&);
+    void drawLineSDF(LineSDFShader&, gl::GLObjectStore&);
+    void drawLinePatterns(LinepatternShader&, gl::GLObjectStore&);
 
 private:
     struct TriangleElement {
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index ccee950c73..da3551aa74 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -46,23 +46,25 @@
 
 using namespace mbgl;
 
-Painter::Painter(MapData& data_, TransformState& state_)
-    : data(data_), state(state_) {
+Painter::Painter(MapData& data_, TransformState& state_, gl::GLObjectStore& glObjectStore_)
+    : data(data_),
+      state(state_),
+      glObjectStore(glObjectStore_) {
     gl::debugging::enable();
 
-    plainShader = std::make_unique<PlainShader>();
-    outlineShader = std::make_unique<OutlineShader>();
-    lineShader = std::make_unique<LineShader>();
-    linesdfShader = std::make_unique<LineSDFShader>();
-    linepatternShader = std::make_unique<LinepatternShader>();
-    patternShader = std::make_unique<PatternShader>();
-    iconShader = std::make_unique<IconShader>();
-    rasterShader = std::make_unique<RasterShader>();
-    sdfGlyphShader = std::make_unique<SDFGlyphShader>();
-    sdfIconShader = std::make_unique<SDFIconShader>();
-    dotShader = std::make_unique<DotShader>();
-    collisionBoxShader = std::make_unique<CollisionBoxShader>();
-    circleShader = std::make_unique<CircleShader>();
+    plainShader = std::make_unique<PlainShader>(glObjectStore);
+    outlineShader = std::make_unique<OutlineShader>(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);
+    dotShader = std::make_unique<DotShader>(glObjectStore);
+    collisionBoxShader = std::make_unique<CollisionBoxShader>(glObjectStore);
+    circleShader = std::make_unique<CircleShader>(glObjectStore);
 
     // Reset GL values
     config.reset();
@@ -108,16 +110,16 @@ void Painter::render(const Style& style, const FrameData& frame_, SpriteAtlas& a
     {
         MBGL_DEBUG_GROUP("upload");
 
-        tileStencilBuffer.upload();
-        tileBorderBuffer.upload();
-        spriteAtlas->upload();
-        lineAtlas->upload();
-        glyphAtlas->upload();
-        annotationSpriteAtlas.upload();
+        tileStencilBuffer.upload(glObjectStore);
+        tileBorderBuffer.upload(glObjectStore);
+        spriteAtlas->upload(glObjectStore);
+        lineAtlas->upload(glObjectStore);
+        glyphAtlas->upload(glObjectStore);
+        annotationSpriteAtlas.upload(glObjectStore);
 
         for (const auto& item : order) {
             if (item.bucket && item.bucket->needsUpload()) {
-                item.bucket->upload();
+                item.bucket->upload(glObjectStore);
             }
         }
     }
@@ -315,9 +317,9 @@ void Painter::renderBackground(const BackgroundLayer& layer) {
         patternShader->u_patternmatrix_b = matrixB;
 
         VertexArrayObject::Unbind();
-        backgroundBuffer.bind();
+        backgroundBuffer.bind(glObjectStore);
         patternShader->bind(0);
-        spriteAtlas->bind(true);
+        spriteAtlas->bind(true, glObjectStore);
     } else {
         Color color = properties.color;
         color[0] *= properties.opacity;
@@ -328,7 +330,7 @@ void Painter::renderBackground(const BackgroundLayer& layer) {
         config.program = plainShader->getID();
         plainShader->u_matrix = identityMatrix;
         plainShader->u_color = color;
-        backgroundArray.bind(*plainShader, backgroundBuffer, BUFFER_OFFSET(0));
+        backgroundArray.bind(*plainShader, backgroundBuffer, BUFFER_OFFSET(0), glObjectStore);
     }
 
     config.stencilTest = GL_FALSE;
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index 8ab0a49806..83d051359b 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -66,9 +66,13 @@ class CollisionBoxShader;
 
 struct ClipID;
 
+namespace util {
+class GLObjectStore;
+}
+
 class Painter : private util::noncopyable {
 public:
-    Painter(MapData&, TransformState&);
+    Painter(MapData&, TransformState&, gl::GLObjectStore&);
     ~Painter();
 
     void render(const Style& style,
@@ -118,7 +122,7 @@ private:
                    float scaleDivisor,
                    std::array<float, 2> texsize,
                    SDFShader& sdfShader,
-                   void (SymbolBucket::*drawSDF)(SDFShader&));
+                   void (SymbolBucket::*drawSDF)(SDFShader&, gl::GLObjectStore&));
 
     void setDepthSublayer(int n);
 
@@ -142,6 +146,8 @@ private:
 
     MapData& data;
     TransformState& state;
+    gl::GLObjectStore& glObjectStore;
+
     FrameData frame;
 
     int indent = 0;
diff --git a/src/mbgl/renderer/painter_circle.cpp b/src/mbgl/renderer/painter_circle.cpp
index 9965e3ab7a..4ae562d674 100644
--- a/src/mbgl/renderer/painter_circle.cpp
+++ b/src/mbgl/renderer/painter_circle.cpp
@@ -46,5 +46,5 @@ void Painter::renderCircle(CircleBucket& bucket,
     circleShader->u_blur = std::max<float>(properties.blur, antialiasing);
     circleShader->u_size = properties.radius;
 
-    bucket.drawCircles(*circleShader);
+    bucket.drawCircles(*circleShader, glObjectStore);
 }
diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp
index f3f8a647d4..aed4c45869 100644
--- a/src/mbgl/renderer/painter_clipping.cpp
+++ b/src/mbgl/renderer/painter_clipping.cpp
@@ -21,7 +21,7 @@ void Painter::drawClippingMasks(const std::map<TileID, ClipID>& stencils) {
     config.colorMask = { GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE };
     config.stencilMask = mask;
 
-    coveringPlainArray.bind(*plainShader, tileStencilBuffer, BUFFER_OFFSET_0);
+    coveringPlainArray.bind(*plainShader, tileStencilBuffer, BUFFER_OFFSET_0, glObjectStore);
 
     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 756c5e41ea..575bffe53f 100644
--- a/src/mbgl/renderer/painter_debug.cpp
+++ b/src/mbgl/renderer/painter_debug.cpp
@@ -39,18 +39,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 * data.pixelRatio;
-    tileData.debugBucket->drawLines(*plainShader);
+    tileData.debugBucket->drawLines(*plainShader, glObjectStore);
 
 #ifndef GL_ES_VERSION_2_0
     // Draw line "end caps"
     MBGL_CHECK_ERROR(glPointSize(2));
-    tileData.debugBucket->drawPoints(*plainShader);
+    tileData.debugBucket->drawPoints(*plainShader, glObjectStore);
 #endif
 
     // Draw black text.
     plainShader->u_color = {{ 0.0f, 0.0f, 0.0f, 1.0f }};
     config.lineWidth = 2.0f * data.pixelRatio;
-    tileData.debugBucket->drawLines(*plainShader);
+    tileData.debugBucket->drawLines(*plainShader, glObjectStore);
 
     config.depthFunc.reset();
     config.depthTest = GL_TRUE;
@@ -70,7 +70,7 @@ void Painter::renderDebugFrame(const mat4 &matrix) {
     plainShader->u_matrix = matrix;
 
     // draw tile outline
-    tileBorderArray.bind(*plainShader, tileBorderBuffer, BUFFER_OFFSET_0);
+    tileBorderArray.bind(*plainShader, tileBorderBuffer, BUFFER_OFFSET_0, glObjectStore);
     plainShader->u_color = {{ 1.0f, 0.0f, 0.0f, 1.0f }};
     config.lineWidth = 4.0f * data.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 28f64c1baf..cd54645c2b 100644
--- a/src/mbgl/renderer/painter_fill.cpp
+++ b/src/mbgl/renderer/painter_fill.cpp
@@ -56,7 +56,7 @@ void Painter::renderFill(FillBucket& bucket, const FillLayer& layer, const TileI
             static_cast<float>(frame.framebufferSize[1])
         }};
         setDepthSublayer(0);
-        bucket.drawVertices(*outlineShader);
+        bucket.drawVertices(*outlineShader, glObjectStore);
     }
 
     if (pattern) {
@@ -111,11 +111,11 @@ void Painter::renderFill(FillBucket& bucket, const FillLayer& layer, const TileI
             patternShader->u_offset_b = std::array<float, 2>{{offsetBx, offsetBy}};
 
             MBGL_CHECK_ERROR(glActiveTexture(GL_TEXTURE0));
-            spriteAtlas->bind(true);
+            spriteAtlas->bind(true, glObjectStore);
 
             // Draw the actual triangles into the color & stencil buffer.
             setDepthSublayer(0);
-            bucket.drawElements(*patternShader);
+            bucket.drawElements(*patternShader, glObjectStore);
         }
     }
     else {
@@ -131,7 +131,7 @@ void Painter::renderFill(FillBucket& bucket, const FillLayer& layer, const TileI
 
             // Draw the actual triangles into the color & stencil buffer.
             setDepthSublayer(1);
-            bucket.drawElements(*plainShader);
+            bucket.drawElements(*plainShader, glObjectStore);
         }
     }
 
@@ -151,6 +151,6 @@ void Painter::renderFill(FillBucket& bucket, const FillLayer& layer, const TileI
         }};
 
         setDepthSublayer(2);
-        bucket.drawVertices(*outlineShader);
+        bucket.drawVertices(*outlineShader, glObjectStore);
     }
 }
diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp
index c17beb3f6b..5fc5ee0221 100644
--- a/src/mbgl/renderer/painter_line.cpp
+++ b/src/mbgl/renderer/painter_line.cpp
@@ -79,9 +79,9 @@ void Painter::renderLine(LineBucket& bucket, const LineLayer& layer, const TileI
         linesdfShader->u_blur = blur;
         linesdfShader->u_color = color;
 
-        LinePatternPos posA = lineAtlas->getDashPosition(properties.dasharray.value.from, layout.cap == CapType::Round);
-        LinePatternPos posB = lineAtlas->getDashPosition(properties.dasharray.value.to, layout.cap == CapType::Round);
-        lineAtlas->bind();
+        LinePatternPos posA = lineAtlas->getDashPosition(properties.dasharray.value.from, layout.cap == CapType::Round, glObjectStore);
+        LinePatternPos posB = lineAtlas->getDashPosition(properties.dasharray.value.to, layout.cap == CapType::Round, glObjectStore);
+        lineAtlas->bind(glObjectStore);
 
         const float widthA = posA.width * properties.dasharray.value.fromScale;
         const float widthB = posB.width * properties.dasharray.value.toScale;
@@ -102,7 +102,7 @@ void Painter::renderLine(LineBucket& bucket, const LineLayer& layer, const TileI
         linesdfShader->u_offset = -properties.offset;
         linesdfShader->u_antialiasingmatrix = antialiasingMatrix;
 
-        bucket.drawLineSDF(*linesdfShader);
+        bucket.drawLineSDF(*linesdfShader, glObjectStore);
 
     } else if (!properties.pattern.value.from.empty()) {
         optional<SpriteAtlasPosition> imagePosA = spriteAtlas->getPosition(properties.pattern.value.from, true);
@@ -134,9 +134,9 @@ void Painter::renderLine(LineBucket& bucket, const LineLayer& layer, const TileI
         linepatternShader->u_antialiasingmatrix = antialiasingMatrix;
 
         MBGL_CHECK_ERROR(glActiveTexture(GL_TEXTURE0));
-        spriteAtlas->bind(true);
+        spriteAtlas->bind(true, glObjectStore);
 
-        bucket.drawLinePatterns(*linepatternShader);
+        bucket.drawLinePatterns(*linepatternShader, glObjectStore);
 
     } else {
         config.program = lineShader->getID();
@@ -152,6 +152,6 @@ void Painter::renderLine(LineBucket& bucket, const LineLayer& layer, const TileI
 
         lineShader->u_color = color;
 
-        bucket.drawLines(*lineShader);
+        bucket.drawLines(*lineShader, glObjectStore);
     }
 }
diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp
index f921ceefc2..377b2c005c 100644
--- a/src/mbgl/renderer/painter_raster.cpp
+++ b/src/mbgl/renderer/painter_raster.cpp
@@ -28,7 +28,7 @@ void Painter::renderRaster(RasterBucket& bucket, const RasterLayer& layer, const
         config.depthTest = GL_TRUE;
         config.depthMask = GL_FALSE;
         setDepthSublayer(0);
-        bucket.drawRaster(*rasterShader, tileStencilBuffer, coveringRasterArray);
+        bucket.drawRaster(*rasterShader, tileStencilBuffer, coveringRasterArray, glObjectStore);
     }
 }
 
diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp
index c2bb1e757f..5f59d6a8a6 100644
--- a/src/mbgl/renderer/painter_symbol.cpp
+++ b/src/mbgl/renderer/painter_symbol.cpp
@@ -23,7 +23,7 @@ void Painter::renderSDF(SymbolBucket &bucket,
                         float sdfFontSize,
                         std::array<float, 2> texsize,
                         SDFShader& sdfShader,
-                        void (SymbolBucket::*drawSDF)(SDFShader&))
+                        void (SymbolBucket::*drawSDF)(SDFShader&, gl::GLObjectStore&))
 {
     mat4 vtxMatrix = translatedMatrix(matrix, styleProperties.translate, id, styleProperties.translateAnchor);
 
@@ -101,7 +101,7 @@ void Painter::renderSDF(SymbolBucket &bucket,
         sdfShader.u_buffer = (haloOffset - styleProperties.haloWidth / fontScale) / sdfPx;
 
         setDepthSublayer(0);
-        (bucket.*drawSDF)(sdfShader);
+        (bucket.*drawSDF)(sdfShader, glObjectStore);
     }
 
     // Then, we draw the text/icon over the halo
@@ -122,7 +122,7 @@ void Painter::renderSDF(SymbolBucket &bucket,
         sdfShader.u_buffer = (256.0f - 64.0f) / 256.0f;
 
         setDepthSublayer(1);
-        (bucket.*drawSDF)(sdfShader);
+        (bucket.*drawSDF)(sdfShader, glObjectStore);
     }
 }
 
@@ -174,7 +174,7 @@ void Painter::renderSymbol(SymbolBucket& bucket, const SymbolLayer& layer, const
         SpriteAtlas* activeSpriteAtlas = layer.spriteAtlas;
         const bool iconScaled = fontScale != 1 || data.pixelRatio != activeSpriteAtlas->getPixelRatio() || bucket.iconsNeedLinear;
         const bool iconTransformed = layout.icon.rotationAlignment == RotationAlignmentType::Map || angleOffset != 0 || state.getPitch() != 0;
-        activeSpriteAtlas->bind(sdf || state.isChanging() || iconScaled || iconTransformed);
+        activeSpriteAtlas->bind(sdf || state.isChanging() || iconScaled || iconTransformed, glObjectStore);
 
         if (sdf) {
             renderSDF(bucket,
@@ -230,7 +230,7 @@ void Painter::renderSymbol(SymbolBucket& bucket, const SymbolLayer& layer, const
             iconShader->u_opacity = properties.icon.opacity;
 
             setDepthSublayer(0);
-            bucket.drawIcons(*iconShader);
+            bucket.drawIcons(*iconShader, glObjectStore);
         }
     }
 
@@ -242,7 +242,7 @@ void Painter::renderSymbol(SymbolBucket& bucket, const SymbolLayer& layer, const
             config.depthTest = GL_FALSE;
         }
 
-        glyphAtlas->bind();
+        glyphAtlas->bind(glObjectStore);
 
         renderSDF(bucket,
                   id,
@@ -267,7 +267,7 @@ void Painter::renderSymbol(SymbolBucket& bucket, const SymbolLayer& layer, const
         config.lineWidth = 1.0f;
 
         setDepthSublayer(0);
-        bucket.drawCollisionBoxes(*collisionBoxShader);
+        bucket.drawCollisionBoxes(*collisionBoxShader, glObjectStore);
 
     }
 
diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp
index 0b19fa0c1e..137574b731 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() {
+void RasterBucket::upload(gl::GLObjectStore& glObjectStore) {
     if (hasData()) {
-        raster.upload();
+        raster.upload(glObjectStore);
         uploaded = true;
     }
 }
@@ -27,10 +27,10 @@ void RasterBucket::setImage(PremultipliedImage image) {
     raster.load(std::move(image));
 }
 
-void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array) {
-    raster.bind(true);
+void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array, gl::GLObjectStore& glObjectStore) {
+    raster.bind(true, glObjectStore);
     shader.u_image = 0;
-    array.bind(shader, vertices, BUFFER_OFFSET_0);
+    array.bind(shader, vertices, BUFFER_OFFSET_0, glObjectStore);
     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 92c6a8ea02..466a7602ed 100644
--- a/src/mbgl/renderer/raster_bucket.hpp
+++ b/src/mbgl/renderer/raster_bucket.hpp
@@ -14,13 +14,13 @@ class RasterBucket : public Bucket {
 public:
     RasterBucket(gl::TexturePool&);
 
-    void upload() override;
+    void upload(gl::GLObjectStore&) override;
     void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override;
     bool hasData() const override;
 
     void setImage(PremultipliedImage);
 
-    void drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array);
+    void drawRaster(RasterShader&, StaticVertexBuffer&, VertexArrayObject&, gl::GLObjectStore&);
 
     Raster raster;
 };
diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp
index 0854f697a3..683a6f4b11 100644
--- a/src/mbgl/renderer/symbol_bucket.cpp
+++ b/src/mbgl/renderer/symbol_bucket.cpp
@@ -64,14 +64,14 @@ SymbolBucket::~SymbolBucket() {
     // Do not remove. header file only contains forward definitions to unique pointers.
 }
 
-void SymbolBucket::upload() {
+void SymbolBucket::upload(gl::GLObjectStore& glObjectStore) {
     if (hasTextData()) {
-        renderData->text.vertices.upload();
-        renderData->text.triangles.upload();
+        renderData->text.vertices.upload(glObjectStore);
+        renderData->text.triangles.upload(glObjectStore);
     }
     if (hasIconData()) {
-        renderData->icon.vertices.upload();
-        renderData->icon.triangles.upload();
+        renderData->icon.vertices.upload(glObjectStore);
+        renderData->icon.triangles.upload(glObjectStore);
     }
 
     uploaded = true;
@@ -572,50 +572,50 @@ void SymbolBucket::swapRenderData() {
     }
 }
 
-void SymbolBucket::drawGlyphs(SDFShader &shader) {
+void SymbolBucket::drawGlyphs(SDFShader& shader, gl::GLObjectStore& glObjectStore) {
     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);
+        group->array[0].bind(shader, text.vertices, text.triangles, vertex_index, glObjectStore);
         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) {
+void SymbolBucket::drawIcons(SDFShader& shader, gl::GLObjectStore& glObjectStore) {
     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);
+        group->array[0].bind(shader, icon.vertices, icon.triangles, vertex_index, glObjectStore);
         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) {
+void SymbolBucket::drawIcons(IconShader& shader, gl::GLObjectStore& glObjectStore) {
     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);
+        group->array[1].bind(shader, icon.vertices, icon.triangles, vertex_index, glObjectStore);
         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) {
+void SymbolBucket::drawCollisionBoxes(CollisionBoxShader& shader, gl::GLObjectStore& glObjectStore) {
     GLbyte *vertex_index = BUFFER_OFFSET_0;
     auto& collisionBox = renderData->collisionBox;
     for (auto &group : collisionBox.groups) {
-        group->array[0].bind(shader, collisionBox.vertices, vertex_index);
+        group->array[0].bind(shader, collisionBox.vertices, vertex_index, glObjectStore);
         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 cca34cd858..cebb7e5dbe 100644
--- a/src/mbgl/renderer/symbol_bucket.hpp
+++ b/src/mbgl/renderer/symbol_bucket.hpp
@@ -70,7 +70,7 @@ public:
     SymbolBucket(float overscaling, float zoom, const MapMode);
     ~SymbolBucket() override;
 
-    void upload() override;
+    void upload(gl::GLObjectStore&) override;
     void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override;
     bool hasData() const override;
     bool hasTextData() const;
@@ -82,10 +82,10 @@ public:
                      GlyphAtlas&,
                      GlyphStore&);
 
-    void drawGlyphs(SDFShader& shader);
-    void drawIcons(SDFShader& shader);
-    void drawIcons(IconShader& shader);
-    void drawCollisionBoxes(CollisionBoxShader& shader);
+    void drawGlyphs(SDFShader&, gl::GLObjectStore&);
+    void drawIcons(SDFShader&, gl::GLObjectStore&);
+    void drawIcons(IconShader&, gl::GLObjectStore&);
+    void drawCollisionBoxes(CollisionBoxShader&, gl::GLObjectStore&);
 
     void parseFeatures(const GeometryTileLayer&,
                        const FilterExpression&);