From 1be8e6327bfaf66ab0c0a858a7e81acec12c0bf8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Minh=20Nguy=E1=BB=85n?= <mxn@1ec5.org>
Date: Thu, 19 Mar 2015 14:40:44 -0700
Subject: [PATCH 01/21] Prepared podspec for beta 1

This podspec was originally lifted from mapbox/mapbox-ios-sdk, which was structured and built quite differently. We could have the podspec build this repo as is, using scripts/package_ios.sh, but that would require developers to install the same version of Xcode as Travis is using (see #977). So this podspec instead pulls a prebuilt library. Much simpler.

Also package a LICENSE with the archive to satisfy a CocoaPods warning.

Fixes #829.
---
 ios/MapboxGL.podspec   | 16 ++++++++--------
 scripts/package_ios.sh |  1 +
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/ios/MapboxGL.podspec b/ios/MapboxGL.podspec
index 6cdec1826..617966744 100644
--- a/ios/MapboxGL.podspec
+++ b/ios/MapboxGL.podspec
@@ -8,25 +8,25 @@ Pod::Spec.new do |m|
   m.homepage         = 'https://www.mapbox.com/blog/mapbox-gl/'
   m.license          = 'BSD'
   m.author           = { 'Mapbox' => 'mobile@mapbox.com' }
-  m.screenshot       = 'https://raw.githubusercontent.com/mapbox/mapbox-gl-cocoa/master/pkg/screenshot.png'
-  m.social_media_url = 'https://twitter.com/Mapbox'
+  m.screenshot       = 'https://raw.githubusercontent.com/mapbox/mapbox-gl-native/master/ios/screenshot.png'
+  m.social_media_url = 'https://twitter.com/mapbox'
 
-  m.source = { :git => 'https://github.com/mapbox/mapbox-gl-cocoa.git', :tag => m.version.to_s }
+  m.source = { :http => "http://mapbox.s3.amazonaws.com/mapbox-gl-native/ios/mapbox-gl-ios-#{m.version.to_s}.zip" }
 
   m.platform              = :ios
   m.ios.deployment_target = '7.0'
 
-  m.source_files = 'dist/static/Headers/*.h'
+  m.source_files = 'Headers/*.h'
 
   m.requires_arc = true
 
-  m.resource_bundle = { 'MapboxGL' => 'dist/static/MapboxGL.bundle/*' }
+  m.resource_bundle = { 'MapboxGL' => 'MapboxGL.bundle/*' }
 
-  m.frameworks = 'CoreLocation', 'Foundation', 'GLKit', 'SystemConfiguration', 'UIKit'
+  m.frameworks = 'CoreLocation', 'GLKit', 'ImageIO', 'MobileCoreServices', 'SystemConfiguration'
 
-  m.libraries = 'MapboxGL', 'c++', 'sqlite3', 'z'
+  m.libraries = 'c++', 'sqlite3', 'z'
 
-  m.vendored_libraries = 'dist/static/libMapboxGL.a'
+  m.vendored_library = 'libMapboxGL.a'
 
   m.xcconfig = { 'OTHER_CPLUSPLUSFLAGS' => '-std=gnu++11 -stdlib=libc++' }
 
diff --git a/scripts/package_ios.sh b/scripts/package_ios.sh
index 89aac5ee7..588ff6d94 100755
--- a/scripts/package_ios.sh
+++ b/scripts/package_ios.sh
@@ -70,6 +70,7 @@ cp -pv include/mbgl/ios/* "${OUTPUT}/static/Headers"
 # complications between faked GYP bundles-as-executables, device build
 # dependencies, and code signing.
 step "Copying Resources..."
+cp -pv LICENSE.md "${OUTPUT}/static"
 mkdir -p "${OUTPUT}/static/${NAME}.bundle"
 cp -pv platform/ios/resources/* "${OUTPUT}/static/${NAME}.bundle"
 cp -prv styles/styles "${OUTPUT}/static/${NAME}.bundle/styles"

From 490c172b35c9f48d95b4c1a38003a00520ba27b8 Mon Sep 17 00:00:00 2001
From: "Thiago Marcos P. Santos" <thiago@mapbox.com>
Date: Wed, 18 Mar 2015 02:05:02 +0200
Subject: [PATCH 02/21] Delete the GLFWView object at exit

Also destroy the glfwWindow we create. This leak was probably harmless
but a nice cleanup helps us debug other serious memory leaks.
---
 linux/main.cpp                 | 5 +++--
 platform/default/glfw_view.cpp | 1 +
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/linux/main.cpp b/linux/main.cpp
index 697941164..4d5474c02 100644
--- a/linux/main.cpp
+++ b/linux/main.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/mbgl.hpp>
+#include <mbgl/util/std.hpp>
 #include <mbgl/util/uv.hpp>
 #include <mbgl/platform/log.hpp>
 #include <mbgl/platform/platform.hpp>
@@ -13,7 +14,7 @@
 #include <sstream>
 
 
-GLFWView *view = nullptr;
+std::unique_ptr<GLFWView> view;
 
 void quit_handler(int) {
     if (view) {
@@ -62,7 +63,7 @@ int main(int argc, char *argv[]) {
     sigIntHandler.sa_flags = 0;
     sigaction(SIGINT, &sigIntHandler, NULL);
 
-    view = new GLFWView();
+    view = mbgl::util::make_unique<GLFWView>();
 
     mbgl::SQLiteCache cache("/tmp/mbgl-cache.db");
     mbgl::DefaultFileSource fileSource(&cache);
diff --git a/platform/default/glfw_view.cpp b/platform/default/glfw_view.cpp
index 601ae0ec2..fd9c701f9 100644
--- a/platform/default/glfw_view.cpp
+++ b/platform/default/glfw_view.cpp
@@ -11,6 +11,7 @@ GLFWView::GLFWView(bool fullscreen_) : fullscreen(fullscreen_) {
 }
 
 GLFWView::~GLFWView() {
+    glfwDestroyWindow(window);
     glfwTerminate();
 }
 

From ceb7049389abffa5e2e4b60239c2af189eb8420d Mon Sep 17 00:00:00 2001
From: "Thiago Marcos P. Santos" <thiago@mapbox.com>
Date: Wed, 18 Mar 2015 02:14:23 +0200
Subject: [PATCH 03/21] Delete the data buffer of LineAtlas

Data buffer is allocated but never deleted.
---
 src/mbgl/geometry/line_atlas.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/mbgl/geometry/line_atlas.cpp b/src/mbgl/geometry/line_atlas.cpp
index bf6944fbc..8be1a8d53 100644
--- a/src/mbgl/geometry/line_atlas.cpp
+++ b/src/mbgl/geometry/line_atlas.cpp
@@ -19,6 +19,7 @@ LineAtlas::~LineAtlas() {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     MBGL_CHECK_ERROR(glDeleteTextures(1, &texture));
+    delete[] data;
     texture = 0;
 }
 

From 1ffe2dd615a9cdca3cd785e19dd5a63fb1b5181c Mon Sep 17 00:00:00 2001
From: "Thiago Marcos P. Santos" <thiago@mapbox.com>
Date: Wed, 18 Mar 2015 16:24:55 +0200
Subject: [PATCH 04/21] Add a reference Valgrind suppresion file

When using Valgrind for debugging memory leaks and access violations, we
often see a lot of false positives, specially when dealing with OpenGL
that does it own buffer management. This file is an attempt to filter
these false positives.

Note that we are only filtering for the open source Radeon driver and
the list will probably grow to accommodate other setups.

To use the Valgrind with the suppression file for hunting memory leaks,
try something like:

valgrind --leak-check=full --track-origins=yes --suppressions=[path/to/valgrind.sup] ./mapbox-gl
---
 scripts/valgrind.sup | 91 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)
 create mode 100644 scripts/valgrind.sup

diff --git a/scripts/valgrind.sup b/scripts/valgrind.sup
new file mode 100644
index 000000000..fcde049d9
--- /dev/null
+++ b/scripts/valgrind.sup
@@ -0,0 +1,91 @@
+{
+   Valgrind gets confused with buffers managed by the graphics driver
+   Memcheck:Leak
+   ...
+   obj:/usr/*/dri/r600_dri.so
+   ...
+}
+{
+   GLFW _glfwCreateCursor()
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   ...
+   obj:/usr/*/libX11.so.6.3.0
+   ...
+   fun:_glfwCreateCursor
+   ...
+}
+{
+   GLFW _glfwPlatform*()
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   ...
+   fun:_glfwPlatform*
+   ...
+}
+{
+   Buffer managed by OpenGL?
+   Memcheck:Cond
+   ...
+   fun:_ZN4mbgl*Uniform*
+   ...
+   fun:_ZN8GLFWView10invalidateEv
+   ...
+}
+{
+   Buffer managed by OpenGL?
+   Memcheck:Cond
+   fun:_ZNSt7__equalILb0EE5equalIPKfS3_EEbT_S4_T0_
+   ...
+   fun:_ZN4mbgl7Painter11renderLayerERKNS_10StyleLayerEPKNS_4Tile2IDEPKSt5arrayIfLm16EE
+}
+{
+   Valgrind doesn't like our make_unique (C++14 polyfill)
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:malloc
+   ...
+   fun:_ZN4mbgl4util11make_unique*
+   ...
+}
+{
+   dlopen doing its magic
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   ...
+   fun:_dl_open
+   ...
+}
+{
+   X11 false positive
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   ...
+   obj:/usr/*/libX11.so.6.3.0
+   ...
+   fun:_XrmInitParseInfo
+   ...
+}
+{
+   OpenSSL false positive
+   Memcheck:Leak
+   ...
+   fun:CRYPTO_malloc
+   ...
+}
+{
+   OpenSSL false positive
+   Memcheck:Leak
+   ...
+   fun:CRYPTO_realloc
+   ...
+}
+{
+   Libcurl false positive
+   Memcheck:Leak
+   fun:malloc
+   ...
+   obj:/usr/*/libcurl.so.4.3.0
+   fun:curl_multi_socket_action
+   ...
+}

From 61fa43619334ac68c66d45d38aaf681f2a21fa96 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= <mail@kkaefer.com>
Date: Wed, 18 Mar 2015 15:37:06 +0100
Subject: [PATCH 05/21] coalesce buffer deletions and run them in bulk during
 rendering

On iOS, the main thread does framebuffer operations just before it requests a rerender of the view contents. This means that GL operations on the Map thread will interfere with that and cause a crash. While most GL operations happen throughout rendering (which is synchronized with the main thread), deletion of shared_ptrs release in turn their OpenGL objects. This may happen at any time and isn't synced with rendering.

This patch changes this so instead of deleting all objects immediately, we are collecting all abandoned IDs and delete them in bulk once the main thread has given us permission to use OpenGL calls (i.e. during render()).
---
 include/mbgl/map/map.hpp           | 10 +++---
 src/mbgl/geometry/buffer.hpp       |  3 +-
 src/mbgl/geometry/line_atlas.cpp   |  6 ++--
 src/mbgl/geometry/sprite_atlas.cpp |  4 +--
 src/mbgl/geometry/vao.cpp          |  3 +-
 src/mbgl/map/environment.cpp       | 55 ++++++++++++++++++++++++++++--
 src/mbgl/map/environment.hpp       | 42 ++++++++++++++++++-----
 src/mbgl/map/map.cpp               | 23 +++++++++++--
 src/mbgl/map/tile_data.cpp         |  2 +-
 src/mbgl/util/texture_pool.cpp     | 15 +++-----
 10 files changed, 127 insertions(+), 36 deletions(-)

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 86c89f769..06ae39d87 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -37,6 +37,7 @@ class GlyphAtlas;
 class SpriteAtlas;
 class LineAtlas;
 class Environment;
+class EnvironmentScope;
 class AnnotationManager;
 
 class Map : private util::noncopyable {
@@ -192,6 +193,7 @@ private:
     Mode mode = Mode::None;
 
     const std::unique_ptr<Environment> env;
+    std::unique_ptr<EnvironmentScope> scope;
     View &view;
 
 private:
@@ -223,13 +225,13 @@ private:
     FileSource& fileSource;
 
     util::ptr<Style> style;
-    const std::unique_ptr<GlyphAtlas> glyphAtlas;
+    std::unique_ptr<GlyphAtlas> glyphAtlas;
     util::ptr<GlyphStore> glyphStore;
-    const std::unique_ptr<SpriteAtlas> spriteAtlas;
+    std::unique_ptr<SpriteAtlas> spriteAtlas;
     util::ptr<Sprite> sprite;
-    const std::unique_ptr<LineAtlas> lineAtlas;
+    std::unique_ptr<LineAtlas> lineAtlas;
     util::ptr<TexturePool> texturePool;
-    const std::unique_ptr<Painter> painter;
+    std::unique_ptr<Painter> painter;
     util::ptr<AnnotationManager> annotationManager;
 
     std::string styleURL;
diff --git a/src/mbgl/geometry/buffer.hpp b/src/mbgl/geometry/buffer.hpp
index 3649574bb..4198425ec 100644
--- a/src/mbgl/geometry/buffer.hpp
+++ b/src/mbgl/geometry/buffer.hpp
@@ -3,6 +3,7 @@
 
 #include <mbgl/platform/gl.hpp>
 #include <mbgl/util/noncopyable.hpp>
+#include <mbgl/map/environment.hpp>
 
 #include <cstdlib>
 #include <cassert>
@@ -21,7 +22,7 @@ public:
     ~Buffer() {
         cleanup();
         if (buffer != 0) {
-            MBGL_CHECK_ERROR(glDeleteBuffers(1, &buffer));
+            Environment::Get().abandonBuffer(buffer);
             buffer = 0;
         }
     }
diff --git a/src/mbgl/geometry/line_atlas.cpp b/src/mbgl/geometry/line_atlas.cpp
index 8be1a8d53..507cc7b08 100644
--- a/src/mbgl/geometry/line_atlas.cpp
+++ b/src/mbgl/geometry/line_atlas.cpp
@@ -1,3 +1,4 @@
+#include <mbgl/map/environment.hpp>
 #include <mbgl/geometry/line_atlas.hpp>
 #include <mbgl/platform/gl.hpp>
 #include <mbgl/platform/log.hpp>
@@ -18,9 +19,10 @@ LineAtlas::LineAtlas(uint16_t w, uint16_t h)
 LineAtlas::~LineAtlas() {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
-    MBGL_CHECK_ERROR(glDeleteTextures(1, &texture));
-    delete[] data;
+    Environment::Get().abandonTexture(texture);
     texture = 0;
+
+    delete[] data;
 }
 
 LinePatternPos LineAtlas::getDashPosition(const std::vector<float> &dasharray, bool round) {
diff --git a/src/mbgl/geometry/sprite_atlas.cpp b/src/mbgl/geometry/sprite_atlas.cpp
index dce772f2e..bf31c6e38 100644
--- a/src/mbgl/geometry/sprite_atlas.cpp
+++ b/src/mbgl/geometry/sprite_atlas.cpp
@@ -1,3 +1,4 @@
+#include <mbgl/map/environment.hpp>
 #include <mbgl/geometry/sprite_atlas.hpp>
 #include <mbgl/platform/gl.hpp>
 #include <mbgl/platform/log.hpp>
@@ -293,8 +294,7 @@ void SpriteAtlas::bind(bool linear) {
 
 SpriteAtlas::~SpriteAtlas() {
     std::lock_guard<std::recursive_mutex> lock(mtx);
-
-    MBGL_CHECK_ERROR(glDeleteTextures(1, &texture));
+    Environment::Get().abandonTexture(texture);
     texture = 0;
     ::operator delete(data), data = nullptr;
 }
diff --git a/src/mbgl/geometry/vao.cpp b/src/mbgl/geometry/vao.cpp
index 00976b4d5..fef74396a 100644
--- a/src/mbgl/geometry/vao.cpp
+++ b/src/mbgl/geometry/vao.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/geometry/vao.hpp>
 #include <mbgl/platform/log.hpp>
 #include <mbgl/util/string.hpp>
+#include <mbgl/map/environment.hpp>
 
 namespace mbgl {
 
@@ -11,7 +12,7 @@ VertexArrayObject::~VertexArrayObject() {
     if (!gl::DeleteVertexArrays) return;
 
     if (vao) {
-        MBGL_CHECK_ERROR(gl::DeleteVertexArrays(1, &vao));
+        Environment::Get().abandonVAO(vao);
     }
 }
 
diff --git a/src/mbgl/map/environment.cpp b/src/mbgl/map/environment.cpp
index 1aea5aa0c..469790501 100644
--- a/src/mbgl/map/environment.cpp
+++ b/src/mbgl/map/environment.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/map/environment.hpp>
 #include <mbgl/storage/file_source.hpp>
+#include <mbgl/platform/gl.hpp>
 
 #include <uv.h>
 
@@ -76,12 +77,12 @@ ThreadInfoStore threadInfoStore;
 
 } // namespace
 
-Environment::Scope::Scope(Environment& env, ThreadType type, const std::string& name)
+EnvironmentScope::EnvironmentScope(Environment& env, ThreadType type, const std::string& name)
     : id(std::this_thread::get_id()) {
     threadInfoStore.registerThread(&env, type, name);
 }
 
-Environment::Scope::~Scope() {
+EnvironmentScope::~EnvironmentScope() {
     assert(id == std::this_thread::get_id());
     threadInfoStore.unregisterThread();
 }
@@ -90,6 +91,12 @@ Environment::Environment(FileSource& fs)
     : id(makeEnvironmentID()), fileSource(fs), loop(uv_loop_new()) {
 }
 
+Environment::~Environment() {
+    assert(abandonedVAOs.empty());
+    assert(abandonedTextures.empty());
+    assert(abandonedBuffers.empty());
+}
+
 Environment& Environment::Get() {
     Environment* env = threadInfoStore.getThreadInfo().env;
     assert(env);
@@ -129,6 +136,50 @@ void Environment::cancelRequest(Request* req) {
     fileSource.cancel(req);
 }
 
+// #############################################################################################
+
+#pragma mark - OpenGL cleanup
+
+void Environment::abandonVAO(uint32_t vao) {
+    assert(currentlyOn(ThreadType::Map));
+    abandonedVAOs.emplace_back(vao);
+}
+
+void Environment::abandonBuffer(uint32_t buffer) {
+    assert(currentlyOn(ThreadType::Map));
+    abandonedBuffers.emplace_back(buffer);
+}
+
+void Environment::abandonTexture(uint32_t texture) {
+    assert(currentlyOn(ThreadType::Map));
+    abandonedTextures.emplace_back(texture);
+}
+
+// Actually remove the objects we marked as abandoned with the above methods.
+void Environment::performCleanup() {
+    assert(currentlyOn(ThreadType::Map));
+
+    if (!abandonedVAOs.empty()) {
+        MBGL_CHECK_ERROR(gl::DeleteVertexArrays(static_cast<GLsizei>(abandonedVAOs.size()),
+                                                abandonedVAOs.data()));
+        abandonedVAOs.clear();
+    }
+
+    if (!abandonedTextures.empty()) {
+        MBGL_CHECK_ERROR(glDeleteTextures(static_cast<GLsizei>(abandonedTextures.size()),
+                                          abandonedTextures.data()));
+        abandonedTextures.clear();
+    }
+
+    if (!abandonedBuffers.empty()) {
+        MBGL_CHECK_ERROR(glDeleteBuffers(static_cast<GLsizei>(abandonedBuffers.size()),
+                                         abandonedBuffers.data()));
+        abandonedBuffers.clear();
+    }
+}
+
+// #############################################################################################
+
 void Environment::terminate() {
     fileSource.abort(*this);
 }
diff --git a/src/mbgl/map/environment.hpp b/src/mbgl/map/environment.hpp
index b631abf13..1cd33a5e6 100644
--- a/src/mbgl/map/environment.hpp
+++ b/src/mbgl/map/environment.hpp
@@ -6,6 +6,7 @@
 
 #include <thread>
 #include <functional>
+#include <vector>
 
 typedef struct uv_loop_s uv_loop_t;
 
@@ -25,16 +26,8 @@ enum class ThreadType : uint8_t {
 
 class Environment final : private util::noncopyable {
 public:
-    class Scope final {
-    public:
-        Scope(Environment&, ThreadType, const std::string& name);
-        ~Scope();
-
-    private:
-        std::thread::id id;
-    };
-
     Environment(FileSource&);
+    ~Environment();
 
     static Environment& Get();
     static bool inScope();
@@ -42,10 +35,27 @@ public:
     static std::string threadName();
 
     unsigned getID() const;
+
+    // #############################################################################################
+
+    // File request APIs
     void requestAsync(const Resource&, std::function<void(const Response&)>);
     Request* request(const Resource&, std::function<void(const Response&)>);
     void cancelRequest(Request*);
 
+    // #############################################################################################
+
+    // Mark OpenGL objects for deletion
+    void abandonVAO(uint32_t vao);
+    void abandonBuffer(uint32_t buffer);
+    void abandonTexture(uint32_t texture);
+
+    // Actually remove the objects we marked as abandoned with the above methods.
+    // Only call this while the OpenGL context is exclusive to this thread.
+    void performCleanup();
+
+    // #############################################################################################
+
     // Request to terminate the environment.
     void terminate();
 
@@ -53,10 +63,24 @@ private:
     unsigned id;
     FileSource& fileSource;
 
+    // Stores OpenGL objects that we marked for deletion
+    std::vector<uint32_t> abandonedVAOs;
+    std::vector<uint32_t> abandonedBuffers;
+    std::vector<uint32_t> abandonedTextures;
+
 public:
     uv_loop_t* const loop;
 };
 
+class EnvironmentScope final {
+public:
+    EnvironmentScope(Environment&, ThreadType, const std::string& name);
+    ~EnvironmentScope();
+
+private:
+    std::thread::id id;
+};
+
 }
 
 #endif
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 22e6cbceb..ae1cfd20f 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -61,6 +61,7 @@ using namespace mbgl;
 
 Map::Map(View& view_, FileSource& fileSource_)
     : env(util::make_unique<Environment>(fileSource_)),
+      scope(util::make_unique<EnvironmentScope>(*env, ThreadType::Main, "Main")),
       view(view_),
       transform(view_),
       fileSource(fileSource_),
@@ -80,15 +81,28 @@ Map::~Map() {
         stop();
     }
 
+    // Extend the scope to include both Main and Map thread types to ease cleanup.
+    scope.reset();
+    scope = util::make_unique<EnvironmentScope>(
+        *env, static_cast<ThreadType>(static_cast<uint8_t>(ThreadType::Main) |
+                                      static_cast<uint8_t>(ThreadType::Map)),
+        "MapandMain");
+
     // Explicitly reset all pointers.
     activeSources.clear();
     sprite.reset();
     glyphStore.reset();
     style.reset();
-    texturePool.reset();
     workers.reset();
+    painter.reset();
+    annotationManager.reset();
+    lineAtlas.reset();
+    spriteAtlas.reset();
+    glyphAtlas.reset();
 
     uv_run(env->loop, UV_RUN_DEFAULT);
+
+    env->performCleanup();
 }
 
 uv::worker &Map::getWorker() {
@@ -113,7 +127,6 @@ void Map::start(bool startPaused) {
 
         // Remove all of these to make sure they are destructed in the correct thread.
         style.reset();
-        workers.reset();
         activeSources.clear();
 
         terminating = true;
@@ -233,7 +246,7 @@ void Map::run() {
         threadName += "andMain";
     }
 
-    Environment::Scope scope(*env, threadType, threadName);
+    EnvironmentScope mapScope(*env, threadType, threadName);
 
     if (mode == Mode::Continuous) {
         checkForPause();
@@ -749,6 +762,10 @@ void Map::prepare() {
 
 void Map::render() {
     assert(Environment::currentlyOn(ThreadType::Map));
+
+    // Cleanup OpenGL objects that we abandoned since the last render call.
+    env->performCleanup();
+
     assert(painter);
     painter->render(*style, activeSources,
                     state, animationTime);
diff --git a/src/mbgl/map/tile_data.cpp b/src/mbgl/map/tile_data.cpp
index aed182671..1832bd8f0 100644
--- a/src/mbgl/map/tile_data.cpp
+++ b/src/mbgl/map/tile_data.cpp
@@ -97,7 +97,7 @@ void TileData::reparse(uv::worker& worker, std::function<void()> callback)
     new uv::work<util::ptr<TileData>>(
         worker,
         [this](util::ptr<TileData>& tile) {
-            Environment::Scope scope(env, ThreadType::TileWorker, "TileWorker_" + tile->name);
+            EnvironmentScope scope(env, ThreadType::TileWorker, "TileWorker_" + tile->name);
             tile->parse();
         },
         [callback](util::ptr<TileData>&) {
diff --git a/src/mbgl/util/texture_pool.cpp b/src/mbgl/util/texture_pool.cpp
index 33bca01c0..845796f5d 100644
--- a/src/mbgl/util/texture_pool.cpp
+++ b/src/mbgl/util/texture_pool.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/util/texture_pool.hpp>
+#include <mbgl/map/environment.hpp>
 
 #include <vector>
 
@@ -42,17 +43,9 @@ void TexturePool::removeTextureID(GLuint texture_id) {
 }
 
 void TexturePool::clearTextureIDs() {
-    std::vector<GLuint> ids_to_remove;
-    ids_to_remove.reserve(texture_ids.size());
-
-    for (std::set<GLuint>::iterator id_iterator = texture_ids.begin();
-         id_iterator != texture_ids.end(); ++id_iterator) {
-        ids_to_remove.push_back(*id_iterator);
+    auto& env = Environment::Get();
+    for (auto texture : texture_ids) {
+        env.abandonTexture(texture);
     }
-
-    if (!ids_to_remove.empty()) {
-        MBGL_CHECK_ERROR(glDeleteTextures((GLsizei)ids_to_remove.size(), &ids_to_remove[0]));
-    }
-
     texture_ids.clear();
 }

From a1a7ab62e176afb354109ba23360c668f84771e8 Mon Sep 17 00:00:00 2001
From: Peter Liu <peterqliu@gmail.com>
Date: Fri, 20 Mar 2015 18:31:12 -0700
Subject: [PATCH 06/21] add emerald

---
 ios/app/MBXViewController.mm | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ios/app/MBXViewController.mm b/ios/app/MBXViewController.mm
index 98b337f92..f0ad9e115 100644
--- a/ios/app/MBXViewController.mm
+++ b/ios/app/MBXViewController.mm
@@ -9,6 +9,7 @@
 static UIColor *const kTintColor = [UIColor colorWithRed:0.120 green:0.550 blue:0.670 alpha:1.000];
 
 static NSArray *const kStyleNames = @[
+    @"Emerald",
     @"Bright",
     @"Basic",
     @"Outdoors",

From 9ee8bac1fe420076772918a25ca24504fef798ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Minh=20Nguy=E1=BB=85n?= <mxn@1ec5.org>
Date: Fri, 20 Mar 2015 22:40:31 -0700
Subject: [PATCH 07/21] Updated to latest styles

a1a7ab62e176afb354109ba23360c668f84771e8 requires mapbox/mapbox-gl-styles@26ba1edacdc4ce2295ca1aaeef28ba6c4c37dbbd.
---
 styles | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/styles b/styles
index c13039337..26ba1edac 160000
--- a/styles
+++ b/styles
@@ -1 +1 @@
-Subproject commit c1303933798e1bb48649d8a64b71038b4d3ed0a4
+Subproject commit 26ba1edacdc4ce2295ca1aaeef28ba6c4c37dbbd

From f43661115f7f2601d77b7fc5f813e65ca2651d0d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Minh=20Nguy=E1=BB=85n?= <mxn@1ec5.org>
Date: Fri, 20 Mar 2015 22:52:21 -0700
Subject: [PATCH 08/21] Show Emerald by default

a1a7ab62e176afb354109ba23360c668f84771e8 only added an Emerald option to the test app, but `MGLMapView` itself has its own default style.

Fixes #964.
---
 platform/ios/MGLMapView.mm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/ios/MGLMapView.mm b/platform/ios/MGLMapView.mm
index 281755a4c..9b096315d 100644
--- a/platform/ios/MGLMapView.mm
+++ b/platform/ios/MGLMapView.mm
@@ -175,7 +175,7 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
 {
     if ( ! styleJSON)
     {
-        [self useBundledStyleNamed:@"bright-v7"];
+        [self useBundledStyleNamed:@"emerald-v7"];
     }
     else
     {

From ecb8e2800d0fbc4e4f843b0d13efc28038ede3ef Mon Sep 17 00:00:00 2001
From: "Justin R. Miller" <incanus@codesorcery.net>
Date: Sun, 22 Mar 2015 00:53:36 -0700
Subject: [PATCH 09/21] Cocoa annotations API

---
 gyp/platform-ios.gypi            |   1 +
 include/mbgl/ios/MGLAnnotation.h |  28 +++
 include/mbgl/ios/MGLMapView.h    |  60 ++++++-
 include/mbgl/util/geo.hpp        |   7 +
 ios/app/MBXViewController.mm     |   2 +-
 ios/docs/install_docs.sh         |  10 +-
 ios/docs/remove_docs.sh          |   2 +-
 platform/ios/MGLMapView.mm       | 291 ++++++++++++++++++++++++++++++-
 src/mbgl/map/annotation.cpp      |   4 +-
 9 files changed, 384 insertions(+), 21 deletions(-)
 create mode 100644 include/mbgl/ios/MGLAnnotation.h

diff --git a/gyp/platform-ios.gypi b/gyp/platform-ios.gypi
index a8a827af6..cc436561f 100644
--- a/gyp/platform-ios.gypi
+++ b/gyp/platform-ios.gypi
@@ -18,6 +18,7 @@
         '../platform/darwin/reachability.m',
         '../include/mbgl/ios/MGLMapView.h',
         '../platform/ios/MGLMapView.mm',
+        '../include/mbgl/ios/MGLAnnotation.h',
         '../include/mbgl/ios/MGLStyleFunctionValue.h',
         '../platform/ios/MGLStyleFunctionValue.m',
         '../include/mbgl/ios/MGLTypes.h',
diff --git a/include/mbgl/ios/MGLAnnotation.h b/include/mbgl/ios/MGLAnnotation.h
new file mode 100644
index 000000000..e4907d9b9
--- /dev/null
+++ b/include/mbgl/ios/MGLAnnotation.h
@@ -0,0 +1,28 @@
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+/** The MGLAnnotation protocol is used to provide annotation-related information to a map view. To use this protocol, you adopt it in any custom objects that store or represent annotation data. Each object then serves as the source of information about a single map annotation and provides critical information, such as the annotation’s location on the map. Annotation objects do not provide the visual representation of the annotation but typically coordinate (in conjunction with the map view’s delegate) the creation of an appropriate objects to handle the display.
+*
+*   An object that adopts this protocol must implement the `coordinate` property. The other methods of this protocol are optional. */
+@protocol MGLAnnotation <NSObject>
+
+/** @name Position Attributes */
+
+/** The center point (specified as a map coordinate) of the annotation. (required) (read-only) */
+@property (nonatomic, readonly) CLLocationCoordinate2D coordinate;
+
+@optional
+
+/** @name Title Attributes */
+
+/** The string containing the annotation’s title.
+*
+* Although this property is optional, if you support the selection of annotations in your map view, you are expected to provide this property. This string is displayed in the callout for the associated annotation. */
+@property (nonatomic, readonly, copy) NSString *title;
+
+/** The string containing the annotation’s subtitle.
+*
+*   This string is displayed in the callout for the associated annotation. */
+@property (nonatomic, readonly, copy) NSString *subtitle;
+
+@end
diff --git a/include/mbgl/ios/MGLMapView.h b/include/mbgl/ios/MGLMapView.h
index 481e878ed..3a6e622e1 100644
--- a/include/mbgl/ios/MGLMapView.h
+++ b/include/mbgl/ios/MGLMapView.h
@@ -2,6 +2,7 @@
 #import <CoreLocation/CoreLocation.h>
 
 @protocol MGLMapViewDelegate;
+@protocol MGLAnnotation;
 
 /** An MGLMapView object provides an embeddable map interface, similar to the one provided by Apple's MapKit. You use this class to display map information and to manipulate the map contents from your application. You can center the map on a given coordinate, specify the size of the area you want to display, and style the features of the map to fit your application's use case.
 *
@@ -184,6 +185,55 @@
 *   @param styleName The map style name to use. */
 - (void)useBundledStyleNamed:(NSString *)styleName;
 
+#pragma mark - Annotating the Map
+
+/** @name Annotating the Map */
+
+/** The complete list of annotations associated with the receiver. (read-only)
+*
+*   The objects in this array must adopt the MGLAnnotation protocol. If no annotations are associated with the map view, the value of this property is `nil`. */
+@property (nonatomic, readonly) NSArray *annotations;
+
+/** Adds the specified annotation to the map view.
+*   @param annotation The annotation object to add to the receiver. This object must conform to the MGLAnnotation protocol. The map view retains the specified object. */
+- (void)addAnnotation:(id <MGLAnnotation>)annotation;
+
+/** Adds an array of annotation objects to the map view.
+*   @param annotations An array of annotation objects. Each object in the array must conform to the MGLAnnotation protocol. The map view retains the individual annotation objects. */
+- (void)addAnnotations:(NSArray *)annotations;
+
+/** Removes the specified annotation object from the map view.
+*
+*   Removing an annotation object disassociates it from the map view entirely, preventing it from being displayed on the map. Thus, you would typically call this method only when you want to hide or delete a given annotation.
+*
+*   @param annotation The annotation object to remove. This object must conform to the MGLAnnotation protocol. */
+- (void)removeAnnotation:(id <MGLAnnotation>)annotation;
+
+/** Removes an array of annotation objects from the map view.
+*
+*   Removing annotation objects disassociates them from the map view entirely, preventing them from being displayed on the map. Thus, you would typically call this method only when you want to hide or delete the specified annotations.
+*
+*   @param annotations The array of annotations to remove. Objects in the array must conform to the MGLAnnotation protocol. */
+- (void)removeAnnotations:(NSArray *)annotations;
+
+/** The annotations that are currently selected.
+*
+*   Assigning a new array to this property selects only the first annotation in the array. */
+@property (nonatomic, copy) NSArray *selectedAnnotations;
+
+/** Selects the specified annotation and displays a callout view for it.
+*
+*   If the specified annotation is not onscreen, this method has no effect.
+*
+*   @param annotation The annotation object to select.
+*   @param animated If `YES`, the callout view is animated into position. */
+- (void)selectAnnotation:(id <MGLAnnotation>)annotation animated:(BOOL)animated;
+
+/** Deselects the specified annotation and hides its callout view.
+*   @param annotation The annotation object to deselect.
+*   @param animated If `YES`, the callout view is animated offscreen. */
+- (void)deselectAnnotation:(id <MGLAnnotation>)annotation animated:(BOOL)animated;
+
 #pragma mark - Debugging
 
 /** @name Debugging */
@@ -201,11 +251,19 @@
 
 @end
 
-// TODO
+/** The MGLMapViewDelegate protocol defines a set of optional methods that you can use to receive map-related update messages. Because many map operations require the MGLMapView class to load data asynchronously, the map view calls these methods to notify your application when specific operations complete. The map view also uses these methods to request annotation marker symbology and to manage interactions with those markers. */
 @protocol MGLMapViewDelegate <NSObject>
 
 @optional
 
+/** @name Managing the Display of Annotations */
+
+/** Returns the style's symbol name to use for the marker for the specified point annotation object.
+*   @param mapView The map view that requested the annotation symbol name.
+*   @param annotation The object representing the annotation that is about to be displayed. 
+*   @return The marker symbol to display for the specified annotation or `nil` if you want to display the default symbol. */
+- (NSString *)mapView:(MGLMapView *)mapView symbolNameForAnnotation:(id <MGLAnnotation>)annotation;
+
 // Responding to Map Position Changes
 
 // TODO
diff --git a/include/mbgl/util/geo.hpp b/include/mbgl/util/geo.hpp
index b99a6e661..6ece6d4de 100644
--- a/include/mbgl/util/geo.hpp
+++ b/include/mbgl/util/geo.hpp
@@ -32,6 +32,13 @@ struct LatLngBounds {
         if (point.longitude < sw.longitude) sw.longitude = point.longitude;
         if (point.longitude > ne.longitude) ne.longitude = point.longitude;
     }
+
+    inline bool contains(const LatLng& point) {
+        return (point.latitude  >= sw.latitude  &&
+                point.latitude  <= ne.latitude  &&
+                point.longitude >= sw.longitude &&
+                point.longitude <= ne.longitude);
+    }
 };
 
 }
diff --git a/ios/app/MBXViewController.mm b/ios/app/MBXViewController.mm
index f0ad9e115..e12964ac9 100644
--- a/ios/app/MBXViewController.mm
+++ b/ios/app/MBXViewController.mm
@@ -233,7 +233,7 @@ mbgl::Settings_NSUserDefaults *settings = nullptr;
     }
 }
 
-#pragma mark - Location
+#pragma mark - CLLocationManagerDelegate
 
 - (void)locationManager:(CLLocationManager *)manager didChangeAuthorizationStatus:(CLAuthorizationStatus)status
 {
diff --git a/ios/docs/install_docs.sh b/ios/docs/install_docs.sh
index 4d116c033..cd6fcdda7 100755
--- a/ios/docs/install_docs.sh
+++ b/ios/docs/install_docs.sh
@@ -5,7 +5,7 @@ if [ -z `which appledoc` ]; then
     exit 1
 fi
 
-VERSION=$( git tag | sort -r | sed -n '1p' )
+VERSION=$( git tag | grep ^[0-9] | sort -r | sed -n '1p' )
 echo "Creating new docs for $VERSION..."
 echo
 
@@ -15,10 +15,4 @@ appledoc \
     --project-company Mapbox \
     --create-docset \
     --company-id com.mapbox \
-    --ignore app \
-    --ignore dist \
-    --ignore pkg \
-    --ignore test \
-    --ignore .m \
-    --ignore .mm \
-    .
\ No newline at end of file
+    ../../include/mbgl/ios
diff --git a/ios/docs/remove_docs.sh b/ios/docs/remove_docs.sh
index bb8c008dc..09e2c1d39 100755
--- a/ios/docs/remove_docs.sh
+++ b/ios/docs/remove_docs.sh
@@ -4,4 +4,4 @@ echo
 echo "Removing docs from ~/Library/Developer/Shared/Documentation/DocSets..."
 echo
 
-rm -rfv ~/Library/Developer/Shared/Documentation/DocSets/com.mapbox.Mapbox-GL-*
\ No newline at end of file
+rm -rfv ~/Library/Developer/Shared/Documentation/DocSets/com.mapbox.Mapbox-GL-*
diff --git a/platform/ios/MGLMapView.mm b/platform/ios/MGLMapView.mm
index 9b096315d..d61c4dad4 100644
--- a/platform/ios/MGLMapView.mm
+++ b/platform/ios/MGLMapView.mm
@@ -16,11 +16,13 @@
 
 #import "MGLTypes.h"
 #import "MGLStyleFunctionValue.h"
+#import "MGLAnnotation.h"
 
 #import "UIColor+MGLAdditions.h"
 #import "NSArray+MGLAdditions.h"
 #import "NSDictionary+MGLAdditions.h"
 
+#import <algorithm>
 
 // Returns the path to the default cache database on this system.
 const std::string &defaultCacheDatabase() {
@@ -39,6 +41,10 @@ const std::string &defaultCacheDatabase() {
 
 static dispatch_once_t loadGLExtensions;
 
+NSString *const MGLDefaultStyleName = @"Emerald";
+NSString *const MGLStyleVersion = @"v7";
+NSString *const MGLDefaultStyleMarkerSymbolName = @"default_marker";
+
 extern NSString *const MGLStyleKeyGeneric;
 extern NSString *const MGLStyleKeyFill;
 extern NSString *const MGLStyleKeyLine;
@@ -52,6 +58,8 @@ extern NSString *const MGLStyleValueFunctionAllowed;
 
 NSTimeInterval const MGLAnimationDuration = 0.3;
 
+NSString *const MGLAnnotationIDKey = @"MGLAnnotationIDKey";
+
 #pragma mark - Private -
 
 @interface MGLMapView () <UIGestureRecognizerDelegate, GLKViewDelegate>
@@ -67,6 +75,9 @@ NSTimeInterval const MGLAnimationDuration = 0.3;
 @property (nonatomic) UIRotationGestureRecognizer *rotate;
 @property (nonatomic) UILongPressGestureRecognizer *quickZoom;
 @property (nonatomic) NSMutableArray *bundledStyleNames;
+@property (nonatomic) NSMapTable *annotationsStore;
+@property (nonatomic) std::vector<uint32_t> annotationsNearbyLastTap;
+@property (nonatomic, weak) id <MGLAnnotation> selectedAnnotation;
 @property (nonatomic, readonly) NSDictionary *allowedStyleTypes;
 @property (nonatomic) CGPoint centerPoint;
 @property (nonatomic) CGFloat scale;
@@ -175,7 +186,9 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
 {
     if ( ! styleJSON)
     {
-        [self useBundledStyleNamed:@"emerald-v7"];
+        [self useBundledStyleNamed:[[[MGLDefaultStyleName lowercaseString]
+                                        stringByAppendingString:@"-"]
+                                        stringByAppendingString:MGLStyleVersion]];
     }
     else
     {
@@ -266,6 +279,12 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
     Reachability* reachability = [Reachability reachabilityForInternetConnection];
     [reachability startNotifier];
 
+    // setup annotations
+    //
+    _annotationsStore = [NSMapTable mapTableWithKeyOptions:NSMapTableStrongMemory valueOptions:NSMapTableStrongMemory];
+    std::string defaultSymbolName([MGLDefaultStyleMarkerSymbolName cStringUsingEncoding:[NSString defaultCStringEncoding]]);
+    mbglMap->setDefaultPointAnnotationSymbol(defaultSymbolName);
+
     // setup logo bug
     //
     _logoBug = [[UIImageView alloc] initWithImage:[MGLMapView resourceImageNamed:@"mapbox.png"]];
@@ -319,6 +338,10 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
     doubleTap.numberOfTapsRequired = 2;
     [self addGestureRecognizer:doubleTap];
 
+    UITapGestureRecognizer *singleTap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleSingleTapGesture:)];
+    [singleTap requireGestureRecognizerToFail:doubleTap];
+    [self addGestureRecognizer:singleTap];
+
     UITapGestureRecognizer *twoFingerTap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleTwoFingerTapGesture:)];
     twoFingerTap.numberOfTouchesRequired = 2;
     [twoFingerTap requireGestureRecognizerToFail:_pinch];
@@ -684,6 +707,118 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
     }
 }
 
+- (void)handleSingleTapGesture:(UITapGestureRecognizer *)singleTap
+{
+    CGPoint tapPoint = [singleTap locationInView:self];
+
+    // tolerances based on touch size & typical marker aspect ratio
+    CGFloat toleranceWidth  = 50;
+    CGFloat toleranceHeight = 75;
+
+    // setup a recognition area weighted 2/3 of the way above the point to account for average marker imagery
+    CGRect tapRect = CGRectMake(tapPoint.x - toleranceWidth / 2, tapPoint.y - 2 * toleranceHeight / 3, toleranceWidth, toleranceHeight);
+    CGPoint tapRectLowerLeft  = CGPointMake(tapRect.origin.x, tapRect.origin.y + tapRect.size.height);
+    CGPoint tapRectUpperLeft  = CGPointMake(tapRect.origin.x, tapRect.origin.y);
+    CGPoint tapRectUpperRight = CGPointMake(tapRect.origin.x + tapRect.size.width, tapRect.origin.y);
+    CGPoint tapRectLowerRight = CGPointMake(tapRect.origin.x + tapRect.size.width, tapRect.origin.y + tapRect.size.height);
+
+    // figure out what that means in coordinate space
+    CLLocationCoordinate2D coordinate;
+    mbgl::LatLngBounds tapBounds;
+
+    coordinate = [self convertPoint:tapRectLowerLeft  toCoordinateFromView:self];
+    tapBounds.extend(mbgl::LatLng(coordinate.latitude, coordinate.longitude));
+
+    coordinate = [self convertPoint:tapRectUpperLeft  toCoordinateFromView:self];
+    tapBounds.extend(mbgl::LatLng(coordinate.latitude, coordinate.longitude));
+
+    coordinate = [self convertPoint:tapRectUpperRight toCoordinateFromView:self];
+    tapBounds.extend(mbgl::LatLng(coordinate.latitude, coordinate.longitude));
+
+    coordinate = [self convertPoint:tapRectLowerRight toCoordinateFromView:self];
+    tapBounds.extend(mbgl::LatLng(coordinate.latitude, coordinate.longitude));
+
+    // query for nearby annotations
+    std::vector<uint32_t> nearbyAnnotations = mbglMap->getAnnotationsInBounds(tapBounds);
+
+    int32_t newSelectedAnnotationID = -1;
+
+    if (nearbyAnnotations.size())
+    {
+        // there is at least one nearby annotation; select one
+        //
+        // first, sort for comparison and iteration
+        std::sort(nearbyAnnotations.begin(), nearbyAnnotations.end());
+
+        if (nearbyAnnotations == self.annotationsNearbyLastTap)
+        {
+            // the selection candidates haven't changed; cycle through them
+            if (self.selectedAnnotation &&
+                [[[self.annotationsStore objectForKey:self.selectedAnnotation]
+                    objectForKey:MGLAnnotationIDKey] unsignedIntValue] == self.annotationsNearbyLastTap.back())
+            {
+                // the selected annotation is the last in the set; cycle back to the first
+                // note: this could be the selected annotation if only one in set
+                newSelectedAnnotationID = self.annotationsNearbyLastTap.front();
+            }
+            else if (self.selectedAnnotation)
+            {
+                // otherwise increment the selection through the candidates
+                uint32_t currentID = [[[self.annotationsStore objectForKey:self.selectedAnnotation] objectForKey:MGLAnnotationIDKey] unsignedIntValue];
+                auto result = std::find(self.annotationsNearbyLastTap.begin(), self.annotationsNearbyLastTap.end(), currentID);
+                auto distance = std::distance(self.annotationsNearbyLastTap.begin(), result);
+                newSelectedAnnotationID = self.annotationsNearbyLastTap[distance + 1];
+            }
+            else
+            {
+                // no current selection; select the first one
+                newSelectedAnnotationID = self.annotationsNearbyLastTap.front();
+            }
+        }
+        else
+        {
+            // start tracking a new set of nearby annotations
+            self.annotationsNearbyLastTap = nearbyAnnotations;
+
+            // select the first one
+            newSelectedAnnotationID = self.annotationsNearbyLastTap.front();
+        }
+    }
+    else
+    {
+        // there are no nearby annotations; deselect if necessary
+        newSelectedAnnotationID = -1;
+    }
+
+    if (newSelectedAnnotationID >= 0)
+    {
+        // find & select model object for selection
+        NSEnumerator *enumerator = self.annotationsStore.keyEnumerator;
+
+        while (id <MGLAnnotation> annotation = enumerator.nextObject)
+        {
+            if ([[[self.annotationsStore objectForKey:annotation] objectForKey:MGLAnnotationIDKey] integerValue] == newSelectedAnnotationID)
+            {
+                // only change selection status if not the currently selected annotation
+                if ( ! [annotation isEqual:self.selectedAnnotation])
+                {
+                    [self selectAnnotation:annotation animated:YES];
+                }
+
+                // either way, we should stop enumerating
+                break;
+            }
+        }
+    }
+    else
+    {
+        // deselect any selected annotation
+        if (self.selectedAnnotation) [self deselectAnnotation:self.selectedAnnotation animated:YES];
+    }
+
+    NSLog(@"%i (%@)", newSelectedAnnotationID, self.selectedAnnotation.title);
+}
+
 - (void)handleDoubleTapGesture:(UITapGestureRecognizer *)doubleTap
 {
     if ( ! self.isZoomEnabled) return;
@@ -840,7 +975,7 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
 {
     CGFloat duration = (animated ? MGLAnimationDuration : 0);
 
-    mbglMap->setLatLng(mbgl::LatLng(coordinate.latitude, coordinate.longitude), secondsAsDuration(duration));
+    mbglMap->setLatLng(coordinateToLatLng(coordinate), secondsAsDuration(duration));
 }
 
 - (void)setCenterCoordinate:(CLLocationCoordinate2D)centerCoordinate
@@ -850,16 +985,14 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
 
 - (CLLocationCoordinate2D)centerCoordinate
 {
-    mbgl::LatLng latLng = mbglMap->getLatLng();
-
-    return CLLocationCoordinate2DMake(latLng.latitude, latLng.longitude);
+    return latLngToCoordinate(mbglMap->getLatLng());
 }
 
 - (void)setCenterCoordinate:(CLLocationCoordinate2D)centerCoordinate zoomLevel:(double)zoomLevel animated:(BOOL)animated
 {
     CGFloat duration = (animated ? MGLAnimationDuration : 0);
 
-    mbglMap->setLatLngZoom(mbgl::LatLng(centerCoordinate.latitude, centerCoordinate.longitude), zoomLevel, secondsAsDuration(duration));
+    mbglMap->setLatLngZoom(coordinateToLatLng(centerCoordinate), zoomLevel, secondsAsDuration(duration));
 
     [self unrotateIfNeededAnimated:animated];
 }
@@ -915,9 +1048,7 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
     //
     convertedPoint.y = self.bounds.size.height - convertedPoint.y;
 
-    mbgl::LatLng latLng = mbglMap->latLngForPixel(mbgl::vec2<double>(convertedPoint.x, convertedPoint.y));
-
-    return CLLocationCoordinate2DMake(latLng.latitude, latLng.longitude);
+    return latLngToCoordinate(mbglMap->latLngForPixel(mbgl::vec2<double>(convertedPoint.x, convertedPoint.y)));
 }
 
 - (CGPoint)convertCoordinate:(CLLocationCoordinate2D)coordinate toPointToView:(UIView *)view
@@ -936,6 +1067,32 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
     return mbglMap->getMetersPerPixelAtLatitude(latitude, self.zoomLevel);
 }
 
+mbgl::LatLng coordinateToLatLng(CLLocationCoordinate2D coordinate)
+{
+    return mbgl::LatLng(coordinate.latitude, coordinate.longitude);
+}
+
+CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
+{
+    return CLLocationCoordinate2DMake(latLng.latitude, latLng.longitude);
+}
+
+- (mbgl::LatLngBounds)viewportBounds
+{
+    mbgl::LatLngBounds bounds;
+
+    bounds.extend(coordinateToLatLng(
+        [self convertPoint:CGPointMake(0, 0) toCoordinateFromView:self]));
+    bounds.extend(coordinateToLatLng(
+        [self convertPoint:CGPointMake(self.bounds.size.width, 0) toCoordinateFromView:self]));
+    bounds.extend(coordinateToLatLng(
+        [self convertPoint:CGPointMake(0, self.bounds.size.height) toCoordinateFromView:self]));
+    bounds.extend(coordinateToLatLng(
+        [self convertPoint:CGPointMake(self.bounds.size.width, self.bounds.size.height) toCoordinateFromView:self]));
+
+    return bounds;
+}
+
 #pragma mark - Styling -
 
 - (NSDictionary *)getRawStyle
@@ -1395,6 +1552,122 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
     return MGLStyleAllowedTypes;
 }
 
+#pragma mark - Annotations -
+
+- (NSArray *)annotations
+{
+    if ([_annotationsStore count])
+    {
+        NSMutableArray *result = [NSMutableArray array];
+
+        NSEnumerator *keyEnumerator = [_annotationsStore keyEnumerator];
+        id <MGLAnnotation> annotation;
+
+        while (annotation = [keyEnumerator nextObject])
+        {
+            [result addObject:annotation];
+        }
+
+        return [NSArray arrayWithArray:result];
+    }
+
+    return nil;
+}
+
+- (void)addAnnotation:(id <MGLAnnotation>)annotation
+{
+    // The core bulk add API is efficient with respect to indexing and
+    // screen refreshes, thus we should defer to it even for individual adds.
+    //
+    [self addAnnotations:@[ annotation ]];
+}
+
+- (void)addAnnotations:(NSArray *)annotations
+{
+    std::vector<mbgl::LatLng> latLngs;
+    latLngs.reserve(annotations.count);
+
+    std::vector<std::string> symbols;
+    symbols.reserve(annotations.count);
+
+    BOOL delegateImplementsSymbolLookup = [self.delegate respondsToSelector:@selector(mapView:symbolNameForAnnotation:)];
+
+    for (id <MGLAnnotation> annotation in annotations)
+    {
+        latLngs.push_back(coordinateToLatLng(annotation.coordinate));
+
+        NSString *symbolName = nil;
+
+        if (delegateImplementsSymbolLookup)
+        {
+            symbolName = [self.delegate mapView:self symbolNameForAnnotation:annotation];
+        }
+
+        symbols.push_back((symbolName ? [symbolName cStringUsingEncoding:[NSString defaultCStringEncoding]] : ""));
+    }
+
+    std::vector<uint32_t> annotationIDs = mbglMap->addPointAnnotations(latLngs, symbols);
+
+    for (size_t i = 0; i < annotationIDs.size(); ++i)
+    {
+        [self.annotationsStore setObject:@{ MGLAnnotationIDKey : @(annotationIDs[i]) }
+                                  forKey:annotations[i]];
+    }
+}
+
+- (void)removeAnnotation:(id <MGLAnnotation>)annotation
+{
+    // The core bulk deletion API is efficient with respect to indexing
+    // and screen refreshes, thus we should defer to it even for
+    // individual deletes.
+    //
+    [self removeAnnotations:@[ annotation ]];
+}
+
+- (void)removeAnnotations:(NSArray *)annotations
+{
+    std::vector<uint32_t> annotationIDsToRemove;
+    annotationIDsToRemove.reserve(annotations.count);
+
+    for (id <MGLAnnotation> annotation in annotations)
+    {
+        annotationIDsToRemove.push_back([[self.annotationsStore objectForKey:annotation] unsignedIntValue]);
+        [self.annotationsStore removeObjectForKey:annotation];
+    }
+
+    mbglMap->removeAnnotations(annotationIDsToRemove);
+}
+
+- (NSArray *)selectedAnnotations
+{
+    return @[ self.selectedAnnotation ];
+}
+
+- (void)setSelectedAnnotations:(NSArray *)selectedAnnotations
+{
+    id <MGLAnnotation> firstAnnotation = selectedAnnotations[0];
+
+    if ( ! [self viewportBounds].contains(coordinateToLatLng(firstAnnotation.coordinate))) return;
+
+    self.selectedAnnotation = firstAnnotation;
+}
+
+- (void)selectAnnotation:(id <MGLAnnotation>)annotation animated:(BOOL)animated
+{
+    (void)animated;
+
+    if ( ! [self viewportBounds].contains(coordinateToLatLng(annotation.coordinate))) return;
+
+    self.selectedAnnotation = annotation;
+}
+
+- (void)deselectAnnotation:(id <MGLAnnotation>)annotation animated:(BOOL)animated
+{
+    (void)animated;
+
+    if ([self.selectedAnnotation isEqual:annotation]) self.selectedAnnotation = nil;
+}
+
 #pragma mark - Utility -
 
 + (CGFloat)degreesToRadians:(CGFloat)degrees
diff --git a/src/mbgl/map/annotation.cpp b/src/mbgl/map/annotation.cpp
index 0d6da5781..83739ab46 100644
--- a/src/mbgl/map/annotation.cpp
+++ b/src/mbgl/map/annotation.cpp
@@ -40,7 +40,9 @@ std::pair<std::vector<Tile::ID>, std::vector<uint32_t>> AnnotationManager::addPo
 
     uint16_t extent = 4096;
 
-    std::vector<uint32_t> annotationIDs(points.size());
+    std::vector<uint32_t> annotationIDs;
+    annotationIDs.reserve(points.size());
+
     std::vector<Tile::ID> affectedTiles;
 
     for (uint32_t i = 0; i < points.size(); ++i) {

From fbd90ff48a861e06562263b211a69181263bb449 Mon Sep 17 00:00:00 2001
From: "Justin R. Miller" <incanus@codesorcery.net>
Date: Sun, 22 Mar 2015 10:43:10 -0700
Subject: [PATCH 10/21] safety checks & no-op returns

---
 platform/ios/MGLMapView.mm | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/platform/ios/MGLMapView.mm b/platform/ios/MGLMapView.mm
index d61c4dad4..2608e4a00 100644
--- a/platform/ios/MGLMapView.mm
+++ b/platform/ios/MGLMapView.mm
@@ -1576,6 +1576,8 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
 
 - (void)addAnnotation:(id <MGLAnnotation>)annotation
 {
+    if ( ! annotation) return;
+
     // The core bulk add API is efficient with respect to indexing and
     // screen refreshes, thus we should defer to it even for individual adds.
     //
@@ -1584,6 +1586,8 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
 
 - (void)addAnnotations:(NSArray *)annotations
 {
+    if ( ! annotations) return;
+
     std::vector<mbgl::LatLng> latLngs;
     latLngs.reserve(annotations.count);
 
@@ -1594,6 +1598,8 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
 
     for (id <MGLAnnotation> annotation in annotations)
     {
+        assert([annotation conformsToProtocol:@protocol(MGLAnnotation)]);
+
         latLngs.push_back(coordinateToLatLng(annotation.coordinate));
 
         NSString *symbolName = nil;
@@ -1617,6 +1623,8 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
 
 - (void)removeAnnotation:(id <MGLAnnotation>)annotation
 {
+    if ( ! annotation) return;
+
     // The core bulk deletion API is efficient with respect to indexing
     // and screen refreshes, thus we should defer to it even for
     // individual deletes.
@@ -1626,11 +1634,15 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
 
 - (void)removeAnnotations:(NSArray *)annotations
 {
+    if ( ! annotations) return;
+
     std::vector<uint32_t> annotationIDsToRemove;
     annotationIDsToRemove.reserve(annotations.count);
 
     for (id <MGLAnnotation> annotation in annotations)
     {
+        assert([annotation conformsToProtocol:@protocol(MGLAnnotation)]);
+
         annotationIDsToRemove.push_back([[self.annotationsStore objectForKey:annotation] unsignedIntValue]);
         [self.annotationsStore removeObjectForKey:annotation];
     }
@@ -1645,8 +1657,12 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
 
 - (void)setSelectedAnnotations:(NSArray *)selectedAnnotations
 {
+    if ( ! selectedAnnotations.count) return;
+
     id <MGLAnnotation> firstAnnotation = selectedAnnotations[0];
 
+    assert([firstAnnotation conformsToProtocol:@protocol(MGLAnnotation)]);
+
     if ( ! [self viewportBounds].contains(coordinateToLatLng(firstAnnotation.coordinate))) return;
 
     self.selectedAnnotation = firstAnnotation;
@@ -1656,6 +1672,8 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
 {
     (void)animated;
 
+    if ( ! annotation) return;
+
     if ( ! [self viewportBounds].contains(coordinateToLatLng(annotation.coordinate))) return;
 
     self.selectedAnnotation = annotation;
@@ -1665,6 +1683,8 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
 {
     (void)animated;
 
+    if ( ! annotation) return;
+
     if ([self.selectedAnnotation isEqual:annotation]) self.selectedAnnotation = nil;
 }
 

From 8b21104eba0aea267c03c5a49c8709f9cb103646 Mon Sep 17 00:00:00 2001
From: "Justin R. Miller" <incanus@codesorcery.net>
Date: Sun, 22 Mar 2015 10:45:47 -0700
Subject: [PATCH 11/21] more safe return when no selection

---
 platform/ios/MGLMapView.mm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/ios/MGLMapView.mm b/platform/ios/MGLMapView.mm
index 2608e4a00..8593e9da5 100644
--- a/platform/ios/MGLMapView.mm
+++ b/platform/ios/MGLMapView.mm
@@ -1652,7 +1652,7 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
 
 - (NSArray *)selectedAnnotations
 {
-    return @[ self.selectedAnnotation ];
+    return (self.selectedAnnotation ? @[ self.selectedAnnotation ] : @[]);
 }
 
 - (void)setSelectedAnnotations:(NSArray *)selectedAnnotations

From 9dd9bd6e9ddf40ae3ae1746b191ce7d0a8ea0842 Mon Sep 17 00:00:00 2001
From: "Justin R. Miller" <incanus@codesorcery.net>
Date: Sun, 22 Mar 2015 12:14:20 -0700
Subject: [PATCH 12/21] bring in tweaked compass snapping fixes from
 @friedbunny

---
 platform/ios/MGLMapView.mm | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/platform/ios/MGLMapView.mm b/platform/ios/MGLMapView.mm
index 8593e9da5..96ae0b5c2 100644
--- a/platform/ios/MGLMapView.mm
+++ b/platform/ios/MGLMapView.mm
@@ -703,6 +703,8 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
 
         [self unrotateIfNeededAnimated:YES];
 
+        [self snapCompassIfNeeded];
+
         [self notifyMapChange:@(mbgl::MapChangeRegionDidChangeAnimated)];
     }
 }
@@ -1710,7 +1712,7 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
     return (self.zoomLevel > 3);
 }
 
-// correct rotations to north as needed
+// correct rotations to north as needed at low zooms
 //
 - (void)unrotateIfNeededAnimated:(BOOL)animated
 {
@@ -1884,6 +1886,22 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
     }
 }
 
+// reset north on very small gesture-induced angles
+//
+- (void)snapCompassIfNeeded
+{
+    double degrees = mbglMap->getBearing() * -1;
+    while (degrees >= 360) degrees -= 360;
+    while (degrees < 0) degrees += 360;
+
+    double tolerance = 7;
+
+    if (self.compass.alpha > 0 && (degrees < tolerance || degrees > 360 - tolerance))
+    {
+        [self resetNorthAnimated:YES];
+    }
+}
+
 + (UIImage *)resourceImageNamed:(NSString *)imageName
 {
     if ( ! [[imageName pathExtension] length])

From 0e2d6c8277d259792980ceba22b6560f7a68f340 Mon Sep 17 00:00:00 2001
From: "Justin R. Miller" <incanus@codesorcery.net>
Date: Sun, 22 Mar 2015 12:25:10 -0700
Subject: [PATCH 13/21] fixes #1053: umbrella Cocoa header

---
 gyp/platform-ios.gypi        | 1 +
 include/mbgl/ios/MapboxGL.h  | 7 +++++++
 ios/app/MBXViewController.mm | 2 +-
 3 files changed, 9 insertions(+), 1 deletion(-)
 create mode 100644 include/mbgl/ios/MapboxGL.h

diff --git a/gyp/platform-ios.gypi b/gyp/platform-ios.gypi
index cc436561f..a02a96eb1 100644
--- a/gyp/platform-ios.gypi
+++ b/gyp/platform-ios.gypi
@@ -16,6 +16,7 @@
         '../platform/darwin/asset_root.mm',
         '../platform/darwin/image.mm',
         '../platform/darwin/reachability.m',
+        '../include/mbgl/ios/MapboxGL.h',
         '../include/mbgl/ios/MGLMapView.h',
         '../platform/ios/MGLMapView.mm',
         '../include/mbgl/ios/MGLAnnotation.h',
diff --git a/include/mbgl/ios/MapboxGL.h b/include/mbgl/ios/MapboxGL.h
new file mode 100644
index 000000000..237d493f3
--- /dev/null
+++ b/include/mbgl/ios/MapboxGL.h
@@ -0,0 +1,7 @@
+#import "MGLAnnotation.h"
+#import "MGLMapView.h"
+#import "MGLStyleFunctionValue.h"
+#import "MGLTypes.h"
+#import "NSArray+MGLAdditions.h"
+#import "NSDictionary+MGLAdditions.h"
+#import "UIColor+MGLAdditions.h"
diff --git a/ios/app/MBXViewController.mm b/ios/app/MBXViewController.mm
index e12964ac9..5286c7190 100644
--- a/ios/app/MBXViewController.mm
+++ b/ios/app/MBXViewController.mm
@@ -1,6 +1,6 @@
 #import "MBXViewController.h"
 
-#import <mbgl/ios/MGLMapView.h>
+#import <mbgl/ios/MapboxGL.h>
 
 #import <mbgl/platform/darwin/settings_nsuserdefaults.hpp>
 

From 80beb46c815be87b99e3004c9b2995ff644f61c3 Mon Sep 17 00:00:00 2001
From: "Justin R. Miller" <incanus@codesorcery.net>
Date: Sun, 22 Mar 2015 23:09:30 -0700
Subject: [PATCH 14/21] Revert "bring in tweaked compass snapping fixes from
 @friedbunny"

See #1064: problematic & can wait until after beta

This reverts commit 9dd9bd6e9ddf40ae3ae1746b191ce7d0a8ea0842.
---
 platform/ios/MGLMapView.mm | 20 +-------------------
 1 file changed, 1 insertion(+), 19 deletions(-)

diff --git a/platform/ios/MGLMapView.mm b/platform/ios/MGLMapView.mm
index 96ae0b5c2..8593e9da5 100644
--- a/platform/ios/MGLMapView.mm
+++ b/platform/ios/MGLMapView.mm
@@ -703,8 +703,6 @@ mbgl::DefaultFileSource *mbglFileSource = nullptr;
 
         [self unrotateIfNeededAnimated:YES];
 
-        [self snapCompassIfNeeded];
-
         [self notifyMapChange:@(mbgl::MapChangeRegionDidChangeAnimated)];
     }
 }
@@ -1712,7 +1710,7 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
     return (self.zoomLevel > 3);
 }
 
-// correct rotations to north as needed at low zooms
+// correct rotations to north as needed
 //
 - (void)unrotateIfNeededAnimated:(BOOL)animated
 {
@@ -1886,22 +1884,6 @@ CLLocationCoordinate2D latLngToCoordinate(mbgl::LatLng latLng)
     }
 }
 
-// reset north on very small gesture-induced angles
-//
-- (void)snapCompassIfNeeded
-{
-    double degrees = mbglMap->getBearing() * -1;
-    while (degrees >= 360) degrees -= 360;
-    while (degrees < 0) degrees += 360;
-
-    double tolerance = 7;
-
-    if (self.compass.alpha > 0 && (degrees < tolerance || degrees > 360 - tolerance))
-    {
-        [self resetNorthAnimated:YES];
-    }
-}
-
 + (UIImage *)resourceImageNamed:(NSString *)imageName
 {
     if ( ! [[imageName pathExtension] length])

From ebd2985f785e19f3d4976f2d803ac017b755d0d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= <mail@kkaefer.com>
Date: Fri, 20 Mar 2015 18:33:29 +0100
Subject: [PATCH 15/21] make style updates a little more threadsafe

- we're now always loading and parsing styles in the map thread
- adds an atomic enum that stores the actual updates we need to perform
- adds a MapData object that mutexes access to variables used from both threads
---
 include/mbgl/map/map.hpp  |  25 ++++++--
 src/mbgl/map/map.cpp      | 130 ++++++++++++++++++++++++--------------
 src/mbgl/map/map_data.hpp |  36 +++++++++++
 3 files changed, 137 insertions(+), 54 deletions(-)
 create mode 100644 src/mbgl/map/map_data.hpp

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 06ae39d87..9ea5c72f6 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -39,6 +39,7 @@ class LineAtlas;
 class Environment;
 class EnvironmentScope;
 class AnnotationManager;
+class MapData;
 
 class Map : private util::noncopyable {
     friend class View;
@@ -75,7 +76,12 @@ public:
     void render();
 
     // Notifies the Map thread that the state has changed and an update might be necessary.
-    void triggerUpdate();
+    using UpdateType = uint32_t;
+    enum class Update : UpdateType {
+        Nothing   = 0,
+        StyleInfo = 1 << 0,
+    };
+    void triggerUpdate(Update = Update::Nothing);
 
     // Triggers a render. Can be called from any thread.
     void triggerRender();
@@ -92,8 +98,8 @@ public:
 
     void setDefaultTransitionDuration(std::chrono::steady_clock::duration duration = std::chrono::steady_clock::duration::zero());
     std::chrono::steady_clock::duration getDefaultTransitionDuration();
-    void setStyleURL(const std::string &url);
-    void setStyleJSON(std::string newStyleJSON, const std::string &base = "");
+    void setStyleURL(const std::string& url);
+    void setStyleJSON(const std::string& json, const std::string& base = "");
     std::string getStyleJSON() const;
 
     // Transition
@@ -178,6 +184,13 @@ private:
     void updateSources();
     void updateSources(const util::ptr<StyleLayerGroup> &group);
 
+    // Triggered by triggerUpdate();
+    void update();
+
+    // Loads the style set in the data object. Called by Update::StyleInfo
+    void reloadStyle();
+    void loadStyleJSON(const std::string& json, const std::string& base);
+
     // Prepares a map render by updating the tiles we need for the current view, as well as updating
     // the stylesheet.
     void prepare();
@@ -234,8 +247,8 @@ private:
     std::unique_ptr<Painter> painter;
     util::ptr<AnnotationManager> annotationManager;
 
-    std::string styleURL;
-    std::string styleJSON = "";
+    const std::unique_ptr<MapData> data;
+
     std::vector<std::string> classes;
     std::string accessToken;
 
@@ -245,6 +258,8 @@ private:
     std::chrono::steady_clock::time_point animationTime = std::chrono::steady_clock::time_point::min();
 
     std::set<util::ptr<StyleSource>> activeSources;
+
+    std::atomic<UpdateType> updated;
 };
 
 }
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index ae1cfd20f..57000e040 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/environment.hpp>
 #include <mbgl/map/view.hpp>
+#include <mbgl/map/map_data.hpp>
 #include <mbgl/platform/platform.hpp>
 #include <mbgl/map/source.hpp>
 #include <mbgl/renderer/painter.hpp>
@@ -71,7 +72,8 @@ Map::Map(View& view_, FileSource& fileSource_)
       lineAtlas(util::make_unique<LineAtlas>(512, 512)),
       texturePool(std::make_shared<TexturePool>()),
       painter(util::make_unique<Painter>(*spriteAtlas, *glyphAtlas, *lineAtlas)),
-      annotationManager(util::make_unique<AnnotationManager>())
+      annotationManager(util::make_unique<AnnotationManager>()),
+      data(util::make_unique<MapData>())
 {
     view.initialize(this);
 }
@@ -138,11 +140,7 @@ void Map::start(bool startPaused) {
     });
 
     asyncUpdate = util::make_unique<uv::async>(env->loop, [this] {
-        assert(Environment::currentlyOn(ThreadType::Map));
-
-        if (state.hasSize()) {
-            prepare();
-        }
+        update();
     });
 
     asyncRender = util::make_unique<uv::async>(env->loop, [this] {
@@ -175,6 +173,8 @@ void Map::start(bool startPaused) {
         isStopped = true;
         view.notify();
     });
+
+    triggerUpdate();
 }
 
 void Map::stop(std::function<void ()> callback) {
@@ -252,7 +252,9 @@ void Map::run() {
         checkForPause();
     }
 
-    if (mode == Mode::Static && !style && styleURL.empty()) {
+    auto styleInfo = data->getStyleInfo();
+
+    if (mode == Mode::Static && !style && (styleInfo.url.empty() && styleInfo.json.empty())) {
         throw util::Exception("Style is not set");
     }
 
@@ -297,7 +299,9 @@ void Map::renderSync() {
     rendered = false;
 }
 
-void Map::triggerUpdate() {
+void Map::triggerUpdate(const Update u) {
+    updated |= static_cast<UpdateType>(u);
+
     if (mode == Mode::Static) {
         prepare();
     } else if (asyncUpdate) {
@@ -345,36 +349,27 @@ void Map::setup() {
 }
 
 void Map::setStyleURL(const std::string &url) {
-    // TODO: Make threadsafe.
+    assert(Environment::currentlyOn(ThreadType::Main));
 
-    styleURL = url;
-    if (mode == Mode::Continuous) {
-        stop();
-        start();
+    const size_t pos = url.rfind('/');
+    std::string base = "";
+    if (pos != std::string::npos) {
+        base = url.substr(0, pos + 1);
     }
+
+    data->setStyleInfo({ url, base, "" });
+    triggerUpdate(Update::StyleInfo);
 }
 
-void Map::setStyleJSON(std::string newStyleJSON, const std::string &base) {
-    // TODO: Make threadsafe.
-    styleJSON.swap(newStyleJSON);
-    sprite.reset();
-    if (!style) {
-        style = std::make_shared<Style>();
-    }
+void Map::setStyleJSON(const std::string& json, const std::string& base) {
+    assert(Environment::currentlyOn(ThreadType::Main));
 
-    style->base = base;
-    style->loadJSON((const uint8_t *)styleJSON.c_str());
-    style->cascadeClasses(classes);
-    style->setDefaultTransitionDuration(defaultTransitionDuration);
-
-    const std::string glyphURL = util::mapbox::normalizeGlyphsURL(style->glyph_url, getAccessToken());
-    glyphStore->setURL(glyphURL);
-
-    triggerUpdate();
+    data->setStyleInfo({ "", base, json });
+    triggerUpdate(Update::StyleInfo);
 }
 
 std::string Map::getStyleJSON() const {
-    return styleJSON;
+    return data->getStyleInfo().json;
 }
 
 util::ptr<Sprite> Map::getSprite() {
@@ -670,7 +665,9 @@ void Map::updateSources() {
     }
 
     // Then, reenable all of those that we actually use when drawing this layer.
-    updateSources(style->layers);
+    if (style) {
+        updateSources(style->layers);
+    }
 
     // Then, construct or destroy the actual source object, depending on enabled state.
     for (const auto& source : activeSources) {
@@ -715,26 +712,58 @@ void Map::updateTiles() {
     }
 }
 
-void Map::prepare() {
+void Map::update() {
     assert(Environment::currentlyOn(ThreadType::Map));
 
-    if (!style) {
-        style = std::make_shared<Style>();
+    if (state.hasSize()) {
+        prepare();
+    }
+}
 
-        env->request({ Resource::Kind::JSON, styleURL}, [&](const Response &res) {
+void Map::reloadStyle() {
+    assert(Environment::currentlyOn(ThreadType::Map));
+
+    style = std::make_shared<Style>();
+
+    const auto styleInfo = data->getStyleInfo();
+
+    if (!styleInfo.url.empty()) {
+        // We have a style URL
+        env->request({ Resource::Kind::JSON, styleInfo.url }, [&](const Response &res) {
             if (res.status == Response::Successful) {
-                // Calculate the base
-                const size_t pos = styleURL.rfind('/');
-                std::string base = "";
-                if (pos != std::string::npos) {
-                    base = styleURL.substr(0, pos + 1);
-                }
-
-                setStyleJSON(res.data, base);
+                loadStyleJSON(res.data, styleInfo.base);
             } else {
                 Log::Error(Event::Setup, "loading style failed: %s", res.message.c_str());
             }
         });
+    } else {
+        // We got JSON data directly.
+        loadStyleJSON(styleInfo.json, styleInfo.base);
+    }
+}
+
+void Map::loadStyleJSON(const std::string& json, const std::string& base) {
+    assert(Environment::currentlyOn(ThreadType::Map));
+
+    sprite.reset();
+    style = std::make_shared<Style>();
+    style->base = base;
+    style->loadJSON((const uint8_t *)json.c_str());
+    style->cascadeClasses(classes);
+    style->setDefaultTransitionDuration(defaultTransitionDuration);
+
+    const std::string glyphURL = util::mapbox::normalizeGlyphsURL(style->glyph_url, getAccessToken());
+    glyphStore->setURL(glyphURL);
+
+    triggerUpdate();
+}
+
+void Map::prepare() {
+    assert(Environment::currentlyOn(ThreadType::Map));
+
+    const auto u = updated.exchange(static_cast<UpdateType>(Update::Nothing));
+    if (u & static_cast<UpdateType>(Update::StyleInfo)) {
+        reloadStyle();
     }
 
     // Update transform transitions.
@@ -746,14 +775,17 @@ void Map::prepare() {
     state = transform.currentState();
 
     animationTime = std::chrono::steady_clock::now();
-    updateSources();
-    style->updateProperties(state.getNormalizedZoom(), animationTime);
 
-    // Allow the sprite atlas to potentially pull new sprite images if needed.
-    spriteAtlas->resize(state.getPixelRatio());
-    spriteAtlas->setSprite(getSprite());
+    if (style) {
+        updateSources();
+        style->updateProperties(state.getNormalizedZoom(), animationTime);
 
-    updateTiles();
+        // Allow the sprite atlas to potentially pull new sprite images if needed.
+        spriteAtlas->resize(state.getPixelRatio());
+        spriteAtlas->setSprite(getSprite());
+
+        updateTiles();
+    }
 
     if (mode == Mode::Continuous) {
         view.invalidate();
diff --git a/src/mbgl/map/map_data.hpp b/src/mbgl/map/map_data.hpp
new file mode 100644
index 000000000..98d2518a2
--- /dev/null
+++ b/src/mbgl/map/map_data.hpp
@@ -0,0 +1,36 @@
+#ifndef MBGL_MAP_MAP_DATA
+#define MBGL_MAP_MAP_DATA
+
+#include <string>
+#include <mutex>
+
+namespace mbgl {
+
+struct StyleInfo {
+    std::string url;
+    std::string base;
+    std::string json;
+};
+
+class MapData {
+    using Lock = std::lock_guard<std::mutex>;
+
+public:
+    inline StyleInfo getStyleInfo() const {
+        Lock lock(mtx);
+        return styleInfo;
+    }
+    inline void setStyleInfo(StyleInfo&& info) {
+        Lock lock(mtx);
+        styleInfo = info;
+    }
+
+private:
+    mutable std::mutex mtx;
+
+    StyleInfo styleInfo;
+};
+
+}
+
+#endif

From 03e400e00224e8012d4272ad9ebcba0bc11ed3f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= <mail@kkaefer.com>
Date: Fri, 20 Mar 2015 18:53:44 +0100
Subject: [PATCH 16/21] make the debug flag atomic and move to MapData

---
 include/mbgl/map/map.hpp  |  2 +-
 src/mbgl/map/map.cpp      | 15 +++++++++------
 src/mbgl/map/map_data.hpp |  6 ++++++
 3 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 9ea5c72f6..71e81d077 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -80,6 +80,7 @@ public:
     enum class Update : UpdateType {
         Nothing   = 0,
         StyleInfo = 1 << 0,
+        Debug     = 1 << 1,
     };
     void triggerUpdate(Update = Update::Nothing);
 
@@ -254,7 +255,6 @@ private:
 
     std::chrono::steady_clock::duration defaultTransitionDuration;
 
-    bool debug = false;
     std::chrono::steady_clock::time_point animationTime = std::chrono::steady_clock::time_point::min();
 
     std::set<util::ptr<StyleSource>> activeSources;
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 57000e040..e00cf6e0a 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -591,18 +591,17 @@ void Map::updateAnnotationTiles(std::vector<Tile::ID>& ids) {
 #pragma mark - Toggles
 
 void Map::setDebug(bool value) {
-    debug = value;
-    assert(painter);
-    painter->setDebug(debug);
-    triggerUpdate();
+    data->setDebug(value);
+    triggerUpdate(Update::Debug);
 }
 
 void Map::toggleDebug() {
-    setDebug(!debug);
+    data->toggleDebug();
+    triggerUpdate(Update::Debug);
 }
 
 bool Map::getDebug() const {
-    return debug;
+    return data->getDebug();
 }
 
 void Map::addClass(const std::string& klass) {
@@ -765,6 +764,10 @@ void Map::prepare() {
     if (u & static_cast<UpdateType>(Update::StyleInfo)) {
         reloadStyle();
     }
+    if (u & static_cast<UpdateType>(Update::Debug)) {
+        assert(painter);
+        painter->setDebug(data->getDebug());
+    }
 
     // Update transform transitions.
     animationTime = std::chrono::steady_clock::now();
diff --git a/src/mbgl/map/map_data.hpp b/src/mbgl/map/map_data.hpp
index 98d2518a2..55bf5f7f6 100644
--- a/src/mbgl/map/map_data.hpp
+++ b/src/mbgl/map/map_data.hpp
@@ -3,6 +3,7 @@
 
 #include <string>
 #include <mutex>
+#include <atomic>
 
 namespace mbgl {
 
@@ -25,10 +26,15 @@ public:
         styleInfo = info;
     }
 
+    inline bool getDebug() const { return debug; }
+    inline bool toggleDebug() { return debug ^= 1u; }
+    inline void setDebug(bool value) { debug = value; }
+
 private:
     mutable std::mutex mtx;
 
     StyleInfo styleInfo;
+    std::atomic<uint8_t> debug;
 };
 
 }

From 268975d4c2d8ce572a500a5f4b06a13eca51cf28 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= <mail@kkaefer.com>
Date: Fri, 20 Mar 2015 19:13:40 +0100
Subject: [PATCH 17/21] move animationTime to MapData store

---
 include/mbgl/map/map.hpp  |  4 +---
 src/mbgl/map/map.cpp      | 12 ++++++++----
 src/mbgl/map/map_data.hpp | 29 +++++++++++++++++++++++++----
 3 files changed, 34 insertions(+), 11 deletions(-)

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 71e81d077..7473a0694 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -164,7 +164,7 @@ public:
     bool getDebug() const;
 
     inline const TransformState &getState() const { return state; }
-    inline std::chrono::steady_clock::time_point getTime() const { return animationTime; }
+    std::chrono::steady_clock::time_point getTime() const;
     inline AnnotationManager& getAnnotationManager() const { return *annotationManager; }
 
 private:
@@ -255,8 +255,6 @@ private:
 
     std::chrono::steady_clock::duration defaultTransitionDuration;
 
-    std::chrono::steady_clock::time_point animationTime = std::chrono::steady_clock::time_point::min();
-
     std::set<util::ptr<StyleSource>> activeSources;
 
     std::atomic<UpdateType> updated;
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index e00cf6e0a..8d4dd1461 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -604,6 +604,10 @@ bool Map::getDebug() const {
     return data->getDebug();
 }
 
+std::chrono::steady_clock::time_point Map::getTime() const {
+    return data->getAnimationTime();
+}
+
 void Map::addClass(const std::string& klass) {
     if (hasClass(klass)) return;
     classes.push_back(klass);
@@ -770,15 +774,15 @@ void Map::prepare() {
     }
 
     // Update transform transitions.
-    animationTime = std::chrono::steady_clock::now();
+
+    const auto animationTime = std::chrono::steady_clock::now();
+    data->setAnimationTime(animationTime);
     if (transform.needsTransition()) {
         transform.updateTransitions(animationTime);
     }
 
     state = transform.currentState();
 
-    animationTime = std::chrono::steady_clock::now();
-
     if (style) {
         updateSources();
         style->updateProperties(state.getNormalizedZoom(), animationTime);
@@ -803,7 +807,7 @@ void Map::render() {
 
     assert(painter);
     painter->render(*style, activeSources,
-                    state, animationTime);
+                    state, data->getAnimationTime());
     // Schedule another rerender when we definitely need a next frame.
     if (transform.needsTransition() || style->hasTransitions()) {
         triggerUpdate();
diff --git a/src/mbgl/map/map_data.hpp b/src/mbgl/map/map_data.hpp
index 55bf5f7f6..8efa43911 100644
--- a/src/mbgl/map/map_data.hpp
+++ b/src/mbgl/map/map_data.hpp
@@ -4,6 +4,7 @@
 #include <string>
 #include <mutex>
 #include <atomic>
+#include <chrono>
 
 namespace mbgl {
 
@@ -17,6 +18,10 @@ class MapData {
     using Lock = std::lock_guard<std::mutex>;
 
 public:
+    inline MapData() {
+        setAnimationTime(std::chrono::steady_clock::time_point::min());
+    }
+
     inline StyleInfo getStyleInfo() const {
         Lock lock(mtx);
         return styleInfo;
@@ -26,15 +31,31 @@ public:
         styleInfo = info;
     }
 
-    inline bool getDebug() const { return debug; }
-    inline bool toggleDebug() { return debug ^= 1u; }
-    inline void setDebug(bool value) { debug = value; }
+    inline bool getDebug() const {
+        return debug;
+    }
+    inline bool toggleDebug() {
+        return debug ^= 1u;
+    }
+    inline void setDebug(bool value) {
+        debug = value;
+    }
+
+    inline std::chrono::steady_clock::time_point getAnimationTime() const {
+        // We're casting the time_point to and from a duration because libstdc++
+        // has a bug that doesn't allow time_points to be atomic.
+        return std::chrono::steady_clock::time_point(animationTime);
+    }
+    inline void setAnimationTime(std::chrono::steady_clock::time_point timePoint) {
+        animationTime = timePoint.time_since_epoch();
+    };
 
 private:
     mutable std::mutex mtx;
 
     StyleInfo styleInfo;
-    std::atomic<uint8_t> debug;
+    std::atomic<uint8_t> debug { false };
+    std::atomic<std::chrono::steady_clock::time_point::duration> animationTime;
 };
 
 }

From 9637176711f2f72e5bfa06561050c4737da6953c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= <mail@kkaefer.com>
Date: Fri, 20 Mar 2015 19:22:27 +0100
Subject: [PATCH 18/21] move defaultTransitionDuration to MapData

---
 include/mbgl/map/map.hpp  |  9 ++++-----
 src/mbgl/map/map.cpp      | 18 ++++++++++++------
 src/mbgl/map/map_data.hpp |  9 +++++++++
 3 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 7473a0694..e77149a4d 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -78,9 +78,10 @@ public:
     // Notifies the Map thread that the state has changed and an update might be necessary.
     using UpdateType = uint32_t;
     enum class Update : UpdateType {
-        Nothing   = 0,
-        StyleInfo = 1 << 0,
-        Debug     = 1 << 1,
+        Nothing                   = 0,
+        StyleInfo                 = 1 << 0,
+        Debug                     = 1 << 1,
+        DefaultTransitionDuration = 1 << 2,
     };
     void triggerUpdate(Update = Update::Nothing);
 
@@ -253,8 +254,6 @@ private:
     std::vector<std::string> classes;
     std::string accessToken;
 
-    std::chrono::steady_clock::duration defaultTransitionDuration;
-
     std::set<util::ptr<StyleSource>> activeSources;
 
     std::atomic<UpdateType> updated;
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 8d4dd1461..4ebd4100b 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -649,14 +649,15 @@ std::vector<std::string> Map::getClasses() const {
 }
 
 void Map::setDefaultTransitionDuration(std::chrono::steady_clock::duration duration) {
-    defaultTransitionDuration = duration;
-    if (style) {
-        style->setDefaultTransitionDuration(duration);
-    }
+    assert(Environment::currentlyOn(ThreadType::Main));
+
+    data->setDefaultTransitionDuration(duration);
+    triggerUpdate(Update::DefaultTransitionDuration);
 }
 
 std::chrono::steady_clock::duration Map::getDefaultTransitionDuration() {
-    return defaultTransitionDuration;
+    assert(Environment::currentlyOn(ThreadType::Main));
+    return data->getDefaultTransitionDuration();
 }
 
 void Map::updateSources() {
@@ -753,7 +754,7 @@ void Map::loadStyleJSON(const std::string& json, const std::string& base) {
     style->base = base;
     style->loadJSON((const uint8_t *)json.c_str());
     style->cascadeClasses(classes);
-    style->setDefaultTransitionDuration(defaultTransitionDuration);
+    style->setDefaultTransitionDuration(data->getDefaultTransitionDuration());
 
     const std::string glyphURL = util::mapbox::normalizeGlyphsURL(style->glyph_url, getAccessToken());
     glyphStore->setURL(glyphURL);
@@ -772,6 +773,11 @@ void Map::prepare() {
         assert(painter);
         painter->setDebug(data->getDebug());
     }
+    if (u & static_cast<UpdateType>(Update::DefaultTransitionDuration)) {
+        if (style) {
+            style->setDefaultTransitionDuration(data->getDefaultTransitionDuration());
+        }
+    }
 
     // Update transform transitions.
 
diff --git a/src/mbgl/map/map_data.hpp b/src/mbgl/map/map_data.hpp
index 8efa43911..972ad3406 100644
--- a/src/mbgl/map/map_data.hpp
+++ b/src/mbgl/map/map_data.hpp
@@ -20,6 +20,7 @@ class MapData {
 public:
     inline MapData() {
         setAnimationTime(std::chrono::steady_clock::time_point::min());
+        setDefaultTransitionDuration(std::chrono::steady_clock::duration::zero());
     }
 
     inline StyleInfo getStyleInfo() const {
@@ -50,12 +51,20 @@ public:
         animationTime = timePoint.time_since_epoch();
     };
 
+    inline std::chrono::steady_clock::duration getDefaultTransitionDuration() const {
+        return defaultTransitionDuration;
+    }
+    inline void setDefaultTransitionDuration(std::chrono::steady_clock::duration duration) {
+        defaultTransitionDuration = duration;
+    };
+
 private:
     mutable std::mutex mtx;
 
     StyleInfo styleInfo;
     std::atomic<uint8_t> debug { false };
     std::atomic<std::chrono::steady_clock::time_point::duration> animationTime;
+    std::atomic<std::chrono::steady_clock::duration> defaultTransitionDuration;
 };
 
 }

From 3d2dcbb6efe38bad93edaaae2d2def2274d4942b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= <mail@kkaefer.com>
Date: Fri, 20 Mar 2015 19:29:10 +0100
Subject: [PATCH 19/21] move accessToken to MapData

---
 include/mbgl/map/map.hpp  |  3 +--
 src/mbgl/map/map.cpp      |  6 +++---
 src/mbgl/map/map_data.hpp | 10 ++++++++++
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index e77149a4d..d18df67a0 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -139,7 +139,7 @@ public:
 
     // API
     void setAccessToken(const std::string &token);
-    const std::string &getAccessToken() const;
+    std::string getAccessToken() const;
 
     // Projection
     inline void getWorldBoundsMeters(ProjectedMeters &sw, ProjectedMeters &ne) const { Projection::getWorldBoundsMeters(sw, ne); }
@@ -252,7 +252,6 @@ private:
     const std::unique_ptr<MapData> data;
 
     std::vector<std::string> classes;
-    std::string accessToken;
 
     std::set<util::ptr<StyleSource>> activeSources;
 
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 4ebd4100b..c57ed3dfb 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -530,11 +530,11 @@ void Map::stopRotating() {
 #pragma mark - Access Token
 
 void Map::setAccessToken(const std::string &token) {
-    accessToken = token;
+    data->setAccessToken(token);
 }
 
-const std::string &Map::getAccessToken() const {
-    return accessToken;
+std::string Map::getAccessToken() const {
+    return data->getAccessToken();
 }
 
 #pragma mark - Annotations
diff --git a/src/mbgl/map/map_data.hpp b/src/mbgl/map/map_data.hpp
index 972ad3406..29ba22711 100644
--- a/src/mbgl/map/map_data.hpp
+++ b/src/mbgl/map/map_data.hpp
@@ -32,6 +32,15 @@ public:
         styleInfo = info;
     }
 
+    inline std::string getAccessToken() const {
+        Lock lock(mtx);
+        return accessToken;
+    }
+    inline void setAccessToken(const std::string &token) {
+        Lock lock(mtx);
+        accessToken = token;
+    }
+
     inline bool getDebug() const {
         return debug;
     }
@@ -62,6 +71,7 @@ private:
     mutable std::mutex mtx;
 
     StyleInfo styleInfo;
+    std::string accessToken;
     std::atomic<uint8_t> debug { false };
     std::atomic<std::chrono::steady_clock::time_point::duration> animationTime;
     std::atomic<std::chrono::steady_clock::duration> defaultTransitionDuration;

From d2faca1861e0cca4e08224969280778e2e3e71a2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= <mail@kkaefer.com>
Date: Fri, 20 Mar 2015 19:46:52 +0100
Subject: [PATCH 20/21] move style classes to MapData object and make thread
 safe

---
 include/mbgl/map/map.hpp  |  3 +--
 src/mbgl/map/map.cpp      | 40 +++++++++++++----------------------
 src/mbgl/map/map_data.cpp | 44 +++++++++++++++++++++++++++++++++++++++
 src/mbgl/map/map_data.hpp | 20 ++++++++++++++++++
 4 files changed, 80 insertions(+), 27 deletions(-)
 create mode 100644 src/mbgl/map/map_data.cpp

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index d18df67a0..e5eabdac4 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -82,6 +82,7 @@ public:
         StyleInfo                 = 1 << 0,
         Debug                     = 1 << 1,
         DefaultTransitionDuration = 1 << 2,
+        Classes                   = 1 << 3,
     };
     void triggerUpdate(Update = Update::Nothing);
 
@@ -251,8 +252,6 @@ private:
 
     const std::unique_ptr<MapData> data;
 
-    std::vector<std::string> classes;
-
     std::set<util::ptr<StyleSource>> activeSources;
 
     std::atomic<UpdateType> updated;
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index c57ed3dfb..1473346a3 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -609,43 +609,28 @@ std::chrono::steady_clock::time_point Map::getTime() const {
 }
 
 void Map::addClass(const std::string& klass) {
-    if (hasClass(klass)) return;
-    classes.push_back(klass);
-    if (style) {
-        style->cascadeClasses(classes);
-        if (style->hasTransitions()) {
-            triggerUpdate();
-        }
+    if (data->addClass(klass)) {
+        triggerUpdate(Update::Classes);
     }
 }
 
 void Map::removeClass(const std::string& klass) {
-    if (!hasClass(klass)) return;
-    classes.erase(std::remove(classes.begin(), classes.end(), klass), classes.end());
-    if (style) {
-        style->cascadeClasses(classes);
-        if (style->hasTransitions()) {
-            triggerUpdate();
-        }
+    if (data->removeClass(klass)) {
+        triggerUpdate(Update::Classes);
     }
 }
 
-void Map::setClasses(const std::vector<std::string>& classes_) {
-    classes = classes_;
-    if (style) {
-        style->cascadeClasses(classes);
-        if (style->hasTransitions()) {
-            triggerUpdate();
-        }
-    }
+void Map::setClasses(const std::vector<std::string>& classes) {
+    data->setClasses(classes);
+    triggerUpdate(Update::Classes);
 }
 
 bool Map::hasClass(const std::string& klass) const {
-    return std::find(classes.begin(), classes.end(), klass) != classes.end();
+    return data->hasClass(klass);
 }
 
 std::vector<std::string> Map::getClasses() const {
-   return classes;
+    return data->getClasses();
 }
 
 void Map::setDefaultTransitionDuration(std::chrono::steady_clock::duration duration) {
@@ -753,7 +738,7 @@ void Map::loadStyleJSON(const std::string& json, const std::string& base) {
     style = std::make_shared<Style>();
     style->base = base;
     style->loadJSON((const uint8_t *)json.c_str());
-    style->cascadeClasses(classes);
+    style->cascadeClasses(data->getClasses());
     style->setDefaultTransitionDuration(data->getDefaultTransitionDuration());
 
     const std::string glyphURL = util::mapbox::normalizeGlyphsURL(style->glyph_url, getAccessToken());
@@ -778,6 +763,11 @@ void Map::prepare() {
             style->setDefaultTransitionDuration(data->getDefaultTransitionDuration());
         }
     }
+    if (u & static_cast<UpdateType>(Update::Classes)) {
+        if (style) {
+            style->cascadeClasses(data->getClasses());
+        }
+    }
 
     // Update transform transitions.
 
diff --git a/src/mbgl/map/map_data.cpp b/src/mbgl/map/map_data.cpp
new file mode 100644
index 000000000..23bc09499
--- /dev/null
+++ b/src/mbgl/map/map_data.cpp
@@ -0,0 +1,44 @@
+#include "map_data.hpp"
+
+#include <algorithm>
+
+namespace mbgl {
+
+// Adds the class if it's not yet set. Returns true when it added the class, and false when it
+// was already present.
+bool MapData::addClass(const std::string& klass) {
+    Lock lock(mtx);
+    if (std::find(classes.begin(), classes.end(), klass) != classes.end()) return false;
+    classes.push_back(klass);
+    return true;
+}
+
+// Removes the class if it's present. Returns true when it remvoed the class, and false when it
+// was not present.
+bool MapData::removeClass(const std::string& klass) {
+    Lock lock(mtx);
+    const auto it = std::find(classes.begin(), classes.end(), klass);
+    if (it != classes.end()) {
+        classes.erase(it);
+        return true;
+    }
+    return false;
+}
+
+// Returns true when class is present in the list of currently set classes.
+bool MapData::hasClass(const std::string& klass) const {
+    Lock lock(mtx);
+    return std::find(classes.begin(), classes.end(), klass) != classes.end();
+}
+
+void MapData::setClasses(const std::vector<std::string>& klasses) {
+    Lock lock(mtx);
+    classes = klasses;
+}
+
+std::vector<std::string> MapData::getClasses() const {
+    Lock lock(mtx);
+    return classes;
+}
+
+}
\ No newline at end of file
diff --git a/src/mbgl/map/map_data.hpp b/src/mbgl/map/map_data.hpp
index 29ba22711..c0d57134d 100644
--- a/src/mbgl/map/map_data.hpp
+++ b/src/mbgl/map/map_data.hpp
@@ -5,6 +5,7 @@
 #include <mutex>
 #include <atomic>
 #include <chrono>
+#include <vector>
 
 namespace mbgl {
 
@@ -41,6 +42,24 @@ public:
         accessToken = token;
     }
 
+    // Adds the class if it's not yet set. Returns true when it added the class, and false when it
+    // was already present.
+    bool addClass(const std::string& klass);
+
+    // Removes the class if it's present. Returns true when it remvoed the class, and false when it
+    // was not present.
+    bool removeClass(const std::string& klass);
+
+    // Returns true when class is present in the list of currently set classes.
+    bool hasClass(const std::string& klass) const;
+
+    // Changes the list of currently set classes to the new list.
+    void setClasses(const std::vector<std::string>& klasses);
+
+    // Returns a list of all currently set classes.
+    std::vector<std::string> getClasses() const;
+
+
     inline bool getDebug() const {
         return debug;
     }
@@ -72,6 +91,7 @@ private:
 
     StyleInfo styleInfo;
     std::string accessToken;
+    std::vector<std::string> classes;
     std::atomic<uint8_t> debug { false };
     std::atomic<std::chrono::steady_clock::time_point::duration> animationTime;
     std::atomic<std::chrono::steady_clock::duration> defaultTransitionDuration;

From 9d30d4042c3311d02568adbb38dd13fb82faf75d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= <mail@kkaefer.com>
Date: Mon, 23 Mar 2015 12:18:40 +0100
Subject: [PATCH 21/21] delete the workers in the correct thread

fixes #1066
---
 src/mbgl/map/map.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 1473346a3..bc53d0d0f 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -129,6 +129,7 @@ void Map::start(bool startPaused) {
 
         // Remove all of these to make sure they are destructed in the correct thread.
         style.reset();
+        workers.reset();
         activeSources.clear();
 
         terminating = true;