From 34fe7dc627f08d57ac259c383e248ddf2f6fb0d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Fri, 22 Aug 2014 18:50:09 +0200
Subject: add basic request caching with sqlite

---
 include/mbgl/platform/event.hpp  |  2 ++
 include/mbgl/util/filesource.hpp | 15 ++++++++++++++-
 2 files changed, 16 insertions(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mbgl/platform/event.hpp b/include/mbgl/platform/event.hpp
index 1676f40d2c..d2a06618a3 100644
--- a/include/mbgl/platform/event.hpp
+++ b/include/mbgl/platform/event.hpp
@@ -29,6 +29,7 @@ enum class Event : uint8_t {
     ParseStyle,
     ParseTile,
     Render,
+    Database,
     HttpRequest,
     Sprite,
 };
@@ -40,6 +41,7 @@ MBGL_DEFINE_ENUM_CLASS(EventClass, Event, {
     { Event::ParseStyle, "ParseStyle" },
     { Event::ParseTile, "ParseTile" },
     { Event::Render, "Render" },
+    { Event::Database, "Database" },
     { Event::HttpRequest, "HttpRequest" },
     { Event::Sprite, "Sprite" },
     { Event(-1), "Unknown" },
diff --git a/include/mbgl/util/filesource.hpp b/include/mbgl/util/filesource.hpp
index 18c63ddfeb..bc0a2927de 100644
--- a/include/mbgl/util/filesource.hpp
+++ b/include/mbgl/util/filesource.hpp
@@ -2,11 +2,15 @@
 #define MBGL_UTIL_FILESOURCE
 
 #include <mbgl/util/uv.hpp>
+#include <mbgl/util/noncopyable.hpp>
 
 #include <string>
 #include <memory>
 #include <functional>
 
+typedef struct sqlite3 sqlite3;
+typedef struct sqlite3_stmt sqlite3_stmt;
+
 namespace mbgl {
 
 namespace platform {
@@ -21,21 +25,30 @@ enum class ResourceType : uint8_t {
     JSON
 };
 
-class FileSource {
+class FileSource : private util::noncopyable, public std::enable_shared_from_this<FileSource> {
 public:
     FileSource();
+    ~FileSource();
 
     void setBase(const std::string &value);
     const std::string &getBase() const;
 
     void load(ResourceType type, const std::string &url, std::function<void(platform::Response *)> callback, const std::shared_ptr<uv::loop> loop = nullptr);
 
+private:
+    void closeDatabase();
+    void createSchema();
+    bool loadFile(const std::string &url, std::function<void(platform::Response *)> callback);
+    void saveFile(const std::string &url, platform::Response *res);
+
 private:
     // Stores a URL that is used as a base for loading resources with relative path.
     std::string base;
 
     // Stores the absolute path to the cache directory.
     const std::string cache;
+
+    sqlite3 *db = nullptr;
 };
 
 }
-- 
cgit v1.2.1


From 28446bed24689b2bac7c8bfbd37741a7fa4fa6be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Mon, 25 Aug 2014 14:02:40 +0200
Subject: compress data and store type

---
 include/mbgl/util/compression.hpp | 15 +++++++++++++++
 include/mbgl/util/filesource.hpp  | 14 +++++++-------
 2 files changed, 22 insertions(+), 7 deletions(-)
 create mode 100644 include/mbgl/util/compression.hpp

(limited to 'include')

diff --git a/include/mbgl/util/compression.hpp b/include/mbgl/util/compression.hpp
new file mode 100644
index 0000000000..a33b2476a7
--- /dev/null
+++ b/include/mbgl/util/compression.hpp
@@ -0,0 +1,15 @@
+#ifndef MBGL_UTIL_COMPRESSION
+#define MBGL_UTIL_COMPRESSION
+
+#include <string>
+
+namespace mbgl {
+namespace util {
+
+std::string compress(const std::string &raw);
+std::string decompress(const std::string &raw);
+
+}
+}
+
+#endif
diff --git a/include/mbgl/util/filesource.hpp b/include/mbgl/util/filesource.hpp
index bc0a2927de..ccff4b5122 100644
--- a/include/mbgl/util/filesource.hpp
+++ b/include/mbgl/util/filesource.hpp
@@ -18,11 +18,11 @@ struct Response;
 }
 
 enum class ResourceType : uint8_t {
-    Unknown,
-    Tile,
-    Glyphs,
-    Image,
-    JSON
+    Unknown = 0,
+    Tile = 1,
+    Glyphs = 2,
+    Image = 3,
+    JSON = 4
 };
 
 class FileSource : private util::noncopyable, public std::enable_shared_from_this<FileSource> {
@@ -38,8 +38,8 @@ public:
 private:
     void closeDatabase();
     void createSchema();
-    bool loadFile(const std::string &url, std::function<void(platform::Response *)> callback);
-    void saveFile(const std::string &url, platform::Response *res);
+    bool loadFile(ResourceType type, const std::string &url, std::function<void(platform::Response *)> callback);
+    void saveFile(ResourceType type, const std::string &url, platform::Response *res);
 
 private:
     // Stores a URL that is used as a base for loading resources with relative path.
-- 
cgit v1.2.1


From b94635f70430c3659cd57596e49649d376284473 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Mon, 25 Aug 2014 16:56:56 +0200
Subject: parse cache-control and last-modified headers

---
 include/mbgl/platform/platform.hpp | 11 ++---------
 include/mbgl/platform/response.hpp | 29 +++++++++++++++++++++++++++++
 2 files changed, 31 insertions(+), 9 deletions(-)
 create mode 100644 include/mbgl/platform/response.hpp

(limited to 'include')

diff --git a/include/mbgl/platform/platform.hpp b/include/mbgl/platform/platform.hpp
index 22405a4cfd..e08cac5312 100644
--- a/include/mbgl/platform/platform.hpp
+++ b/include/mbgl/platform/platform.hpp
@@ -1,10 +1,11 @@
 #ifndef MBGL_PLATFORM_PLATFORM
 #define MBGL_PLATFORM_PLATFORM
 
+#include <mbgl/platform/response.hpp>
+
 #include <mbgl/util/uv.hpp>
 
 #include <memory>
-#include <functional>
 #include <string>
 
 namespace mbgl {
@@ -12,14 +13,6 @@ namespace platform {
 
 class Request;
 
-struct Response {
-    Response(std::function<void(Response *)> callback) : callback(callback) {}
-    int16_t code = -1;
-    std::string body;
-    std::string error_message;
-    std::function<void(Response *)> callback;
-};
-
 // Makes an HTTP request of a URL, preferrably on a background thread, and calls a function with the
 // results in the original thread (which runs the libuv loop).
 // If the loop pointer is NULL, the callback function will be called on an arbitrary thread.
diff --git a/include/mbgl/platform/response.hpp b/include/mbgl/platform/response.hpp
new file mode 100644
index 0000000000..345a2ee3df
--- /dev/null
+++ b/include/mbgl/platform/response.hpp
@@ -0,0 +1,29 @@
+#ifndef MBGL_PLATFORM_RESPONSE
+#define MBGL_PLATFORM_RESPONSE
+
+#include <string>
+#include <functional>
+#include <ctime>
+
+#include <mbgl/util/noncopyable.hpp>
+
+namespace mbgl {
+namespace platform {
+
+struct Response : private util::noncopyable {
+    Response(std::function<void(Response *)> callback) : callback(callback) {}
+    int16_t code = -1;
+    std::string body;
+    std::string error_message;
+    std::time_t modified;
+    std::time_t expires;
+    std::function<void(Response *)> callback;
+
+    void setCacheControl(const char *value);
+    void setLastModified(const char *value);
+};
+
+}
+}
+
+#endif
-- 
cgit v1.2.1


From d9fc7708a2dfb6e2506a5d10d896a813557c056d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Mon, 15 Sep 2014 17:26:44 +0200
Subject: do 304 requests and cache them in sqlite

---
 include/mbgl/map/map.hpp                    |  8 ++-
 include/mbgl/map/tile_data.hpp              |  5 +-
 include/mbgl/platform/platform.hpp          | 13 ----
 include/mbgl/platform/request.hpp           | 41 -------------
 include/mbgl/platform/response.hpp          | 29 ---------
 include/mbgl/storage/base_request.hpp       | 46 +++++++++++++++
 include/mbgl/storage/file_request.hpp       | 32 ++++++++++
 include/mbgl/storage/file_source.hpp        | 54 +++++++++++++++++
 include/mbgl/storage/http_request.hpp       | 38 ++++++++++++
 include/mbgl/storage/http_request_baton.hpp | 28 +++++++++
 include/mbgl/storage/request.hpp            | 39 ++++++++++++
 include/mbgl/storage/resource_type.hpp      | 18 ++++++
 include/mbgl/storage/response.hpp           | 23 ++++++++
 include/mbgl/storage/sqlite_store.hpp       | 47 +++++++++++++++
 include/mbgl/text/glyph_store.hpp           |  7 +++
 include/mbgl/util/filesource.hpp            | 56 ------------------
 include/mbgl/util/interpolate.hpp           |  2 +
 include/mbgl/util/parsedate.h               | 38 ++++++++++++
 include/mbgl/util/queue.h                   | 92 +++++++++++++++++++++++++++++
 include/mbgl/util/sqlite3.hpp               | 74 +++++++++++++++++++++++
 include/mbgl/util/uv-channel.h              | 29 +++++++++
 include/mbgl/util/uv-messenger.h            | 31 ++++++++++
 include/mbgl/util/uv-worker.h               | 36 +++++++++++
 23 files changed, 642 insertions(+), 144 deletions(-)
 delete mode 100644 include/mbgl/platform/request.hpp
 delete mode 100644 include/mbgl/platform/response.hpp
 create mode 100644 include/mbgl/storage/base_request.hpp
 create mode 100644 include/mbgl/storage/file_request.hpp
 create mode 100644 include/mbgl/storage/file_source.hpp
 create mode 100644 include/mbgl/storage/http_request.hpp
 create mode 100644 include/mbgl/storage/http_request_baton.hpp
 create mode 100644 include/mbgl/storage/request.hpp
 create mode 100644 include/mbgl/storage/resource_type.hpp
 create mode 100644 include/mbgl/storage/response.hpp
 create mode 100644 include/mbgl/storage/sqlite_store.hpp
 delete mode 100644 include/mbgl/util/filesource.hpp
 create mode 100644 include/mbgl/util/parsedate.h
 create mode 100644 include/mbgl/util/queue.h
 create mode 100644 include/mbgl/util/sqlite3.hpp
 create mode 100644 include/mbgl/util/uv-channel.h
 create mode 100644 include/mbgl/util/uv-messenger.h
 create mode 100644 include/mbgl/util/uv-worker.h

(limited to 'include')

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index fba38879ed..98951a375c 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -35,11 +35,14 @@ public:
     explicit Map(View &view);
     ~Map();
 
-    // Start/stop the map render thread
+    // Start/stop the map render thread. the start() call is asynchronous, while the stop() call
+    // will block until the map rendering thread stopped.
     void start();
     void stop();
 
-    // Runs the map event loop.
+    // Runs the map event loop. ONLY run this function when you want to get render a single frame
+    // with this map object. It will *not* spawn a separate thread and instead block until the
+    // frame is completely rendered.
     void run();
 
     // Triggers a lazy rerender: only performs a render when the map is not clean.
@@ -192,6 +195,7 @@ private:
 
     Painter painter;
 
+    std::string styleURL;
     std::string styleJSON = "";
     std::string accessToken = "";
 
diff --git a/include/mbgl/map/tile_data.hpp b/include/mbgl/map/tile_data.hpp
index 9aaef84e04..900224be2d 100644
--- a/include/mbgl/map/tile_data.hpp
+++ b/include/mbgl/map/tile_data.hpp
@@ -19,8 +19,7 @@ class Map;
 class Painter;
 class SourceInfo;
 class StyleLayer;
-
-namespace platform { class Request; }
+class Request;
 
 class TileData : public std::enable_shared_from_this<TileData>,
              private util::noncopyable {
@@ -72,7 +71,7 @@ public:
     const SourceInfo &source;
 
 protected:
-    std::weak_ptr<platform::Request> req;
+    std::unique_ptr<Request> req;
     std::string data;
 
     // Contains the tile ID string for painting debug information.
diff --git a/include/mbgl/platform/platform.hpp b/include/mbgl/platform/platform.hpp
index e08cac5312..6356d81bb1 100644
--- a/include/mbgl/platform/platform.hpp
+++ b/include/mbgl/platform/platform.hpp
@@ -1,8 +1,6 @@
 #ifndef MBGL_PLATFORM_PLATFORM
 #define MBGL_PLATFORM_PLATFORM
 
-#include <mbgl/platform/response.hpp>
-
 #include <mbgl/util/uv.hpp>
 
 #include <memory>
@@ -13,23 +11,12 @@ namespace platform {
 
 class Request;
 
-// Makes an HTTP request of a URL, preferrably on a background thread, and calls a function with the
-// results in the original thread (which runs the libuv loop).
-// If the loop pointer is NULL, the callback function will be called on an arbitrary thread.
-// Returns a cancellable request.
-std::shared_ptr<Request> request_http(const std::string &url,
-                                      std::function<void(Response *)> callback,
-                                      std::shared_ptr<uv::loop> loop = nullptr);
-
 // Uppercase a string, potentially using platform-specific routines.
 std::string uppercase(const std::string &string);
 
 // Lowercase a string, potentially using platform-specific routines.
 std::string lowercase(const std::string &string);
 
-// Cancels an HTTP request.
-void cancel_request_http(const std::shared_ptr<Request> &req);
-
 // Shows an alpha image with the specified dimensions in a named window.
 void show_debug_image(std::string name, const char *data, size_t width, size_t height);
 
diff --git a/include/mbgl/platform/request.hpp b/include/mbgl/platform/request.hpp
deleted file mode 100644
index 0cbacf645d..0000000000
--- a/include/mbgl/platform/request.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef MBGL_PLATFORM_REQUEST
-#define MBGL_PLATFORM_REQUEST
-
-#include <string>
-#include <functional>
-#include <memory>
-#include <atomic>
-
-#include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/uv.hpp>
-
-namespace mbgl {
-namespace platform {
-
-struct Response;
-
-class Request : public std::enable_shared_from_this<Request>, private util::noncopyable {
-public:
-    Request(const std::string &url,
-            std::function<void(Response *)> callback,
-            std::shared_ptr<uv::loop> loop);
-    ~Request();
-
-    void complete();
-
-private:
-    static void complete(uv_async_t *async);
-
-public:
-    const std::string url;
-    std::unique_ptr<Response> res;
-    std::atomic<bool> cancelled;
-
-public:
-    uv_async_t *async = nullptr;
-    std::shared_ptr<uv::loop> loop;
-};
-}
-}
-
-#endif
diff --git a/include/mbgl/platform/response.hpp b/include/mbgl/platform/response.hpp
deleted file mode 100644
index 345a2ee3df..0000000000
--- a/include/mbgl/platform/response.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef MBGL_PLATFORM_RESPONSE
-#define MBGL_PLATFORM_RESPONSE
-
-#include <string>
-#include <functional>
-#include <ctime>
-
-#include <mbgl/util/noncopyable.hpp>
-
-namespace mbgl {
-namespace platform {
-
-struct Response : private util::noncopyable {
-    Response(std::function<void(Response *)> callback) : callback(callback) {}
-    int16_t code = -1;
-    std::string body;
-    std::string error_message;
-    std::time_t modified;
-    std::time_t expires;
-    std::function<void(Response *)> callback;
-
-    void setCacheControl(const char *value);
-    void setLastModified(const char *value);
-};
-
-}
-}
-
-#endif
diff --git a/include/mbgl/storage/base_request.hpp b/include/mbgl/storage/base_request.hpp
new file mode 100644
index 0000000000..b8ebd368e4
--- /dev/null
+++ b/include/mbgl/storage/base_request.hpp
@@ -0,0 +1,46 @@
+#ifndef MBGL_STORAGE_BASE_REQUEST
+#define MBGL_STORAGE_BASE_REQUEST
+
+#include <string>
+#include <forward_list>
+#include <memory>
+#include <functional>
+
+typedef struct uv_loop_s uv_loop_t;
+typedef struct uv_async_s uv_async_t;
+
+namespace mbgl {
+
+class Response;
+class Request;
+using Callback = std::function<void(const Response &)>;
+
+
+class BaseRequest {
+private:
+    // Make noncopyable and immovable
+    BaseRequest(const BaseRequest &) = delete;
+    BaseRequest(BaseRequest &&) = delete;
+    BaseRequest& operator=(const BaseRequest &) = delete;
+    BaseRequest& operator=(BaseRequest &&) = delete;
+
+public:
+    BaseRequest();
+    virtual ~BaseRequest();
+
+    Callback *add(Callback &&callback, const std::shared_ptr<BaseRequest> &request);
+    void remove(Callback *callback);
+    void notify();
+
+public:
+    const unsigned long thread_id;
+    std::unique_ptr<Response> response;
+
+private:
+    std::shared_ptr<BaseRequest> self;
+    std::forward_list<std::unique_ptr<Callback>> callbacks;
+};
+
+}
+
+#endif
diff --git a/include/mbgl/storage/file_request.hpp b/include/mbgl/storage/file_request.hpp
new file mode 100644
index 0000000000..156fd6dfe7
--- /dev/null
+++ b/include/mbgl/storage/file_request.hpp
@@ -0,0 +1,32 @@
+#ifndef MBGL_STORAGE_FILE_REQUEST
+#define MBGL_STORAGE_FILE_REQUEST
+
+
+#include <string>
+#include <memory>
+#include <cassert>
+
+#include <mbgl/storage/base_request.hpp>
+
+namespace mbgl {
+
+typedef struct uv_loop_s uv_loop_t;
+
+struct FileRequestBaton;
+
+class FileRequest : public BaseRequest {
+public:
+    FileRequest(const std::string &path, uv_loop_t *loop);
+    ~FileRequest();
+
+private:
+    const std::string path;
+    const unsigned long thread_id;
+    FileRequestBaton *ptr = nullptr;
+
+    friend struct FileRequestBaton;
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/include/mbgl/storage/file_source.hpp b/include/mbgl/storage/file_source.hpp
new file mode 100644
index 0000000000..4cc95ae24e
--- /dev/null
+++ b/include/mbgl/storage/file_source.hpp
@@ -0,0 +1,54 @@
+#ifndef MBGL_STORAGE_FILE_SOURCE
+#define MBGL_STORAGE_FILE_SOURCE
+
+#include <mbgl/storage/resource_type.hpp>
+#include <mbgl/storage/request.hpp>
+
+#include <string>
+#include <memory>
+#include <unordered_map>
+#include <functional>
+
+typedef struct uv_loop_s uv_loop_t;
+typedef struct uv_messenger_s uv_messenger_t;
+
+namespace mbgl {
+
+class BaseRequest;
+class SQLiteStore;
+
+class FileSource {
+private:
+    FileSource(const FileSource &) = delete;
+    FileSource(FileSource &&) = delete;
+    FileSource& operator=(const FileSource &) = delete;
+    FileSource& operator=(FileSource &&) = delete;
+
+public:
+    FileSource(uv_loop_t *loop);
+    ~FileSource();
+
+public:
+    // Stores and retrieves the base path/URL for relative requests
+    void setBase(const std::string &value);
+    const std::string &getBase() const;
+
+    std::unique_ptr<Request> request(ResourceType type, const std::string &url);
+
+    void prepare(std::function<void()> fn);
+
+private:
+    const unsigned long thread_id;
+
+    // Stores a URL that is used as a base for loading resources with relative path.
+    std::string base;
+
+    std::unordered_map<std::string, std::weak_ptr<BaseRequest>> pending;
+    std::shared_ptr<SQLiteStore> store;
+    uv_loop_t *loop = nullptr;
+    uv_messenger_t *queue = nullptr;
+};
+
+}
+
+#endif
diff --git a/include/mbgl/storage/http_request.hpp b/include/mbgl/storage/http_request.hpp
new file mode 100644
index 0000000000..30f7b3aa6d
--- /dev/null
+++ b/include/mbgl/storage/http_request.hpp
@@ -0,0 +1,38 @@
+#ifndef MBGL_STORAGE_HTTP_REQUEST
+#define MBGL_STORAGE_HTTP_REQUEST
+
+#include <mbgl/storage/resource_type.hpp>
+#include <mbgl/storage/base_request.hpp>
+
+#include <string>
+#include <memory>
+#include <cassert>
+
+typedef struct uv_loop_s uv_loop_t;
+
+namespace mbgl {
+
+struct CacheRequestBaton;
+struct HTTPRequestBaton;
+struct CacheEntry;
+class SQLiteStore;
+
+class HTTPRequest : public BaseRequest {
+public:
+    HTTPRequest(ResourceType type, const std::string &path, uv_loop_t *loop, std::shared_ptr<SQLiteStore> store);
+    ~HTTPRequest();
+
+private:
+    void loadedCacheEntry(std::unique_ptr<Response> &&response);
+
+private:
+    const unsigned long thread_id;
+    CacheRequestBaton *cache_baton = nullptr;
+    HTTPRequestBaton *http_baton = nullptr;
+    std::shared_ptr<SQLiteStore> store;
+    const ResourceType type;
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/include/mbgl/storage/http_request_baton.hpp b/include/mbgl/storage/http_request_baton.hpp
new file mode 100644
index 0000000000..5f06a68cd1
--- /dev/null
+++ b/include/mbgl/storage/http_request_baton.hpp
@@ -0,0 +1,28 @@
+#ifndef MBGL_STORAGE_HTTP_REQUEST_BATON
+#define MBGL_STORAGE_HTTP_REQUEST_BATON
+
+#include <mbgl/storage/response.hpp>
+
+#include <string>
+
+typedef struct uv_async_s uv_async_t;
+
+namespace mbgl {
+
+class HTTPRequest;
+
+struct HTTPRequestBaton {
+    HTTPRequest *request = nullptr;
+    std::string path;
+    uv_async_t *async = nullptr;
+    std::unique_ptr<Response> response;
+    void *ptr = nullptr;
+    bool not_modified = false;
+
+    void start();
+    void cancel();
+};
+
+}
+
+#endif
diff --git a/include/mbgl/storage/request.hpp b/include/mbgl/storage/request.hpp
new file mode 100644
index 0000000000..fa27fbc781
--- /dev/null
+++ b/include/mbgl/storage/request.hpp
@@ -0,0 +1,39 @@
+#ifndef MBGL_STORAGE_REQUEST
+#define MBGL_STORAGE_REQUEST
+
+#include <mbgl/storage/response.hpp>
+
+#include <memory>
+#include <functional>
+#include <forward_list>
+
+typedef struct uv_loop_s uv_loop_t;
+
+namespace mbgl {
+
+class BaseRequest;
+using Callback = std::function<void(const Response &)>;
+
+class Request {
+private:
+    Request(const Request &) = delete;
+    Request(Request &&) = delete;
+    Request& operator=(const Request &) = delete;
+    Request& operator=(Request &&) = delete;
+
+public:
+    Request(const std::shared_ptr<BaseRequest> &base);
+    ~Request();
+
+    void onload(Callback cb);
+    void cancel();
+
+private:
+    const unsigned long thread_id;
+    std::shared_ptr<BaseRequest> base;
+    std::forward_list<Callback *> callbacks;
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/include/mbgl/storage/resource_type.hpp b/include/mbgl/storage/resource_type.hpp
new file mode 100644
index 0000000000..b7204a9fa1
--- /dev/null
+++ b/include/mbgl/storage/resource_type.hpp
@@ -0,0 +1,18 @@
+#ifndef MBGL_STORAGE_RESOURCE_TYPE
+#define MBGL_STORAGE_RESOURCE_TYPE
+
+#include <cstdint>
+
+namespace mbgl {
+
+enum class ResourceType : uint8_t {
+    Unknown = 0,
+    Tile = 1,
+    Glyphs = 2,
+    Image = 3,
+    JSON = 4
+};
+
+}
+
+#endif
diff --git a/include/mbgl/storage/response.hpp b/include/mbgl/storage/response.hpp
new file mode 100644
index 0000000000..4960173f9e
--- /dev/null
+++ b/include/mbgl/storage/response.hpp
@@ -0,0 +1,23 @@
+#ifndef MBGL_STORAGE_RESPONSE
+#define MBGL_STORAGE_RESPONSE
+
+#include <string>
+#include <ctime>
+
+namespace mbgl {
+
+class Response {
+public:
+    long code = 0;
+    int64_t modified = 0;
+    int64_t expires = 0;
+    std::string data;
+
+    std::string message;
+
+    static int64_t parseCacheControl(const char *value);
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/include/mbgl/storage/sqlite_store.hpp b/include/mbgl/storage/sqlite_store.hpp
new file mode 100644
index 0000000000..e03e6cf2bc
--- /dev/null
+++ b/include/mbgl/storage/sqlite_store.hpp
@@ -0,0 +1,47 @@
+#ifndef MBGL_STORAGE_SQLITE_STORE
+#define MBGL_STORAGE_SQLITE_STORE
+
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/storage/response.hpp>
+
+#include <uv.h>
+
+#include <string>
+
+typedef struct uv_worker_s uv_worker_t;
+
+namespace mapbox {
+namespace sqlite {
+class Database;
+}
+}
+
+namespace mbgl {
+
+class SQLiteStore {
+public:
+    SQLiteStore(uv_loop_t *loop, const std::string &path);
+    ~SQLiteStore();
+
+    typedef void (*GetCallback)(std::unique_ptr<Response> &&entry, void *ptr);
+
+    void get(const std::string &path, GetCallback cb, void *ptr);
+    void put(const std::string &path, ResourceType type, const Response &entry);
+    void updateExpiration(const std::string &path, int64_t expires);
+
+private:
+    void createSchema();
+    void closeDatabase();
+    static void runGet(uv_work_t *req);
+    static void runPut(uv_work_t *req);
+    static void deliverResult(uv_work_t *req, int status);
+
+private:
+    const unsigned long thread_id;
+    std::shared_ptr<mapbox::sqlite::Database> db;
+    uv_worker_t *worker = nullptr;
+};
+
+}
+
+#endif
diff --git a/include/mbgl/text/glyph_store.hpp b/include/mbgl/text/glyph_store.hpp
index e0c0391c73..9730967053 100644
--- a/include/mbgl/text/glyph_store.hpp
+++ b/include/mbgl/text/glyph_store.hpp
@@ -49,6 +49,13 @@ class GlyphPBF {
 public:
     GlyphPBF(const std::string &glyphURL, const std::string &fontStack, GlyphRange glyphRange, const std::shared_ptr<FileSource> &fileSource);
 
+private:
+    GlyphPBF(const GlyphPBF &) = delete;
+    GlyphPBF(GlyphPBF &&) = delete;
+    GlyphPBF &operator=(const GlyphPBF &) = delete;
+    GlyphPBF &operator=(GlyphPBF &&) = delete;
+
+public:
     void parse(FontStack &stack);
 
     std::shared_future<GlyphPBF &> getFuture();
diff --git a/include/mbgl/util/filesource.hpp b/include/mbgl/util/filesource.hpp
deleted file mode 100644
index ccff4b5122..0000000000
--- a/include/mbgl/util/filesource.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef MBGL_UTIL_FILESOURCE
-#define MBGL_UTIL_FILESOURCE
-
-#include <mbgl/util/uv.hpp>
-#include <mbgl/util/noncopyable.hpp>
-
-#include <string>
-#include <memory>
-#include <functional>
-
-typedef struct sqlite3 sqlite3;
-typedef struct sqlite3_stmt sqlite3_stmt;
-
-namespace mbgl {
-
-namespace platform {
-struct Response;
-}
-
-enum class ResourceType : uint8_t {
-    Unknown = 0,
-    Tile = 1,
-    Glyphs = 2,
-    Image = 3,
-    JSON = 4
-};
-
-class FileSource : private util::noncopyable, public std::enable_shared_from_this<FileSource> {
-public:
-    FileSource();
-    ~FileSource();
-
-    void setBase(const std::string &value);
-    const std::string &getBase() const;
-
-    void load(ResourceType type, const std::string &url, std::function<void(platform::Response *)> callback, const std::shared_ptr<uv::loop> loop = nullptr);
-
-private:
-    void closeDatabase();
-    void createSchema();
-    bool loadFile(ResourceType type, const std::string &url, std::function<void(platform::Response *)> callback);
-    void saveFile(ResourceType type, const std::string &url, platform::Response *res);
-
-private:
-    // Stores a URL that is used as a base for loading resources with relative path.
-    std::string base;
-
-    // Stores the absolute path to the cache directory.
-    const std::string cache;
-
-    sqlite3 *db = nullptr;
-};
-
-}
-
-#endif
diff --git a/include/mbgl/util/interpolate.hpp b/include/mbgl/util/interpolate.hpp
index e8c3389350..c9232db4eb 100644
--- a/include/mbgl/util/interpolate.hpp
+++ b/include/mbgl/util/interpolate.hpp
@@ -1,6 +1,8 @@
 #ifndef MBGL_UTIL_INTERPOLATE
 #define MBGL_UTIL_INTERPOLATE
 
+#include <array>
+
 namespace mbgl {
 namespace util {
 
diff --git a/include/mbgl/util/parsedate.h b/include/mbgl/util/parsedate.h
new file mode 100644
index 0000000000..6905e361d4
--- /dev/null
+++ b/include/mbgl/util/parsedate.h
@@ -0,0 +1,38 @@
+#ifndef HEADER_PARSEDATE_H
+#define HEADER_PARSEDATE_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <time.h>
+
+time_t parse_date(const char *p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HEADER_PARSEDATE_H */
diff --git a/include/mbgl/util/queue.h b/include/mbgl/util/queue.h
new file mode 100644
index 0000000000..fe02b454ea
--- /dev/null
+++ b/include/mbgl/util/queue.h
@@ -0,0 +1,92 @@
+/* Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef QUEUE_H_
+#define QUEUE_H_
+
+typedef void *QUEUE[2];
+
+/* Private macros. */
+#define QUEUE_NEXT(q)       (*(QUEUE **) &((*(q))[0]))
+#define QUEUE_PREV(q)       (*(QUEUE **) &((*(q))[1]))
+#define QUEUE_PREV_NEXT(q)  (QUEUE_NEXT(QUEUE_PREV(q)))
+#define QUEUE_NEXT_PREV(q)  (QUEUE_PREV(QUEUE_NEXT(q)))
+
+/* Public macros. */
+#define QUEUE_DATA(ptr, type, field)                                          \
+  ((type *) ((char *) (ptr) - ((char *) &((type *) 0)->field)))
+
+#define QUEUE_FOREACH(q, h)                                                   \
+  for ((q) = QUEUE_NEXT(h); (q) != (h); (q) = QUEUE_NEXT(q))
+
+#define QUEUE_EMPTY(q)                                                        \
+  ((const QUEUE *) (q) == (const QUEUE *) QUEUE_NEXT(q))
+
+#define QUEUE_HEAD(q)                                                         \
+  (QUEUE_NEXT(q))
+
+#define QUEUE_INIT(q)                                                         \
+  do {                                                                        \
+    QUEUE_NEXT(q) = (q);                                                      \
+    QUEUE_PREV(q) = (q);                                                      \
+  }                                                                           \
+  while (0)
+
+#define QUEUE_ADD(h, n)                                                       \
+  do {                                                                        \
+    QUEUE_PREV_NEXT(h) = QUEUE_NEXT(n);                                       \
+    QUEUE_NEXT_PREV(n) = QUEUE_PREV(h);                                       \
+    QUEUE_PREV(h) = QUEUE_PREV(n);                                            \
+    QUEUE_PREV_NEXT(h) = (h);                                                 \
+  }                                                                           \
+  while (0)
+
+#define QUEUE_SPLIT(h, q, n)                                                  \
+  do {                                                                        \
+    QUEUE_PREV(n) = QUEUE_PREV(h);                                            \
+    QUEUE_PREV_NEXT(n) = (n);                                                 \
+    QUEUE_NEXT(n) = (q);                                                      \
+    QUEUE_PREV(h) = QUEUE_PREV(q);                                            \
+    QUEUE_PREV_NEXT(h) = (h);                                                 \
+    QUEUE_PREV(q) = (n);                                                      \
+  }                                                                           \
+  while (0)
+
+#define QUEUE_INSERT_HEAD(h, q)                                               \
+  do {                                                                        \
+    QUEUE_NEXT(q) = QUEUE_NEXT(h);                                            \
+    QUEUE_PREV(q) = (h);                                                      \
+    QUEUE_NEXT_PREV(q) = (q);                                                 \
+    QUEUE_NEXT(h) = (q);                                                      \
+  }                                                                           \
+  while (0)
+
+#define QUEUE_INSERT_TAIL(h, q)                                               \
+  do {                                                                        \
+    QUEUE_NEXT(q) = (h);                                                      \
+    QUEUE_PREV(q) = QUEUE_PREV(h);                                            \
+    QUEUE_PREV_NEXT(q) = (q);                                                 \
+    QUEUE_PREV(h) = (q);                                                      \
+  }                                                                           \
+  while (0)
+
+#define QUEUE_REMOVE(q)                                                       \
+  do {                                                                        \
+    QUEUE_PREV_NEXT(q) = QUEUE_NEXT(q);                                       \
+    QUEUE_NEXT_PREV(q) = QUEUE_PREV(q);                                       \
+  }                                                                           \
+  while (0)
+
+#endif /* QUEUE_H_ */
diff --git a/include/mbgl/util/sqlite3.hpp b/include/mbgl/util/sqlite3.hpp
new file mode 100644
index 0000000000..3e324f7ce1
--- /dev/null
+++ b/include/mbgl/util/sqlite3.hpp
@@ -0,0 +1,74 @@
+#pragma once
+
+#include <string>
+#include <stdexcept>
+
+typedef struct sqlite3 sqlite3;
+typedef struct sqlite3_stmt sqlite3_stmt;
+
+namespace mapbox {
+namespace sqlite {
+
+enum OpenFlag : int {
+    ReadOnly = 0x00000001,
+    ReadWrite = 0x00000002,
+    Create = 0x00000004,
+    NoMutex = 0x00008000,
+    FullMutex = 0x00010000,
+    SharedCache = 0x00020000,
+    PrivateCache = 0x00040000,
+};
+
+struct Exception : std::runtime_error {
+    inline Exception(int err, const char *msg) : std::runtime_error(msg), code(err) {}
+    const int code = 0;
+};
+
+class Statement;
+
+class Database {
+private:
+    Database(const Database &) = delete;
+    Database &operator=(const Database &) = delete;
+
+public:
+    Database(const std::string &filename, int flags = 0);
+    Database(Database &&);
+    ~Database();
+    Database &operator=(Database &&);
+
+    operator bool() const;
+
+    void exec(const std::string &sql);
+    Statement prepare(const char *query);
+
+private:
+    sqlite3 *db = nullptr;
+};
+
+class Statement {
+private:
+    Statement(const Statement &) = delete;
+    Statement &operator=(const Statement &) = delete;
+
+public:
+    Statement(sqlite3 *db, const char *sql);
+    Statement(Statement &&);
+    ~Statement();
+    Statement &operator=(Statement &&);
+
+    operator bool() const;
+
+    template <typename T> void bind(int offset, T value);
+    void bind(int offset, const std::string &value, bool retain = true);
+    template <typename T> T get(int offset);
+
+    bool run();
+    void reset();
+
+private:
+    sqlite3_stmt *stmt = nullptr;
+};
+
+}
+}
diff --git a/include/mbgl/util/uv-channel.h b/include/mbgl/util/uv-channel.h
new file mode 100644
index 0000000000..ea5c279f65
--- /dev/null
+++ b/include/mbgl/util/uv-channel.h
@@ -0,0 +1,29 @@
+#ifndef MBGL_UTIL_UV_CHANNEL
+#define MBGL_UTIL_UV_CHANNEL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <uv.h>
+
+// Taken from http://navaneeth.github.io/blog/2013/08/02/channels-in-libuv/
+
+typedef struct uv_chan_s uv_chan_t;
+
+struct uv_chan_s {
+    uv_mutex_t mutex;
+    uv_cond_t cond;
+    void *q[2];
+};
+
+int uv_chan_init(uv_chan_t *chan);
+void uv_chan_send(uv_chan_t *chan, void *data);
+void *uv_chan_receive(uv_chan_t *chan);
+void uv_chan_destroy(uv_chan_t *chan);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/mbgl/util/uv-messenger.h b/include/mbgl/util/uv-messenger.h
new file mode 100644
index 0000000000..b082466b60
--- /dev/null
+++ b/include/mbgl/util/uv-messenger.h
@@ -0,0 +1,31 @@
+#ifndef MBGL_UTIL_UV_MESSENGER
+#define MBGL_UTIL_UV_MESSENGER
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <uv.h>
+
+typedef struct uv_messenger_s uv_messenger_t;
+typedef void (*uv_messenger_cb)(void *arg);
+typedef void (*uv_messenger_stop_cb)(uv_messenger_t *msgr);
+
+struct uv_messenger_s {
+    uv_mutex_t mutex;
+    uv_async_t async;
+    uv_messenger_cb callback;
+    void *data;
+    void *queue[2];
+};
+
+int uv_messenger_init(uv_loop_t *loop, uv_messenger_t *msgr, uv_messenger_cb callback);
+void uv_messenger_send(uv_messenger_t *msgr, void *arg);
+void uv_messenger_stop(uv_messenger_t *msgr);
+void uv_messenger_unref(uv_messenger_t *msgr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/mbgl/util/uv-worker.h b/include/mbgl/util/uv-worker.h
new file mode 100644
index 0000000000..b9eb10fb70
--- /dev/null
+++ b/include/mbgl/util/uv-worker.h
@@ -0,0 +1,36 @@
+#ifndef MBGL_UTIL_UV_WORKER
+#define MBGL_UTIL_UV_WORKER
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct uv_messenger_s uv_messenger_t;
+
+#include <mbgl/util/uv-channel.h>
+
+#include <stdlib.h>
+
+typedef struct uv_worker_s uv_worker_t;
+
+struct uv_worker_s {
+    uv_thread_t thread;
+    uv_messenger_t *msgr;
+    uv_chan_t chan;
+    const char *name;
+};
+
+typedef void (*uv_worker_cb)(void *data);
+typedef void (*uv_worker_after_cb)(void *data);
+
+int uv_worker_init(uv_worker_t *worker, uv_loop_t *loop);
+int uv_worker_init_named(uv_worker_t *worker, uv_loop_t *loop, const char *name);
+void uv_worker_send(uv_worker_t *worker, void *data, uv_worker_cb work_cb,
+                    uv_worker_after_cb after_work_cb);
+void uv_worker_close(uv_worker_t *worker);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
-- 
cgit v1.2.1


From 6c526e56370a0f4dee9a4b6ed45489fcb14e3ff1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Tue, 16 Sep 2014 14:48:46 +0200
Subject: make sure all of our async handles are stopped before stopping the
 map thread

---
 include/mbgl/map/map.hpp              | 11 ++++++++---
 include/mbgl/storage/base_request.hpp |  6 +++++-
 include/mbgl/storage/file_request.hpp |  2 --
 include/mbgl/util/uv_detail.hpp       | 13 +------------
 4 files changed, 14 insertions(+), 18 deletions(-)

(limited to 'include')

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 98951a375c..3b2c97122e 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -160,9 +160,9 @@ private:
     bool async = false;
     std::shared_ptr<uv::loop> loop;
     std::unique_ptr<uv::thread> thread;
-    uv_async_t *async_terminate = nullptr;
-    uv_async_t *async_render = nullptr;
-    uv_async_t *async_cleanup = nullptr;
+    std::unique_ptr<uv_async_t> async_terminate;
+    std::unique_ptr<uv_async_t> async_render;
+    std::unique_ptr<uv_async_t> async_cleanup;
 
 private:
     // If cleared, the next time the render thread attempts to render the map, it will *actually*
@@ -181,6 +181,11 @@ public:
     View &view;
 
 private:
+#ifndef NDEBUG
+    const unsigned long main_thread;
+    unsigned long map_thread = -1;
+#endif
+
     Transform transform;
     TransformState state;
 
diff --git a/include/mbgl/storage/base_request.hpp b/include/mbgl/storage/base_request.hpp
index b8ebd368e4..05ef1e4a7b 100644
--- a/include/mbgl/storage/base_request.hpp
+++ b/include/mbgl/storage/base_request.hpp
@@ -25,7 +25,7 @@ private:
     BaseRequest& operator=(BaseRequest &&) = delete;
 
 public:
-    BaseRequest();
+    BaseRequest(const std::string &path);
     virtual ~BaseRequest();
 
     Callback *add(Callback &&callback, const std::shared_ptr<BaseRequest> &request);
@@ -34,10 +34,14 @@ public:
 
 public:
     const unsigned long thread_id;
+    const std::string path;
     std::unique_ptr<Response> response;
 
 private:
+    // This object may hold a shared_ptr to itself. It does this to prevent destruction of this object
+    // while a request is in progress.
     std::shared_ptr<BaseRequest> self;
+
     std::forward_list<std::unique_ptr<Callback>> callbacks;
 };
 
diff --git a/include/mbgl/storage/file_request.hpp b/include/mbgl/storage/file_request.hpp
index 156fd6dfe7..331ed8421f 100644
--- a/include/mbgl/storage/file_request.hpp
+++ b/include/mbgl/storage/file_request.hpp
@@ -20,8 +20,6 @@ public:
     ~FileRequest();
 
 private:
-    const std::string path;
-    const unsigned long thread_id;
     FileRequestBaton *ptr = nullptr;
 
     friend struct FileRequestBaton;
diff --git a/include/mbgl/util/uv_detail.hpp b/include/mbgl/util/uv_detail.hpp
index c65c247ba1..eefb5ac8df 100644
--- a/include/mbgl/util/uv_detail.hpp
+++ b/include/mbgl/util/uv_detail.hpp
@@ -2,20 +2,9 @@
 #define MBGL_UTIL_UV_DETAIL
 
 #include <uv.h>
+
 #include <functional>
 #include <cassert>
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunused-parameter"
-#endif
-
-#include <boost/lockfree/queue.hpp>
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
 #include <string>
 
 
-- 
cgit v1.2.1


From f26bb724dc164b69b5358f30c6248fdf5cbd076b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Tue, 16 Sep 2014 16:38:32 +0200
Subject: use util::ptr as a wrapper around std::shared_ptr that asserts
 nonemptiness

---
 include/mbgl/map/map.hpp                 | 44 ++++++++++++++++----------------
 include/mbgl/map/raster_tile_data.hpp    |  6 ++---
 include/mbgl/map/source.hpp              |  6 ++---
 include/mbgl/map/sprite.hpp              |  6 ++---
 include/mbgl/map/tile.hpp                |  4 +--
 include/mbgl/map/tile_data.hpp           |  8 +++---
 include/mbgl/map/tile_parser.hpp         | 30 +++++++++++-----------
 include/mbgl/map/transform.hpp           |  8 +++---
 include/mbgl/map/vector_tile_data.hpp    |  4 +--
 include/mbgl/renderer/bucket.hpp         |  6 ++---
 include/mbgl/renderer/debug_bucket.hpp   |  3 +--
 include/mbgl/renderer/fill_bucket.hpp    |  2 +-
 include/mbgl/renderer/line_bucket.hpp    |  5 ++--
 include/mbgl/renderer/painter.hpp        | 17 ++++++------
 include/mbgl/renderer/raster_bucket.hpp  |  4 +--
 include/mbgl/renderer/symbol_bucket.hpp  |  2 +-
 include/mbgl/storage/base_request.hpp    |  8 +++---
 include/mbgl/storage/file_request.hpp    |  5 ----
 include/mbgl/storage/file_source.hpp     |  3 +--
 include/mbgl/storage/http_request.hpp    |  4 +--
 include/mbgl/storage/request.hpp         |  6 ++---
 include/mbgl/storage/sqlite_store.hpp    |  2 +-
 include/mbgl/style/style.hpp             |  4 +--
 include/mbgl/style/style_bucket.hpp      |  6 ++---
 include/mbgl/style/style_layer.hpp       |  7 ++---
 include/mbgl/style/style_layer_group.hpp |  2 +-
 include/mbgl/style/style_parser.hpp      | 18 ++++++-------
 include/mbgl/style/style_source.hpp      |  7 +++--
 include/mbgl/text/glyph_store.hpp        |  7 ++---
 include/mbgl/util/ptr.hpp                | 29 +++++++++++++++++++++
 include/mbgl/util/raster.hpp             |  8 +++---
 include/mbgl/util/uv_detail.hpp          |  6 +++--
 32 files changed, 151 insertions(+), 126 deletions(-)
 create mode 100644 include/mbgl/util/ptr.hpp

(limited to 'include')

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 3b2c97122e..786c7196ae 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -7,11 +7,11 @@
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/time.hpp>
 #include <mbgl/util/uv.hpp>
+#include <mbgl/util/ptr.hpp>
 
 #include <cstdint>
 #include <atomic>
 #include <iosfwd>
-#include <memory>
 #include <set>
 #include <vector>
 
@@ -48,7 +48,7 @@ public:
     // Triggers a lazy rerender: only performs a render when the map is not clean.
     void rerender();
 
-    void renderLayer(std::shared_ptr<StyleLayer> layer_desc, RenderPass pass, const Tile::ID* id = nullptr, const mat4* matrix = nullptr);
+    void renderLayer(util::ptr<StyleLayer> layer_desc, RenderPass pass, const Tile::ID* id = nullptr, const mat4* matrix = nullptr);
 
     // Forces a map update: always triggers a rerender.
     void update();
@@ -65,7 +65,7 @@ public:
     void resize(uint16_t width, uint16_t height, float ratio, uint16_t fb_width, uint16_t fb_height);
 
     // Styling
-    const std::set<std::shared_ptr<StyleSource>> getActiveSources() const;
+    const std::set<util::ptr<StyleSource>> getActiveSources() const;
     void setAppliedClasses(const std::vector<std::string> &classes);
     void toggleClass(const std::string &name);
     const std::vector<std::string> &getAppliedClasses() const;
@@ -118,14 +118,14 @@ public:
 
 public:
     inline const TransformState &getState() const { return state; }
-    inline std::shared_ptr<FileSource> getFileSource() const { return fileSource; }
-    inline std::shared_ptr<Style> getStyle() const { return style; }
-    inline std::shared_ptr<GlyphAtlas> getGlyphAtlas() { return glyphAtlas; }
-    inline std::shared_ptr<GlyphStore> getGlyphStore() { return glyphStore; }
-    inline std::shared_ptr<SpriteAtlas> getSpriteAtlas() { return spriteAtlas; }
-    std::shared_ptr<Sprite> getSprite();
-    inline std::shared_ptr<Texturepool> getTexturepool() { return texturepool; }
-    inline std::shared_ptr<uv::loop> getLoop() { return loop; }
+    inline util::ptr<FileSource> getFileSource() const { return fileSource; }
+    inline util::ptr<Style> getStyle() const { return style; }
+    inline util::ptr<GlyphAtlas> getGlyphAtlas() { return glyphAtlas; }
+    inline util::ptr<GlyphStore> getGlyphStore() { return glyphStore; }
+    inline util::ptr<SpriteAtlas> getSpriteAtlas() { return spriteAtlas; }
+    util::ptr<Sprite> getSprite();
+    inline util::ptr<Texturepool> getTexturepool() { return texturepool; }
+    inline util::ptr<uv::loop> getLoop() { return loop; }
     inline timestamp getAnimationTime() const { return animationTime; }
     inline timestamp getTime() const { return animationTime; }
     void updateTiles();
@@ -141,7 +141,7 @@ private:
     void setup();
 
     void updateSources();
-    void updateSources(const std::shared_ptr<StyleLayerGroup> &group);
+    void updateSources(const util::ptr<StyleLayerGroup> &group);
 
     void updateRenderState();
 
@@ -154,11 +154,11 @@ private:
 
     // Unconditionally performs a render with the current map state.
     void render();
-    void renderLayers(std::shared_ptr<StyleLayerGroup> group);
+    void renderLayers(util::ptr<StyleLayerGroup> group);
 
 private:
     bool async = false;
-    std::shared_ptr<uv::loop> loop;
+    util::ptr<uv::loop> loop;
     std::unique_ptr<uv::thread> thread;
     std::unique_ptr<uv_async_t> async_terminate;
     std::unique_ptr<uv_async_t> async_render;
@@ -189,14 +189,14 @@ private:
     Transform transform;
     TransformState state;
 
-    std::shared_ptr<FileSource> fileSource;
+    util::ptr<FileSource> fileSource;
 
-    std::shared_ptr<Style> style;
-    std::shared_ptr<GlyphAtlas> glyphAtlas;
-    std::shared_ptr<GlyphStore> glyphStore;
-    std::shared_ptr<SpriteAtlas> spriteAtlas;
-    std::shared_ptr<Sprite> sprite;
-    std::shared_ptr<Texturepool> texturepool;
+    util::ptr<Style> style;
+    util::ptr<GlyphAtlas> glyphAtlas;
+    util::ptr<GlyphStore> glyphStore;
+    util::ptr<SpriteAtlas> spriteAtlas;
+    util::ptr<Sprite> sprite;
+    util::ptr<Texturepool> texturepool;
 
     Painter painter;
 
@@ -209,7 +209,7 @@ private:
 
     int indent = 0;
 
-    std::set<std::shared_ptr<StyleSource>> activeSources;
+    std::set<util::ptr<StyleSource>> activeSources;
 
 };
 
diff --git a/include/mbgl/map/raster_tile_data.hpp b/include/mbgl/map/raster_tile_data.hpp
index 98aa3baaf5..329bbf4634 100644
--- a/include/mbgl/map/raster_tile_data.hpp
+++ b/include/mbgl/map/raster_tile_data.hpp
@@ -5,8 +5,6 @@
 #include <mbgl/map/tile_data.hpp>
 #include <mbgl/renderer/raster_bucket.hpp>
 
-#include <memory>
-
 namespace mbgl {
 
 class Map;
@@ -22,8 +20,8 @@ public:
     ~RasterTileData();
 
     virtual void parse();
-    virtual void render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc, const mat4 &matrix);
-    virtual bool hasData(std::shared_ptr<StyleLayer> layer_desc) const;
+    virtual void render(Painter &painter, util::ptr<StyleLayer> layer_desc, const mat4 &matrix);
+    virtual bool hasData(util::ptr<StyleLayer> layer_desc) const;
 
 protected:
     StyleBucketRaster properties;
diff --git a/include/mbgl/map/source.hpp b/include/mbgl/map/source.hpp
index cb069db272..471165f37c 100644
--- a/include/mbgl/map/source.hpp
+++ b/include/mbgl/map/source.hpp
@@ -8,12 +8,12 @@
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/time.hpp>
 #include <mbgl/util/mat4.hpp>
+#include <mbgl/util/ptr.hpp>
 
 #include <cstdint>
 #include <forward_list>
 #include <iosfwd>
 #include <map>
-#include <memory>
 
 namespace mbgl {
 
@@ -33,8 +33,8 @@ public:
     void updateMatrices(const mat4 &projMatrix, const TransformState &transform);
     void drawClippingMasks(Painter &painter);
     size_t getTileCount() const;
-    void render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc);
-    void render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID &id, const mat4 &matrix);
+    void render(Painter &painter, util::ptr<StyleLayer> layer_desc);
+    void render(Painter &painter, util::ptr<StyleLayer> layer_desc, const Tile::ID &id, const mat4 &matrix);
     void finishRender(Painter &painter);
 
     std::forward_list<Tile::ID> getIDs() const;
diff --git a/include/mbgl/map/sprite.hpp b/include/mbgl/map/sprite.hpp
index 6461a5e33d..454ebd8886 100644
--- a/include/mbgl/map/sprite.hpp
+++ b/include/mbgl/map/sprite.hpp
@@ -3,11 +3,11 @@
 
 #include <mbgl/util/image.hpp>
 #include <mbgl/util/noncopyable.hpp>
+#include <mbgl/util/ptr.hpp>
 
 #include <cstdint>
 #include <atomic>
 #include <iosfwd>
-#include <memory>
 #include <string>
 #include <unordered_map>
 #include <future>
@@ -34,11 +34,11 @@ public:
 class Sprite : public std::enable_shared_from_this<Sprite>, private util::noncopyable {
 private:
     struct Key {};
-    void load(const std::shared_ptr<FileSource> &fileSource);
+    void load(const util::ptr<FileSource> &fileSource);
 
 public:
     Sprite(const Key &, const std::string& base_url, float pixelRatio);
-    static std::shared_ptr<Sprite> Create(const std::string& base_url, float pixelRatio, const std::shared_ptr<FileSource> &fileSource);
+    static util::ptr<Sprite> Create(const std::string& base_url, float pixelRatio, const util::ptr<FileSource> &fileSource);
 
     const SpritePosition &getSpritePosition(const std::string& name) const;
 
diff --git a/include/mbgl/map/tile.hpp b/include/mbgl/map/tile.hpp
index 75ced7e384..b9f0556add 100644
--- a/include/mbgl/map/tile.hpp
+++ b/include/mbgl/map/tile.hpp
@@ -3,6 +3,7 @@
 
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/noncopyable.hpp>
+#include <mbgl/util/ptr.hpp>
 
 #include <cstdint>
 #include <bitset>
@@ -10,7 +11,6 @@
 #include <cstdint>
 #include <forward_list>
 #include <iosfwd>
-#include <memory>
 #include <string>
 
 namespace mbgl {
@@ -78,7 +78,7 @@ public:
     const Tile::ID id;
     ClipID clip;
     mat4 matrix;
-    std::shared_ptr<TileData> data;
+    util::ptr<TileData> data;
 };
 
 }
diff --git a/include/mbgl/map/tile_data.hpp b/include/mbgl/map/tile_data.hpp
index 900224be2d..803f0447b3 100644
--- a/include/mbgl/map/tile_data.hpp
+++ b/include/mbgl/map/tile_data.hpp
@@ -6,11 +6,11 @@
 #include <mbgl/geometry/debug_font_buffer.hpp>
 
 #include <mbgl/util/noncopyable.hpp>
+#include <mbgl/util/ptr.hpp>
 
 #include <atomic>
 #include <exception>
 #include <iosfwd>
-#include <memory>
 #include <string>
 
 namespace mbgl {
@@ -28,7 +28,7 @@ public:
     struct geometry_too_long_exception : exception {};
 
 public:
-    typedef std::shared_ptr<TileData> Ptr;
+    typedef util::ptr<TileData> Ptr;
 
     enum class State {
         invalid,
@@ -56,8 +56,8 @@ public:
     virtual void beforeParse();
     virtual void parse() = 0;
     virtual void afterParse();
-    virtual void render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc, const mat4 &matrix) = 0;
-    virtual bool hasData(std::shared_ptr<StyleLayer> layer_desc) const = 0;
+    virtual void render(Painter &painter, util::ptr<StyleLayer> layer_desc, const mat4 &matrix) = 0;
+    virtual bool hasData(util::ptr<StyleLayer> layer_desc) const = 0;
 
 
 public:
diff --git a/include/mbgl/map/tile_parser.hpp b/include/mbgl/map/tile_parser.hpp
index fa64dad6d5..ddb4b98820 100644
--- a/include/mbgl/map/tile_parser.hpp
+++ b/include/mbgl/map/tile_parser.hpp
@@ -4,10 +4,10 @@
 #include <mbgl/map/vector_tile.hpp>
 #include <mbgl/style/filter_expression.hpp>
 #include <mbgl/text/glyph.hpp>
+#include <mbgl/util/ptr.hpp>
 
 #include <cstdint>
 #include <iosfwd>
-#include <memory>
 #include <string>
 
 namespace mbgl {
@@ -32,11 +32,11 @@ class Collision;
 class TileParser {
 public:
     TileParser(const std::string &data, VectorTileData &tile,
-               const std::shared_ptr<const Style> &style,
-               const std::shared_ptr<GlyphAtlas> &glyphAtlas,
-               const std::shared_ptr<GlyphStore> &glyphStore,
-               const std::shared_ptr<SpriteAtlas> &spriteAtlas,
-               const std::shared_ptr<Sprite> &sprite);
+               const util::ptr<const Style> &style,
+               const util::ptr<GlyphAtlas> &glyphAtlas,
+               const util::ptr<GlyphStore> &glyphStore,
+               const util::ptr<SpriteAtlas> &spriteAtlas,
+               const util::ptr<Sprite> &sprite);
     ~TileParser();
 
 public:
@@ -44,11 +44,11 @@ public:
 
 private:
     bool obsolete() const;
-    void parseStyleLayers(std::shared_ptr<StyleLayerGroup> group);
-    std::unique_ptr<Bucket> createBucket(std::shared_ptr<StyleBucket> bucket_desc);
+    void parseStyleLayers(util::ptr<StyleLayerGroup> group);
+    std::unique_ptr<Bucket> createBucket(util::ptr<StyleBucket> bucket_desc);
 
     std::unique_ptr<Bucket> createFillBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketFill &fill);
-    std::unique_ptr<Bucket> createRasterBucket(const std::shared_ptr<Texturepool> &texturepool, const StyleBucketRaster &raster);
+    std::unique_ptr<Bucket> createRasterBucket(const util::ptr<Texturepool> &texturepool, const StyleBucketRaster &raster);
     std::unique_ptr<Bucket> createLineBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketLine &line);
     std::unique_ptr<Bucket> createSymbolBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketSymbol &symbol);
 
@@ -59,12 +59,12 @@ private:
     VectorTileData& tile;
 
     // Cross-thread shared data.
-    std::shared_ptr<const Style> style;
-    std::shared_ptr<GlyphAtlas> glyphAtlas;
-    std::shared_ptr<GlyphStore> glyphStore;
-    std::shared_ptr<SpriteAtlas> spriteAtlas;
-    std::shared_ptr<Sprite> sprite;
-    std::shared_ptr<Texturepool> texturePool;
+    util::ptr<const Style> style;
+    util::ptr<GlyphAtlas> glyphAtlas;
+    util::ptr<GlyphStore> glyphStore;
+    util::ptr<SpriteAtlas> spriteAtlas;
+    util::ptr<Sprite> sprite;
+    util::ptr<Texturepool> texturePool;
 
     std::unique_ptr<Collision> collision;
 };
diff --git a/include/mbgl/map/transform.hpp b/include/mbgl/map/transform.hpp
index d0f56b7fba..5404f333c1 100644
--- a/include/mbgl/map/transform.hpp
+++ b/include/mbgl/map/transform.hpp
@@ -98,10 +98,10 @@ private:
     // cache values for spherical mercator math
     double Bc, Cc;
 
-    std::forward_list<std::shared_ptr<util::transition>> transitions;
-    std::shared_ptr<util::transition> scale_timeout;
-    std::shared_ptr<util::transition> rotate_timeout;
-    std::shared_ptr<util::transition> pan_timeout;
+    std::forward_list<util::ptr<util::transition>> transitions;
+    util::ptr<util::transition> scale_timeout;
+    util::ptr<util::transition> rotate_timeout;
+    util::ptr<util::transition> pan_timeout;
 };
 
 }
diff --git a/include/mbgl/map/vector_tile_data.hpp b/include/mbgl/map/vector_tile_data.hpp
index deb628e485..3f80c0080c 100644
--- a/include/mbgl/map/vector_tile_data.hpp
+++ b/include/mbgl/map/vector_tile_data.hpp
@@ -32,8 +32,8 @@ public:
     virtual void beforeParse();
     virtual void parse();
     virtual void afterParse();
-    virtual void render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc, const mat4 &matrix);
-    virtual bool hasData(std::shared_ptr<StyleLayer> layer_desc) const;
+    virtual void render(Painter &painter, util::ptr<StyleLayer> layer_desc, const mat4 &matrix);
+    virtual bool hasData(util::ptr<StyleLayer> layer_desc) const;
 
 protected:
     // Holds the actual geometries in this tile.
diff --git a/include/mbgl/renderer/bucket.hpp b/include/mbgl/renderer/bucket.hpp
index 1391f6e3e3..696bfb1110 100644
--- a/include/mbgl/renderer/bucket.hpp
+++ b/include/mbgl/renderer/bucket.hpp
@@ -1,11 +1,11 @@
 #ifndef MBGL_RENDERER_BUCKET
 #define MBGL_RENDERER_BUCKET
 
-#include <string>
-#include <memory>
 #include <mbgl/map/tile.hpp>
 #include <mbgl/util/noncopyable.hpp>
 
+#include <string>
+
 namespace mbgl {
 
 class Painter;
@@ -13,7 +13,7 @@ class StyleLayer;
 
 class Bucket : private util::noncopyable {
 public:
-    virtual void render(Painter& painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix) = 0;
+    virtual void render(Painter& painter, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix) = 0;
     virtual bool hasData() const = 0;
     virtual ~Bucket() {}
 
diff --git a/include/mbgl/renderer/debug_bucket.hpp b/include/mbgl/renderer/debug_bucket.hpp
index 660b7fcba8..fb6cfb4cae 100644
--- a/include/mbgl/renderer/debug_bucket.hpp
+++ b/include/mbgl/renderer/debug_bucket.hpp
@@ -6,7 +6,6 @@
 #include <mbgl/geometry/vao.hpp>
 
 #include <vector>
-#include <memory>
 
 #ifndef BUFFER_OFFSET
 #define BUFFER_OFFSET(i) ((char *)nullptr + (i))
@@ -20,7 +19,7 @@ class DebugBucket : public Bucket {
 public:
     DebugBucket(DebugFontBuffer& fontBuffer);
 
-    virtual void render(Painter& painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
+    virtual void render(Painter& painter, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
     virtual bool hasData() const;
 
     void drawLines(PlainShader& shader);
diff --git a/include/mbgl/renderer/fill_bucket.hpp b/include/mbgl/renderer/fill_bucket.hpp
index 15868e4092..ae766ec28d 100644
--- a/include/mbgl/renderer/fill_bucket.hpp
+++ b/include/mbgl/renderer/fill_bucket.hpp
@@ -44,7 +44,7 @@ public:
                const StyleBucketFill& properties);
     ~FillBucket();
 
-    virtual void render(Painter& painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
+    virtual void render(Painter& painter, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
     virtual bool hasData() const;
 
     void addGeometry(pbf& data);
diff --git a/include/mbgl/renderer/line_bucket.hpp b/include/mbgl/renderer/line_bucket.hpp
index 8babb734ed..7337ca80ad 100644
--- a/include/mbgl/renderer/line_bucket.hpp
+++ b/include/mbgl/renderer/line_bucket.hpp
@@ -1,13 +1,12 @@
 #ifndef MBGL_RENDERER_LINEBUCKET
 #define MBGL_RENDERER_LINEBUCKET
 
-#include "bucket.hpp"
+#include <mbgl/renderer/bucket.hpp>
 #include <mbgl/geometry/vao.hpp>
 #include <mbgl/geometry/elements_buffer.hpp>
 #include <mbgl/geometry/line_buffer.hpp>
 #include <mbgl/style/style_bucket.hpp>
 
-#include <memory>
 #include <vector>
 
 namespace mbgl {
@@ -30,7 +29,7 @@ public:
                PointElementsBuffer& pointElementsBuffer,
                const StyleBucketLine& properties);
 
-    virtual void render(Painter& painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
+    virtual void render(Painter& painter, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
     virtual bool hasData() const;
 
     void addGeometry(pbf& data);
diff --git a/include/mbgl/renderer/painter.hpp b/include/mbgl/renderer/painter.hpp
index 75529d1136..13c2050bd0 100644
--- a/include/mbgl/renderer/painter.hpp
+++ b/include/mbgl/renderer/painter.hpp
@@ -22,6 +22,7 @@
 #include <mbgl/shader/gaussian_shader.hpp>
 
 #include <mbgl/map/transform_state.hpp>
+#include <mbgl/util/ptr.hpp>
 
 #include <map>
 #include <unordered_map>
@@ -72,7 +73,7 @@ public:
     void changeMatrix();
 
     // Renders a particular layer from a tile.
-    void renderTileLayer(const Tile& tile, std::shared_ptr<StyleLayer> layer_desc, const mat4 &matrix);
+    void renderTileLayer(const Tile& tile, util::ptr<StyleLayer> layer_desc, const mat4 &matrix);
 
     // Renders debug information for a tile.
     void renderTileDebug(const Tile& tile);
@@ -82,11 +83,11 @@ public:
 
     void renderDebugText(DebugBucket& bucket, const mat4 &matrix);
     void renderDebugText(const std::vector<std::string> &strings);
-    void renderFill(FillBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
-    void renderLine(LineBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
-    void renderSymbol(SymbolBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
-    void renderRaster(RasterBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
-    void renderBackground(std::shared_ptr<StyleLayer> layer_desc);
+    void renderFill(FillBucket& bucket, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
+    void renderLine(LineBucket& bucket, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
+    void renderSymbol(SymbolBucket& bucket, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
+    void renderRaster(RasterBucket& bucket, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
+    void renderBackground(util::ptr<StyleLayer> layer_desc);
 
     float saturationFactor(float saturation);
     float contrastFactor(float contrast);
@@ -96,7 +97,7 @@ public:
 
     void renderPrerenderedTexture(RasterBucket &bucket, const mat4 &matrix, const RasterProperties& properties);
 
-    void createPrerendered(RasterBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
+    void createPrerendered(RasterBucket& bucket, util::ptr<StyleLayer> layer_desc, const Tile::ID& id);
 
     void resize();
 
@@ -110,7 +111,7 @@ public:
     // Configures the painter strata that is used for early z-culling of fragments.
     void setStrata(float strata);
 
-    void drawClippingMasks(const std::set<std::shared_ptr<StyleSource>> &sources);
+    void drawClippingMasks(const std::set<util::ptr<StyleSource>> &sources);
     void drawClippingMask(const mat4& matrix, const ClipID& clip);
 
     void resetFramebuffer();
diff --git a/include/mbgl/renderer/raster_bucket.hpp b/include/mbgl/renderer/raster_bucket.hpp
index 66cceac8e7..794da3b143 100644
--- a/include/mbgl/renderer/raster_bucket.hpp
+++ b/include/mbgl/renderer/raster_bucket.hpp
@@ -16,9 +16,9 @@ class VertexArrayObject;
 
 class RasterBucket : public Bucket {
 public:
-    RasterBucket(const std::shared_ptr<Texturepool> &texturepool, const StyleBucketRaster& properties);
+    RasterBucket(const util::ptr<Texturepool> &texturepool, const StyleBucketRaster& properties);
 
-    virtual void render(Painter& painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
+    virtual void render(Painter& painter, util::ptr<StyleLayer> layer_desc, const Tile::ID& id, const mat4 &matrix);
     virtual bool hasData() const;
 
     bool setImage(const std::string &data);
diff --git a/include/mbgl/renderer/symbol_bucket.hpp b/include/mbgl/renderer/symbol_bucket.hpp
index c71d276456..42682401ef 100644
--- a/include/mbgl/renderer/symbol_bucket.hpp
+++ b/include/mbgl/renderer/symbol_bucket.hpp
@@ -56,7 +56,7 @@ class SymbolBucket : public Bucket {
 public:
     SymbolBucket(const StyleBucketSymbol &properties, Collision &collision);
 
-    virtual void render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID &id, const mat4 &matrix);
+    virtual void render(Painter &painter, util::ptr<StyleLayer> layer_desc, const Tile::ID &id, const mat4 &matrix);
     virtual bool hasData() const;
     virtual bool hasTextData() const;
     virtual bool hasIconData() const;
diff --git a/include/mbgl/storage/base_request.hpp b/include/mbgl/storage/base_request.hpp
index 05ef1e4a7b..c903742f4b 100644
--- a/include/mbgl/storage/base_request.hpp
+++ b/include/mbgl/storage/base_request.hpp
@@ -1,11 +1,13 @@
 #ifndef MBGL_STORAGE_BASE_REQUEST
 #define MBGL_STORAGE_BASE_REQUEST
 
+#include <mbgl/util/ptr.hpp>
+
 #include <string>
 #include <forward_list>
-#include <memory>
 #include <functional>
 
+
 typedef struct uv_loop_s uv_loop_t;
 typedef struct uv_async_s uv_async_t;
 
@@ -28,7 +30,7 @@ public:
     BaseRequest(const std::string &path);
     virtual ~BaseRequest();
 
-    Callback *add(Callback &&callback, const std::shared_ptr<BaseRequest> &request);
+    Callback *add(Callback &&callback, const util::ptr<BaseRequest> &request);
     void remove(Callback *callback);
     void notify();
 
@@ -40,7 +42,7 @@ public:
 private:
     // This object may hold a shared_ptr to itself. It does this to prevent destruction of this object
     // while a request is in progress.
-    std::shared_ptr<BaseRequest> self;
+    util::ptr<BaseRequest> self;
 
     std::forward_list<std::unique_ptr<Callback>> callbacks;
 };
diff --git a/include/mbgl/storage/file_request.hpp b/include/mbgl/storage/file_request.hpp
index 331ed8421f..c99237ad4b 100644
--- a/include/mbgl/storage/file_request.hpp
+++ b/include/mbgl/storage/file_request.hpp
@@ -1,11 +1,6 @@
 #ifndef MBGL_STORAGE_FILE_REQUEST
 #define MBGL_STORAGE_FILE_REQUEST
 
-
-#include <string>
-#include <memory>
-#include <cassert>
-
 #include <mbgl/storage/base_request.hpp>
 
 namespace mbgl {
diff --git a/include/mbgl/storage/file_source.hpp b/include/mbgl/storage/file_source.hpp
index 4cc95ae24e..06d416d0c6 100644
--- a/include/mbgl/storage/file_source.hpp
+++ b/include/mbgl/storage/file_source.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/storage/request.hpp>
 
 #include <string>
-#include <memory>
 #include <unordered_map>
 #include <functional>
 
@@ -44,7 +43,7 @@ private:
     std::string base;
 
     std::unordered_map<std::string, std::weak_ptr<BaseRequest>> pending;
-    std::shared_ptr<SQLiteStore> store;
+    util::ptr<SQLiteStore> store;
     uv_loop_t *loop = nullptr;
     uv_messenger_t *queue = nullptr;
 };
diff --git a/include/mbgl/storage/http_request.hpp b/include/mbgl/storage/http_request.hpp
index 30f7b3aa6d..ef3210d48d 100644
--- a/include/mbgl/storage/http_request.hpp
+++ b/include/mbgl/storage/http_request.hpp
@@ -19,7 +19,7 @@ class SQLiteStore;
 
 class HTTPRequest : public BaseRequest {
 public:
-    HTTPRequest(ResourceType type, const std::string &path, uv_loop_t *loop, std::shared_ptr<SQLiteStore> store);
+    HTTPRequest(ResourceType type, const std::string &path, uv_loop_t *loop, util::ptr<SQLiteStore> store);
     ~HTTPRequest();
 
 private:
@@ -29,7 +29,7 @@ private:
     const unsigned long thread_id;
     CacheRequestBaton *cache_baton = nullptr;
     HTTPRequestBaton *http_baton = nullptr;
-    std::shared_ptr<SQLiteStore> store;
+    util::ptr<SQLiteStore> store;
     const ResourceType type;
 };
 
diff --git a/include/mbgl/storage/request.hpp b/include/mbgl/storage/request.hpp
index fa27fbc781..10c938ed15 100644
--- a/include/mbgl/storage/request.hpp
+++ b/include/mbgl/storage/request.hpp
@@ -2,8 +2,8 @@
 #define MBGL_STORAGE_REQUEST
 
 #include <mbgl/storage/response.hpp>
+#include <mbgl/util/ptr.hpp>
 
-#include <memory>
 #include <functional>
 #include <forward_list>
 
@@ -22,7 +22,7 @@ private:
     Request& operator=(Request &&) = delete;
 
 public:
-    Request(const std::shared_ptr<BaseRequest> &base);
+    Request(const util::ptr<BaseRequest> &base);
     ~Request();
 
     void onload(Callback cb);
@@ -30,7 +30,7 @@ public:
 
 private:
     const unsigned long thread_id;
-    std::shared_ptr<BaseRequest> base;
+    util::ptr<BaseRequest> base;
     std::forward_list<Callback *> callbacks;
 };
 
diff --git a/include/mbgl/storage/sqlite_store.hpp b/include/mbgl/storage/sqlite_store.hpp
index e03e6cf2bc..cb7730d0bf 100644
--- a/include/mbgl/storage/sqlite_store.hpp
+++ b/include/mbgl/storage/sqlite_store.hpp
@@ -38,7 +38,7 @@ private:
 
 private:
     const unsigned long thread_id;
-    std::shared_ptr<mapbox::sqlite::Database> db;
+    util::ptr<mapbox::sqlite::Database> db;
     uv_worker_t *worker = nullptr;
 };
 
diff --git a/include/mbgl/style/style.hpp b/include/mbgl/style/style.hpp
index c09de6ebba..56f318ecbb 100644
--- a/include/mbgl/style/style.hpp
+++ b/include/mbgl/style/style.hpp
@@ -6,6 +6,7 @@
 
 #include <mbgl/util/time.hpp>
 #include <mbgl/util/uv.hpp>
+#include <mbgl/util/ptr.hpp>
 
 #include <cstdint>
 #include <map>
@@ -13,7 +14,6 @@
 #include <unordered_map>
 #include <vector>
 #include <set>
-#include <memory>
 
 namespace mbgl {
 
@@ -49,7 +49,7 @@ public:
     const std::string &getSpriteURL() const;
 
 public:
-    std::shared_ptr<StyleLayerGroup> layers;
+    util::ptr<StyleLayerGroup> layers;
     std::vector<std::string> appliedClasses;
     std::string glyph_url;
 
diff --git a/include/mbgl/style/style_bucket.hpp b/include/mbgl/style/style_bucket.hpp
index c2cde52aa5..c4a8f6037e 100644
--- a/include/mbgl/style/style_bucket.hpp
+++ b/include/mbgl/style/style_bucket.hpp
@@ -8,8 +8,8 @@
 #include <mbgl/util/vec.hpp>
 #include <mbgl/util/variant.hpp>
 #include <mbgl/util/noncopyable.hpp>
+#include <mbgl/util/ptr.hpp>
 
-#include <memory>
 #include <forward_list>
 
 namespace mbgl {
@@ -93,12 +93,12 @@ typedef mapbox::util::variant<StyleBucketFill, StyleBucketLine, StyleBucketSymbo
 
 class StyleBucket {
 public:
-    typedef std::shared_ptr<StyleBucket> Ptr;
+    typedef util::ptr<StyleBucket> Ptr;
 
     StyleBucket(StyleLayerType type);
 
     std::string name;
-    std::shared_ptr<StyleSource> style_source;
+    util::ptr<StyleSource> style_source;
     std::string source_layer;
     FilterExpression filter;
     StyleBucketRender render = std::false_type();
diff --git a/include/mbgl/style/style_layer.hpp b/include/mbgl/style/style_layer.hpp
index 84981e3fb4..641dc1e71c 100644
--- a/include/mbgl/style/style_layer.hpp
+++ b/include/mbgl/style/style_layer.hpp
@@ -6,8 +6,9 @@
 #include <mbgl/style/style_properties.hpp>
 #include <mbgl/style/applied_class_properties.hpp>
 
+#include <mbgl/util/ptr.hpp>
+
 #include <vector>
-#include <memory>
 #include <string>
 #include <map>
 #include <set>
@@ -64,7 +65,7 @@ public:
 
     // Bucket information, telling the renderer how to generate the geometries
     // for this layer (feature property filters, tessellation instructions, ...).
-    std::shared_ptr<StyleBucket> bucket;
+    util::ptr<StyleBucket> bucket;
 
     // Contains all style classes that can be applied to this layer.
     const std::map<ClassID, ClassProperties> styles;
@@ -80,7 +81,7 @@ public:
     StyleProperties properties;
 
     // Child layer array (if this layer has child layers).
-    std::shared_ptr<StyleLayerGroup> layers;
+    util::ptr<StyleLayerGroup> layers;
 };
 
 }
diff --git a/include/mbgl/style/style_layer_group.hpp b/include/mbgl/style/style_layer_group.hpp
index 983dd136f0..1af6e23bd7 100644
--- a/include/mbgl/style/style_layer_group.hpp
+++ b/include/mbgl/style/style_layer_group.hpp
@@ -15,7 +15,7 @@ public:
 
     bool hasTransitions() const;
 public:
-    std::vector<std::shared_ptr<StyleLayer>> layers;
+    std::vector<util::ptr<StyleLayer>> layers;
 };
 
 }
diff --git a/include/mbgl/style/style_parser.hpp b/include/mbgl/style/style_parser.hpp
index e4e1b7f632..fc253bb1dd 100644
--- a/include/mbgl/style/style_parser.hpp
+++ b/include/mbgl/style/style_parser.hpp
@@ -27,7 +27,7 @@ public:
 
     void parse(JSVal document);
 
-    std::shared_ptr<StyleLayerGroup> getLayers() {
+    util::ptr<StyleLayerGroup> getLayers() {
         return root;
     }
 
@@ -46,14 +46,14 @@ private:
     void parseSources(JSVal value);
 
     std::unique_ptr<StyleLayerGroup> createLayers(JSVal value);
-    std::shared_ptr<StyleLayer> createLayer(JSVal value);
+    util::ptr<StyleLayer> createLayer(JSVal value);
     void parseLayers();
-    void parseLayer(std::pair<JSVal, std::shared_ptr<StyleLayer>> &pair);
+    void parseLayer(std::pair<JSVal, util::ptr<StyleLayer>> &pair);
     void parseStyles(JSVal value, std::map<ClassID, ClassProperties> &styles);
     void parseStyle(JSVal, ClassProperties &properties);
-    void parseReference(JSVal value, std::shared_ptr<StyleLayer> &layer);
-    void parseBucket(JSVal value, std::shared_ptr<StyleLayer> &layer);
-    void parseRender(JSVal value, std::shared_ptr<StyleLayer> &layer);
+    void parseReference(JSVal value, util::ptr<StyleLayer> &layer);
+    void parseBucket(JSVal value, util::ptr<StyleLayer> &layer);
+    void parseRender(JSVal value, util::ptr<StyleLayer> &layer);
     void parseSprite(JSVal value);
     void parseGlyphURL(JSVal value);
 
@@ -94,13 +94,13 @@ private:
 private:
     std::unordered_map<std::string, const rapidjson::Value *> constants;
 
-    std::unordered_map<std::string, const std::shared_ptr<StyleSource>> sources;
+    std::unordered_map<std::string, const util::ptr<StyleSource>> sources;
 
     // This stores the root layer.
-    std::shared_ptr<StyleLayerGroup> root;
+    util::ptr<StyleLayerGroup> root;
 
     // This maps ids to Layer objects, with all items being at the root level.
-    std::unordered_map<std::string, std::pair<JSVal, std::shared_ptr<StyleLayer>>> layers;
+    std::unordered_map<std::string, std::pair<JSVal, util::ptr<StyleLayer>>> layers;
 
     // Store a stack of layers we're parsing right now. This is to prevent reference cycles.
     std::forward_list<StyleLayer *> stack;
diff --git a/include/mbgl/style/style_source.hpp b/include/mbgl/style/style_source.hpp
index b598550c65..4b89a6557c 100644
--- a/include/mbgl/style/style_source.hpp
+++ b/include/mbgl/style/style_source.hpp
@@ -2,13 +2,12 @@
 #define MBGL_STYLE_STYLE_SOURCE
 
 #include <mbgl/style/types.hpp>
+#include <mbgl/util/ptr.hpp>
+#include <rapidjson/document.h>
 
-#include <memory>
 #include <vector>
 #include <string>
 
-#include <rapidjson/document.h>
-
 namespace mbgl {
 
 class Source;
@@ -34,7 +33,7 @@ public:
     SourceInfo info;
 
     bool enabled = false;
-    std::shared_ptr<Source> source;
+    util::ptr<Source> source;
 
     StyleSource(const SourceInfo &info)
         : info(info)
diff --git a/include/mbgl/text/glyph_store.hpp b/include/mbgl/text/glyph_store.hpp
index 9730967053..f8a7cb4d0c 100644
--- a/include/mbgl/text/glyph_store.hpp
+++ b/include/mbgl/text/glyph_store.hpp
@@ -4,6 +4,7 @@
 #include <mbgl/text/glyph.hpp>
 #include <mbgl/util/pbf.hpp>
 #include <mbgl/util/vec.hpp>
+#include <mbgl/util/ptr.hpp>
 
 #include <cstdint>
 #include <vector>
@@ -47,7 +48,7 @@ private:
 
 class GlyphPBF {
 public:
-    GlyphPBF(const std::string &glyphURL, const std::string &fontStack, GlyphRange glyphRange, const std::shared_ptr<FileSource> &fileSource);
+    GlyphPBF(const std::string &glyphURL, const std::string &fontStack, GlyphRange glyphRange, const util::ptr<FileSource> &fileSource);
 
 private:
     GlyphPBF(const GlyphPBF &) = delete;
@@ -70,7 +71,7 @@ private:
 // Manages Glyphrange PBF loading.
 class GlyphStore {
 public:
-    GlyphStore(const std::shared_ptr<FileSource> &fileSource);
+    GlyphStore(const util::ptr<FileSource> &fileSource);
 
     // Block until all specified GlyphRanges of the specified font stack are loaded.
     void waitForGlyphRanges(const std::string &fontStack, const std::set<GlyphRange> &glyphRanges);
@@ -89,7 +90,7 @@ public:
     std::string glyphURL;
 
 private:
-    const std::shared_ptr<FileSource> fileSource;
+    const util::ptr<FileSource> fileSource;
     std::unordered_map<std::string, std::map<GlyphRange, std::unique_ptr<GlyphPBF>>> ranges;
     std::unordered_map<std::string, std::unique_ptr<FontStack>> stacks;
     std::mutex mtx;
diff --git a/include/mbgl/util/ptr.hpp b/include/mbgl/util/ptr.hpp
new file mode 100644
index 0000000000..5511083fc6
--- /dev/null
+++ b/include/mbgl/util/ptr.hpp
@@ -0,0 +1,29 @@
+#ifndef MBGL_UTIL_PTR
+#define MBGL_UTIL_PTR
+
+#include <memory>
+#include <cassert>
+
+namespace mbgl {
+namespace util {
+
+template <typename T>
+class ptr : public ::std::shared_ptr<T> {
+public:
+    template <typename... Args>
+    inline ptr(Args &&... args)
+        : ::std::shared_ptr<T>(::std::forward<Args>(args)...) {}
+
+    inline auto operator->() const -> decltype(::std::shared_ptr<T>::operator->()) {
+        assert(*this);
+        return ::std::shared_ptr<T>::operator->();
+    }
+    inline auto operator*() const -> decltype(::std::shared_ptr<T>::operator*()) {
+        assert(*this);
+        return ::std::shared_ptr<T>::operator*();
+    }
+};
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/include/mbgl/util/raster.hpp b/include/mbgl/util/raster.hpp
index e526ffa5ac..7051c30091 100644
--- a/include/mbgl/util/raster.hpp
+++ b/include/mbgl/util/raster.hpp
@@ -4,11 +4,11 @@
 #include <mbgl/util/transition.hpp>
 #include <mbgl/util/texturepool.hpp>
 #include <mbgl/util/image.hpp>
+#include <mbgl/util/ptr.hpp>
 #include <mbgl/renderer/prerendered_texture.hpp>
 
 #include <string>
 #include <mutex>
-#include <memory>
 
 typedef struct uv_loop_s uv_loop_t;
 
@@ -17,7 +17,7 @@ namespace mbgl {
 class Raster : public std::enable_shared_from_this<Raster> {
 
 public:
-    Raster(const std::shared_ptr<Texturepool> &texturepool);
+    Raster(const util::ptr<Texturepool> &texturepool);
     ~Raster();
 
     // load image data
@@ -57,7 +57,7 @@ private:
     bool loaded = false;
 
     // shared texture pool
-    std::shared_ptr<Texturepool> texturepool;
+    util::ptr<Texturepool> texturepool;
 
     // min/mag filter
     uint32_t filter = 0;
@@ -66,7 +66,7 @@ private:
     std::unique_ptr<util::Image> img;
 
     // fade in transition
-    std::shared_ptr<util::transition> fade_transition = nullptr;
+    util::ptr<util::transition> fade_transition = nullptr;
 };
 
 }
diff --git a/include/mbgl/util/uv_detail.hpp b/include/mbgl/util/uv_detail.hpp
index eefb5ac8df..272ca41495 100644
--- a/include/mbgl/util/uv_detail.hpp
+++ b/include/mbgl/util/uv_detail.hpp
@@ -1,6 +1,8 @@
 #ifndef MBGL_UTIL_UV_DETAIL
 #define MBGL_UTIL_UV_DETAIL
 
+#include <mbgl/util/ptr.hpp>
+
 #include <uv.h>
 
 #include <functional>
@@ -113,7 +115,7 @@ public:
     typedef void (*after_work_callback)(T &object);
 
     template<typename... Args>
-    work(const std::shared_ptr<loop> &loop, work_callback work_cb, after_work_callback after_work_cb, Args&&... args)
+    work(const mbgl::util::ptr<loop> &loop, work_callback work_cb, after_work_callback after_work_cb, Args&&... args)
         : loop(loop),
           data(std::forward<Args>(args)...),
           work_cb(work_cb),
@@ -135,7 +137,7 @@ private:
     }
 
 private:
-    std::shared_ptr<uv::loop> loop;
+    mbgl::util::ptr<uv::loop> loop;
     uv_work_t req;
     T data;
     work_callback work_cb;
-- 
cgit v1.2.1


From fd2b2e208229259630f92bd7615f9197c163d27f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Tue, 16 Sep 2014 18:23:42 +0200
Subject: use separate workers for tile parsing to avoid blocking the
 threadpool for other libuv actions

---
 include/mbgl/map/map.hpp        |  2 ++
 include/mbgl/util/uv-worker.h   |  5 ++---
 include/mbgl/util/uv.hpp        |  1 +
 include/mbgl/util/uv_detail.hpp | 35 ++++++++++++++++++++++++-----------
 4 files changed, 29 insertions(+), 14 deletions(-)

(limited to 'include')

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 786c7196ae..c389d898b1 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -126,6 +126,7 @@ public:
     util::ptr<Sprite> getSprite();
     inline util::ptr<Texturepool> getTexturepool() { return texturepool; }
     inline util::ptr<uv::loop> getLoop() { return loop; }
+    uv::worker &getWorker();
     inline timestamp getAnimationTime() const { return animationTime; }
     inline timestamp getTime() const { return animationTime; }
     void updateTiles();
@@ -159,6 +160,7 @@ private:
 private:
     bool async = false;
     util::ptr<uv::loop> loop;
+    std::unique_ptr<uv::worker> workers;
     std::unique_ptr<uv::thread> thread;
     std::unique_ptr<uv_async_t> async_terminate;
     std::unique_ptr<uv_async_t> async_render;
diff --git a/include/mbgl/util/uv-worker.h b/include/mbgl/util/uv-worker.h
index b9eb10fb70..a66feb4d00 100644
--- a/include/mbgl/util/uv-worker.h
+++ b/include/mbgl/util/uv-worker.h
@@ -14,17 +14,16 @@ typedef struct uv_messenger_s uv_messenger_t;
 typedef struct uv_worker_s uv_worker_t;
 
 struct uv_worker_s {
-    uv_thread_t thread;
     uv_messenger_t *msgr;
     uv_chan_t chan;
     const char *name;
+    void *threads[2];
 };
 
 typedef void (*uv_worker_cb)(void *data);
 typedef void (*uv_worker_after_cb)(void *data);
 
-int uv_worker_init(uv_worker_t *worker, uv_loop_t *loop);
-int uv_worker_init_named(uv_worker_t *worker, uv_loop_t *loop, const char *name);
+int uv_worker_init(uv_worker_t *worker, uv_loop_t *loop, int count, const char *name);
 void uv_worker_send(uv_worker_t *worker, void *data, uv_worker_cb work_cb,
                     uv_worker_after_cb after_work_cb);
 void uv_worker_close(uv_worker_t *worker);
diff --git a/include/mbgl/util/uv.hpp b/include/mbgl/util/uv.hpp
index 4ceb8b873f..80fff9c96f 100644
--- a/include/mbgl/util/uv.hpp
+++ b/include/mbgl/util/uv.hpp
@@ -14,6 +14,7 @@ std::string cwd();
 class thread;
 class rwlock;
 class loop;
+class worker;
 
 }
 
diff --git a/include/mbgl/util/uv_detail.hpp b/include/mbgl/util/uv_detail.hpp
index 272ca41495..b0b4fe583f 100644
--- a/include/mbgl/util/uv_detail.hpp
+++ b/include/mbgl/util/uv_detail.hpp
@@ -2,6 +2,7 @@
 #define MBGL_UTIL_UV_DETAIL
 
 #include <mbgl/util/ptr.hpp>
+#include <mbgl/util/uv-worker.h>
 
 #include <uv.h>
 
@@ -108,6 +109,22 @@ private:
     uv_once_t o = UV_ONCE_INIT;
 };
 
+class worker {
+public:
+    inline worker(uv_loop_t *loop, unsigned int count, const char *name = nullptr) {
+        uv_worker_init(&w, loop, count, name);
+    }
+    inline ~worker() {
+        uv_worker_close(&w);
+    }
+    inline void add(void *data, uv_worker_cb work_cb, uv_worker_after_cb after_work_cb) {
+        uv_worker_send(&w, data, work_cb, after_work_cb);
+    }
+
+private:
+    uv_worker_t w;
+};
+
 template <typename T>
 class work {
 public:
@@ -115,30 +132,26 @@ public:
     typedef void (*after_work_callback)(T &object);
 
     template<typename... Args>
-    work(const mbgl::util::ptr<loop> &loop, work_callback work_cb, after_work_callback after_work_cb, Args&&... args)
-        : loop(loop),
-          data(std::forward<Args>(args)...),
+    work(worker &worker, work_callback work_cb, after_work_callback after_work_cb, Args&&... args)
+        : data(std::forward<Args>(args)...),
           work_cb(work_cb),
           after_work_cb(after_work_cb) {
-        req.data = this;
-        uv_queue_work(**loop, &req, do_work, after_work);
+        worker.add(this, do_work, after_work);
     }
 
 private:
-    static void do_work(uv_work_t *req) {
-        work<T> *w = static_cast<work<T> *>(req->data);
+    static void do_work(void *data) {
+        work<T> *w = reinterpret_cast<work<T> *>(data);
         w->work_cb(w->data);
     }
 
-    static void after_work(uv_work_t *req, int) {
-        work<T> *w = static_cast<work<T> *>(req->data);
+    static void after_work(void *data) {
+        work<T> *w = reinterpret_cast<work<T> *>(data);
         w->after_work_cb(w->data);
         delete w;
     }
 
 private:
-    mbgl::util::ptr<uv::loop> loop;
-    uv_work_t req;
     T data;
     work_callback work_cb;
     after_work_callback after_work_cb;
-- 
cgit v1.2.1


From 89cd310cf6117586701b1e72fe7c2bf0fbd760db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Wed, 17 Sep 2014 12:10:08 +0200
Subject: notifications on request cancellation

---
 include/mbgl/storage/base_request.hpp     |  4 +---
 include/mbgl/storage/request.hpp          |  6 +++---
 include/mbgl/storage/request_callback.hpp | 22 ++++++++++++++++++++++
 3 files changed, 26 insertions(+), 6 deletions(-)
 create mode 100644 include/mbgl/storage/request_callback.hpp

(limited to 'include')

diff --git a/include/mbgl/storage/base_request.hpp b/include/mbgl/storage/base_request.hpp
index c903742f4b..832ecbc23d 100644
--- a/include/mbgl/storage/base_request.hpp
+++ b/include/mbgl/storage/base_request.hpp
@@ -1,6 +1,7 @@
 #ifndef MBGL_STORAGE_BASE_REQUEST
 #define MBGL_STORAGE_BASE_REQUEST
 
+#include <mbgl/storage/request_callback.hpp>
 #include <mbgl/util/ptr.hpp>
 
 #include <string>
@@ -15,8 +16,6 @@ namespace mbgl {
 
 class Response;
 class Request;
-using Callback = std::function<void(const Response &)>;
-
 
 class BaseRequest {
 private:
@@ -43,7 +42,6 @@ private:
     // This object may hold a shared_ptr to itself. It does this to prevent destruction of this object
     // while a request is in progress.
     util::ptr<BaseRequest> self;
-
     std::forward_list<std::unique_ptr<Callback>> callbacks;
 };
 
diff --git a/include/mbgl/storage/request.hpp b/include/mbgl/storage/request.hpp
index 10c938ed15..e603ee527a 100644
--- a/include/mbgl/storage/request.hpp
+++ b/include/mbgl/storage/request.hpp
@@ -1,10 +1,10 @@
 #ifndef MBGL_STORAGE_REQUEST
 #define MBGL_STORAGE_REQUEST
 
+#include <mbgl/storage/request_callback.hpp>
 #include <mbgl/storage/response.hpp>
 #include <mbgl/util/ptr.hpp>
 
-#include <functional>
 #include <forward_list>
 
 typedef struct uv_loop_s uv_loop_t;
@@ -12,7 +12,6 @@ typedef struct uv_loop_s uv_loop_t;
 namespace mbgl {
 
 class BaseRequest;
-using Callback = std::function<void(const Response &)>;
 
 class Request {
 private:
@@ -25,7 +24,8 @@ public:
     Request(const util::ptr<BaseRequest> &base);
     ~Request();
 
-    void onload(Callback cb);
+    void onload(CompletedCallback cb);
+    void oncancel(AbortedCallback cb);
     void cancel();
 
 private:
diff --git a/include/mbgl/storage/request_callback.hpp b/include/mbgl/storage/request_callback.hpp
new file mode 100644
index 0000000000..01427bd96d
--- /dev/null
+++ b/include/mbgl/storage/request_callback.hpp
@@ -0,0 +1,22 @@
+#ifndef MBGL_STORAGE_REQUEST_CALLBACK
+#define MBGL_STORAGE_REQUEST_CALLBACK
+
+#include <mbgl/util/variant.hpp>
+
+#include <functional>
+
+namespace mbgl {
+
+class Response;
+
+using CompletedCallback = std::function<void(const Response &)>;
+using AbortedCallback = std::function<void()>;
+
+using Callback = mapbox::util::variant<
+    CompletedCallback,
+    AbortedCallback
+>;
+
+}
+
+#endif
-- 
cgit v1.2.1


From ba18c08524cffd3fa03adf49f680f3a80390d61d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Wed, 17 Sep 2014 15:29:24 +0200
Subject: add a callback to stop() to allow running the current thread's event
 loop

---
 include/mbgl/map/map.hpp  | 7 ++++++-
 include/mbgl/map/view.hpp | 2 ++
 2 files changed, 8 insertions(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index c389d898b1..48c4e89cc9 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -31,6 +31,8 @@ class FileSource;
 class View;
 
 class Map : private util::noncopyable {
+    typedef void (*stop_callback)();
+
 public:
     explicit Map(View &view);
     ~Map();
@@ -38,7 +40,7 @@ public:
     // Start/stop the map render thread. the start() call is asynchronous, while the stop() call
     // will block until the map rendering thread stopped.
     void start();
-    void stop();
+    void stop(stop_callback cb = nullptr);
 
     // Runs the map event loop. ONLY run this function when you want to get render a single frame
     // with this map object. It will *not* spawn a separate thread and instead block until the
@@ -179,6 +181,9 @@ private:
     // ready for rendering.
     std::atomic_flag is_rendered = ATOMIC_FLAG_INIT;
 
+    // Stores whether the map thread has been stopped already.
+    std::atomic_bool is_stopped;
+
 public:
     View &view;
 
diff --git a/include/mbgl/map/view.hpp b/include/mbgl/map/view.hpp
index 92d60d4d02..bbdcd97c79 100644
--- a/include/mbgl/map/view.hpp
+++ b/include/mbgl/map/view.hpp
@@ -41,6 +41,8 @@ public:
         return 0;
     }
 
+    virtual void notify() = 0;
+
     // Notifies a watcher of map x/y/scale/rotation changes.
     // Must only be called from the same thread that caused the change.
     // Must not be called from the render thread.
-- 
cgit v1.2.1


From 111fccb76c1f599470074a75ca77e9de016cca73 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Wed, 17 Sep 2014 15:39:16 +0200
Subject: option to pass data parameter, and add more explanation

---
 include/mbgl/map/map.hpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

(limited to 'include')

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 48c4e89cc9..85c9e8e6a5 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -31,16 +31,21 @@ class FileSource;
 class View;
 
 class Map : private util::noncopyable {
-    typedef void (*stop_callback)();
+    typedef void (*stop_callback)(void *);
 
 public:
     explicit Map(View &view);
     ~Map();
 
-    // Start/stop the map render thread. the start() call is asynchronous, while the stop() call
-    // will block until the map rendering thread stopped.
+    // Start the map render thread. It is asynchronous.
     void start();
-    void stop(stop_callback cb = nullptr);
+
+    // Stop the map render thread. This call will block until the map rendering thread stopped.
+    // The optional callback function will be invoked repeatedly until the map thread is stopped.
+    // The callback function should wait until it is woken up again by view.notify(), otherwise
+    // this will be a busy waiting loop. The optional data parameter will be passed to the callback
+    // function.
+    void stop(stop_callback cb = nullptr, void *data = nullptr);
 
     // Runs the map event loop. ONLY run this function when you want to get render a single frame
     // with this map object. It will *not* spawn a separate thread and instead block until the
-- 
cgit v1.2.1


From 19129cbd023345569b24f1b9863e0ee32ae61182 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Wed, 17 Sep 2014 16:01:35 +0200
Subject: make SourceInfo object noncopyable and use a shared_pointer for it

---
 include/mbgl/map/raster_tile_data.hpp | 2 +-
 include/mbgl/map/source.hpp           | 4 ++--
 include/mbgl/map/tile_data.hpp        | 4 ++--
 include/mbgl/map/vector_tile_data.hpp | 2 +-
 include/mbgl/style/style_source.hpp   | 7 ++++---
 5 files changed, 10 insertions(+), 9 deletions(-)

(limited to 'include')

diff --git a/include/mbgl/map/raster_tile_data.hpp b/include/mbgl/map/raster_tile_data.hpp
index 329bbf4634..14833c0d84 100644
--- a/include/mbgl/map/raster_tile_data.hpp
+++ b/include/mbgl/map/raster_tile_data.hpp
@@ -16,7 +16,7 @@ class RasterTileData : public TileData {
     friend class TileParser;
 
 public:
-    RasterTileData(Tile::ID id, Map &map, const SourceInfo &source);
+    RasterTileData(Tile::ID id, Map &map, const util::ptr<SourceInfo> &source);
     ~RasterTileData();
 
     virtual void parse();
diff --git a/include/mbgl/map/source.hpp b/include/mbgl/map/source.hpp
index 471165f37c..e74ddb9902 100644
--- a/include/mbgl/map/source.hpp
+++ b/include/mbgl/map/source.hpp
@@ -25,7 +25,7 @@ struct box;
 
 class Source : public std::enable_shared_from_this<Source>, private util::noncopyable {
 public:
-    Source(SourceInfo& info);
+    Source(const util::ptr<SourceInfo>& info);
 
     void load(Map &map);
 
@@ -54,7 +54,7 @@ private:
 
     double getZoom(const TransformState &state) const;
 
-    SourceInfo& info;
+    util::ptr<SourceInfo> info;
     bool loaded = false;
 
     // Stores the time when this source was most recently updated.
diff --git a/include/mbgl/map/tile_data.hpp b/include/mbgl/map/tile_data.hpp
index 803f0447b3..07cf19c5c8 100644
--- a/include/mbgl/map/tile_data.hpp
+++ b/include/mbgl/map/tile_data.hpp
@@ -40,7 +40,7 @@ public:
     };
 
 public:
-    TileData(Tile::ID id, Map &map, const SourceInfo &source);
+    TileData(Tile::ID id, Map &map, const util::ptr<SourceInfo> &source);
     ~TileData();
 
     void request();
@@ -68,7 +68,7 @@ protected:
     Map &map;
 
 public:
-    const SourceInfo &source;
+    util::ptr<SourceInfo> source;
 
 protected:
     std::unique_ptr<Request> req;
diff --git a/include/mbgl/map/vector_tile_data.hpp b/include/mbgl/map/vector_tile_data.hpp
index 3f80c0080c..9de666c84f 100644
--- a/include/mbgl/map/vector_tile_data.hpp
+++ b/include/mbgl/map/vector_tile_data.hpp
@@ -26,7 +26,7 @@ class VectorTileData : public TileData {
     friend class TileParser;
 
 public:
-    VectorTileData(Tile::ID id, Map &map, const SourceInfo &source);
+    VectorTileData(Tile::ID id, Map &map, const util::ptr<SourceInfo> &source);
     ~VectorTileData();
 
     virtual void beforeParse();
diff --git a/include/mbgl/style/style_source.hpp b/include/mbgl/style/style_source.hpp
index 4b89a6557c..00c48431a1 100644
--- a/include/mbgl/style/style_source.hpp
+++ b/include/mbgl/style/style_source.hpp
@@ -3,6 +3,7 @@
 
 #include <mbgl/style/types.hpp>
 #include <mbgl/util/ptr.hpp>
+#include <mbgl/util/noncopyable.hpp>
 #include <rapidjson/document.h>
 
 #include <vector>
@@ -12,7 +13,7 @@ namespace mbgl {
 
 class Source;
 
-class SourceInfo {
+class SourceInfo : private util::noncopyable {
 public:
     SourceType type = SourceType::Vector;
     std::string url;
@@ -30,12 +31,12 @@ public:
 
 class StyleSource : public std::enable_shared_from_this<StyleSource> {
 public:
-    SourceInfo info;
+    util::ptr<SourceInfo> info;
 
     bool enabled = false;
     util::ptr<Source> source;
 
-    StyleSource(const SourceInfo &info)
+    StyleSource(const util::ptr<SourceInfo> &info)
         : info(info)
     {}
 };
-- 
cgit v1.2.1


From daa22d6b0f0821465bf5adde9e09195bdaff30a7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Wed, 17 Sep 2014 18:10:45 +0200
Subject: use asynchronous worker termination

instead of waiting until all threads have joined, we are now supplying a callback that will be invoked once all threads have terminated. you can use this callback to free the worker struct
---
 include/mbgl/util/uv-worker.h   | 15 ++++++++++-----
 include/mbgl/util/uv_detail.hpp | 12 +++++++-----
 2 files changed, 17 insertions(+), 10 deletions(-)

(limited to 'include')

diff --git a/include/mbgl/util/uv-worker.h b/include/mbgl/util/uv-worker.h
index a66feb4d00..a9c9aff500 100644
--- a/include/mbgl/util/uv-worker.h
+++ b/include/mbgl/util/uv-worker.h
@@ -13,20 +13,25 @@ typedef struct uv_messenger_s uv_messenger_t;
 
 typedef struct uv_worker_s uv_worker_t;
 
+typedef void (*uv_worker_cb)(void *data);
+typedef void (*uv_worker_after_cb)(void *data);
+typedef void (*uv_worker_close_cb)(uv_worker_t *worker);
+
 struct uv_worker_s {
+#ifndef NDEBUG
+    unsigned long thread_id;
+#endif
     uv_messenger_t *msgr;
     uv_chan_t chan;
     const char *name;
-    void *threads[2];
+    int count;
+    uv_worker_close_cb close_cb;
 };
 
-typedef void (*uv_worker_cb)(void *data);
-typedef void (*uv_worker_after_cb)(void *data);
-
 int uv_worker_init(uv_worker_t *worker, uv_loop_t *loop, int count, const char *name);
 void uv_worker_send(uv_worker_t *worker, void *data, uv_worker_cb work_cb,
                     uv_worker_after_cb after_work_cb);
-void uv_worker_close(uv_worker_t *worker);
+void uv_worker_close(uv_worker_t *worker, uv_worker_close_cb close_cb);
 
 #ifdef __cplusplus
 }
diff --git a/include/mbgl/util/uv_detail.hpp b/include/mbgl/util/uv_detail.hpp
index b0b4fe583f..e0a57ce65d 100644
--- a/include/mbgl/util/uv_detail.hpp
+++ b/include/mbgl/util/uv_detail.hpp
@@ -111,18 +111,20 @@ private:
 
 class worker {
 public:
-    inline worker(uv_loop_t *loop, unsigned int count, const char *name = nullptr) {
-        uv_worker_init(&w, loop, count, name);
+    inline worker(uv_loop_t *loop, unsigned int count, const char *name = nullptr) : w(new uv_worker_t) {
+        uv_worker_init(w, loop, count, name);
     }
     inline ~worker() {
-        uv_worker_close(&w);
+        uv_worker_close(w, [](uv_worker_t *worker) {
+            delete worker;
+        });
     }
     inline void add(void *data, uv_worker_cb work_cb, uv_worker_after_cb after_work_cb) {
-        uv_worker_send(&w, data, work_cb, after_work_cb);
+        uv_worker_send(w, data, work_cb, after_work_cb);
     }
 
 private:
-    uv_worker_t w;
+    uv_worker_t *w;
 };
 
 template <typename T>
-- 
cgit v1.2.1


From 3f38c7650e6d76fe5e6fd6d8f2f3174af0c2e176 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Mon, 22 Sep 2014 13:06:40 +0200
Subject: add retry timers

---
 include/mbgl/storage/base_request.hpp       | 10 ++++-
 include/mbgl/storage/file_request.hpp       |  2 +
 include/mbgl/storage/http_request.hpp       |  4 ++
 include/mbgl/storage/http_request_baton.hpp | 64 ++++++++++++++++++++++++++++-
 include/mbgl/storage/response.hpp           |  2 +
 include/mbgl/util/uv.hpp                    |  6 +++
 6 files changed, 86 insertions(+), 2 deletions(-)

(limited to 'include')

diff --git a/include/mbgl/storage/base_request.hpp b/include/mbgl/storage/base_request.hpp
index 832ecbc23d..e9e6bfcb46 100644
--- a/include/mbgl/storage/base_request.hpp
+++ b/include/mbgl/storage/base_request.hpp
@@ -31,14 +31,22 @@ public:
 
     Callback *add(Callback &&callback, const util::ptr<BaseRequest> &request);
     void remove(Callback *callback);
+
+    // Must be called by subclasses when a valid Response object is available. It will notify
+    // all listeners.
     void notify();
 
+    // This function is called when the request ought to be stopped. Any subclass must make sure this
+    // is also called in its destructor. Calling this function repeatedly must be safe.
+    // This function must call notify().
+    virtual void cancel() = 0;
+
 public:
     const unsigned long thread_id;
     const std::string path;
     std::unique_ptr<Response> response;
 
-private:
+protected:
     // This object may hold a shared_ptr to itself. It does this to prevent destruction of this object
     // while a request is in progress.
     util::ptr<BaseRequest> self;
diff --git a/include/mbgl/storage/file_request.hpp b/include/mbgl/storage/file_request.hpp
index c99237ad4b..2f883728ff 100644
--- a/include/mbgl/storage/file_request.hpp
+++ b/include/mbgl/storage/file_request.hpp
@@ -14,6 +14,8 @@ public:
     FileRequest(const std::string &path, uv_loop_t *loop);
     ~FileRequest();
 
+    void cancel();
+
 private:
     FileRequestBaton *ptr = nullptr;
 
diff --git a/include/mbgl/storage/http_request.hpp b/include/mbgl/storage/http_request.hpp
index ef3210d48d..61aed954f0 100644
--- a/include/mbgl/storage/http_request.hpp
+++ b/include/mbgl/storage/http_request.hpp
@@ -22,6 +22,8 @@ public:
     HTTPRequest(ResourceType type, const std::string &path, uv_loop_t *loop, util::ptr<SQLiteStore> store);
     ~HTTPRequest();
 
+    void cancel();
+
 private:
     void loadedCacheEntry(std::unique_ptr<Response> &&response);
 
@@ -31,6 +33,8 @@ private:
     HTTPRequestBaton *http_baton = nullptr;
     util::ptr<SQLiteStore> store;
     const ResourceType type;
+
+    friend struct HTTPRequestBaton;
 };
 
 }
diff --git a/include/mbgl/storage/http_request_baton.hpp b/include/mbgl/storage/http_request_baton.hpp
index 5f06a68cd1..47e75a203b 100644
--- a/include/mbgl/storage/http_request_baton.hpp
+++ b/include/mbgl/storage/http_request_baton.hpp
@@ -6,21 +6,83 @@
 #include <string>
 
 typedef struct uv_async_s uv_async_t;
+typedef struct uv_timer_s uv_timer_t;
 
 namespace mbgl {
 
 class HTTPRequest;
 
+enum class HTTPResponseType : int8_t {
+    // This error probably won't be resolved by retrying anytime soon. We are giving up.
+    PermanentError = -5,
+
+    // This error might be resolved by waiting some time (e.g. server issues).
+    // We are going to do an exponential back-off and will try again in a few seconds.
+    TemporaryError = -4,
+
+    // This error was caused by a temporary error and it is likely that it will be resolved
+    // immediately. We are going to try again right away. This is like the TemporaryError, except
+    // that we will not perform exponential back-off.
+    SingularError = -3,
+
+    // This error might be resolved once the network reachability status changes.
+    // We are going to watch the network status for changes and will retry as soon as the operating
+    // system notifies us of a network status change.
+    ConnectionError = -2,
+
+    // The request was canceled programatically.
+    Canceled = -1,
+
+    // The request is still in progress.
+    Unknown = 0,
+
+    // The request returned data successfully. We retrieved and decoded the data successfully.
+    Successful = 1,
+
+    // The request confirmed that the data wasn't changed. We already have the data.
+    NotModified = 2,
+};
+
 struct HTTPRequestBaton {
+    HTTPRequestBaton();
+    ~HTTPRequestBaton();
+
+
+    const unsigned long thread_id;
     HTTPRequest *request = nullptr;
     std::string path;
     uv_async_t *async = nullptr;
+    uv_timer_t *timer = nullptr;
     std::unique_ptr<Response> response;
     void *ptr = nullptr;
-    bool not_modified = false;
+    HTTPResponseType type = HTTPResponseType::Unknown;
+    uint8_t attempts = 0;
+
+    // IMPLEMENT THESE 3 PLATFORM SPECIFIC FUNCTIONS:
 
+    // Begin the HTTP request. Platform-specific implementation.
     void start();
+
+    // This will be called so that the baton can release resources. It is expected that the ptr is
+    // null after this call. Platform-specific implementation.
+    void cleanup();
+
+    // This will be called to cancel the HTTP request (if possible). Platform-specific implementation.
     void cancel();
+
+
+
+    // Called when the request should be canceled. This will call cancel() in turn.
+    void stop();
+
+    // After calling reset(), it is safe to call start() again on this baton object.
+    void reset();
+
+    // Will call start() after the specified timeout.
+    void retry(uint64_t delay);
+
+    // Will be
+    static void notify(uv_async_t *async);
 };
 
 }
diff --git a/include/mbgl/storage/response.hpp b/include/mbgl/storage/response.hpp
index 4960173f9e..8125656d81 100644
--- a/include/mbgl/storage/response.hpp
+++ b/include/mbgl/storage/response.hpp
@@ -6,6 +6,8 @@
 
 namespace mbgl {
 
+
+
 class Response {
 public:
     long code = 0;
diff --git a/include/mbgl/util/uv.hpp b/include/mbgl/util/uv.hpp
index 80fff9c96f..3c533cfbf8 100644
--- a/include/mbgl/util/uv.hpp
+++ b/include/mbgl/util/uv.hpp
@@ -4,6 +4,7 @@
 #include <string>
 
 typedef struct uv_async_s uv_async_t;
+typedef struct uv_timer_s uv_timer_t;
 typedef struct uv_handle_s uv_handle_t;
 typedef struct uv_loop_s uv_loop_t;
 
@@ -11,6 +12,11 @@ namespace uv {
 
 std::string cwd();
 
+struct deleter {
+    void operator()(uv_async_t *async);
+    void operator()(uv_timer_t *timer);
+};
+
 class thread;
 class rwlock;
 class loop;
-- 
cgit v1.2.1


From 0fc1f6686886e1122757d5cee17e401ece8178bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Tue, 23 Sep 2014 15:03:39 +0200
Subject: whitespace fixes

---
 include/mbgl/storage/http_request_baton.hpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'include')

diff --git a/include/mbgl/storage/http_request_baton.hpp b/include/mbgl/storage/http_request_baton.hpp
index 47e75a203b..b492ee0c75 100644
--- a/include/mbgl/storage/http_request_baton.hpp
+++ b/include/mbgl/storage/http_request_baton.hpp
@@ -47,7 +47,6 @@ struct HTTPRequestBaton {
     HTTPRequestBaton();
     ~HTTPRequestBaton();
 
-
     const unsigned long thread_id;
     HTTPRequest *request = nullptr;
     std::string path;
-- 
cgit v1.2.1


From 992d9ff051ecd45f83160930c43c9d5a2da04048 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Wed, 24 Sep 2014 16:09:26 +0200
Subject: add back CURL requesting

---
 include/mbgl/storage/http_request.hpp       | 14 +++++++++--
 include/mbgl/storage/http_request_baton.hpp | 38 +++++++++--------------------
 2 files changed, 23 insertions(+), 29 deletions(-)

(limited to 'include')

diff --git a/include/mbgl/storage/http_request.hpp b/include/mbgl/storage/http_request.hpp
index 61aed954f0..9edefcaaae 100644
--- a/include/mbgl/storage/http_request.hpp
+++ b/include/mbgl/storage/http_request.hpp
@@ -3,12 +3,14 @@
 
 #include <mbgl/storage/resource_type.hpp>
 #include <mbgl/storage/base_request.hpp>
+#include <mbgl/storage/http_request_baton.hpp>
 
 #include <string>
 #include <memory>
 #include <cassert>
 
 typedef struct uv_loop_s uv_loop_t;
+typedef struct uv_timer_s uv_timer_t;
 
 namespace mbgl {
 
@@ -25,14 +27,22 @@ public:
     void cancel();
 
 private:
-    void loadedCacheEntry(std::unique_ptr<Response> &&response);
+    void handleCacheResponse(std::unique_ptr<Response> &&response, uv_loop_t *loop);
+    void handleHTTPResponse(HTTPResponseType responseType, std::unique_ptr<Response> &&response, uv_loop_t *loop);
+
+    void startRequest(uv_loop_t *loop);
+
+    void removeCacheBaton();
+    void removeHTTPBaton();
 
 private:
     const unsigned long thread_id;
     CacheRequestBaton *cache_baton = nullptr;
-    HTTPRequestBaton *http_baton = nullptr;
+    util::ptr<HTTPRequestBaton> http_baton;
+    uv_timer_t *backoff_timer = nullptr;
     util::ptr<SQLiteStore> store;
     const ResourceType type;
+    uint8_t attempts = 0;
 
     friend struct HTTPRequestBaton;
 };
diff --git a/include/mbgl/storage/http_request_baton.hpp b/include/mbgl/storage/http_request_baton.hpp
index b492ee0c75..279784ec25 100644
--- a/include/mbgl/storage/http_request_baton.hpp
+++ b/include/mbgl/storage/http_request_baton.hpp
@@ -2,11 +2,11 @@
 #define MBGL_STORAGE_HTTP_REQUEST_BATON
 
 #include <mbgl/storage/response.hpp>
+#include <mbgl/util/ptr.hpp>
 
 #include <string>
 
 typedef struct uv_async_s uv_async_t;
-typedef struct uv_timer_s uv_timer_t;
 
 namespace mbgl {
 
@@ -44,44 +44,28 @@ enum class HTTPResponseType : int8_t {
 };
 
 struct HTTPRequestBaton {
-    HTTPRequestBaton();
+    HTTPRequestBaton(const std::string &path);
     ~HTTPRequestBaton();
 
     const unsigned long thread_id;
+    const std::string path;
+
     HTTPRequest *request = nullptr;
-    std::string path;
     uv_async_t *async = nullptr;
-    uv_timer_t *timer = nullptr;
+
+    HTTPResponseType type = HTTPResponseType::Unknown;
     std::unique_ptr<Response> response;
+
+    // Implementation specific use.
     void *ptr = nullptr;
-    HTTPResponseType type = HTTPResponseType::Unknown;
-    uint8_t attempts = 0;
 
     // IMPLEMENT THESE 3 PLATFORM SPECIFIC FUNCTIONS:
 
     // Begin the HTTP request. Platform-specific implementation.
-    void start();
-
-    // This will be called so that the baton can release resources. It is expected that the ptr is
-    // null after this call. Platform-specific implementation.
-    void cleanup();
-
-    // This will be called to cancel the HTTP request (if possible). Platform-specific implementation.
-    void cancel();
-
-
-
-    // Called when the request should be canceled. This will call cancel() in turn.
-    void stop();
-
-    // After calling reset(), it is safe to call start() again on this baton object.
-    void reset();
-
-    // Will call start() after the specified timeout.
-    void retry(uint64_t delay);
+    static void start(const util::ptr<HTTPRequestBaton> &ptr);
 
-    // Will be
-    static void notify(uv_async_t *async);
+    // This will be called to stop/cancel the HTTP request (if possible). Platform-specific implementation.
+    static void stop(const util::ptr<HTTPRequestBaton> &ptr);
 };
 
 }
-- 
cgit v1.2.1


From 1209744b38da0252731812d4cc5371be960fb3c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Wed, 24 Sep 2014 17:08:44 +0200
Subject: use the default cache location on ios to avoid writing to unwritable
 file system locations

---
 include/mbgl/platform/platform.hpp   | 3 +++
 include/mbgl/storage/file_source.hpp | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mbgl/platform/platform.hpp b/include/mbgl/platform/platform.hpp
index 6356d81bb1..b7107bb9cd 100644
--- a/include/mbgl/platform/platform.hpp
+++ b/include/mbgl/platform/platform.hpp
@@ -17,6 +17,9 @@ std::string uppercase(const std::string &string);
 // Lowercase a string, potentially using platform-specific routines.
 std::string lowercase(const std::string &string);
 
+// Returns the path to the default cache database on this system.
+std::string defaultCacheDatabase();
+
 // Shows an alpha image with the specified dimensions in a named window.
 void show_debug_image(std::string name, const char *data, size_t width, size_t height);
 
diff --git a/include/mbgl/storage/file_source.hpp b/include/mbgl/storage/file_source.hpp
index 06d416d0c6..5933aea483 100644
--- a/include/mbgl/storage/file_source.hpp
+++ b/include/mbgl/storage/file_source.hpp
@@ -24,7 +24,7 @@ private:
     FileSource& operator=(FileSource &&) = delete;
 
 public:
-    FileSource(uv_loop_t *loop);
+    FileSource(uv_loop_t *loop, const std::string &path);
     ~FileSource();
 
 public:
-- 
cgit v1.2.1


From b9628c86543ffe819b030c3d84f65fa09e084850 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Fri, 26 Sep 2014 16:10:39 +0200
Subject: add etag support and if-none-match/if-modified-since to cocoa http
 handling

---
 include/mbgl/storage/http_request.hpp | 2 +-
 include/mbgl/storage/response.hpp     | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mbgl/storage/http_request.hpp b/include/mbgl/storage/http_request.hpp
index 9edefcaaae..c81e23ef8d 100644
--- a/include/mbgl/storage/http_request.hpp
+++ b/include/mbgl/storage/http_request.hpp
@@ -30,7 +30,7 @@ private:
     void handleCacheResponse(std::unique_ptr<Response> &&response, uv_loop_t *loop);
     void handleHTTPResponse(HTTPResponseType responseType, std::unique_ptr<Response> &&response, uv_loop_t *loop);
 
-    void startRequest(uv_loop_t *loop);
+    void startRequest(std::unique_ptr<Response> &&res, uv_loop_t *loop);
 
     void removeCacheBaton();
     void removeHTTPBaton();
diff --git a/include/mbgl/storage/response.hpp b/include/mbgl/storage/response.hpp
index 8125656d81..9357ad3c63 100644
--- a/include/mbgl/storage/response.hpp
+++ b/include/mbgl/storage/response.hpp
@@ -13,6 +13,7 @@ public:
     long code = 0;
     int64_t modified = 0;
     int64_t expires = 0;
+    std::string etag;
     std::string data;
 
     std::string message;
-- 
cgit v1.2.1


From 46e06bf378e5edc38b5ce1c3ab1e4567eb756d24 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Mon, 29 Sep 2014 12:27:34 +0200
Subject: don't pass the loop through all function calls

---
 include/mbgl/storage/http_request.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'include')

diff --git a/include/mbgl/storage/http_request.hpp b/include/mbgl/storage/http_request.hpp
index c81e23ef8d..4c8d064d65 100644
--- a/include/mbgl/storage/http_request.hpp
+++ b/include/mbgl/storage/http_request.hpp
@@ -27,16 +27,18 @@ public:
     void cancel();
 
 private:
-    void handleCacheResponse(std::unique_ptr<Response> &&response, uv_loop_t *loop);
-    void handleHTTPResponse(HTTPResponseType responseType, std::unique_ptr<Response> &&response, uv_loop_t *loop);
+    void startCacheRequest();
+    void handleCacheResponse(std::unique_ptr<Response> &&response);
+    void startHTTPRequest(std::unique_ptr<Response> &&res);
+    void handleHTTPResponse(HTTPResponseType responseType, std::unique_ptr<Response> &&response);
 
-    void startRequest(std::unique_ptr<Response> &&res, uv_loop_t *loop);
 
     void removeCacheBaton();
     void removeHTTPBaton();
 
 private:
     const unsigned long thread_id;
+    uv_loop_t *const loop;
     CacheRequestBaton *cache_baton = nullptr;
     util::ptr<HTTPRequestBaton> http_baton;
     uv_timer_t *backoff_timer = nullptr;
-- 
cgit v1.2.1


From 135f68e249e4b01df7d9b5387a045bfb91bc4455 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Mon, 29 Sep 2014 13:18:50 +0200
Subject: add retries in case of connection failures

---
 include/mbgl/storage/http_request.hpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'include')

diff --git a/include/mbgl/storage/http_request.hpp b/include/mbgl/storage/http_request.hpp
index 4c8d064d65..05e152aeba 100644
--- a/include/mbgl/storage/http_request.hpp
+++ b/include/mbgl/storage/http_request.hpp
@@ -32,9 +32,11 @@ private:
     void startHTTPRequest(std::unique_ptr<Response> &&res);
     void handleHTTPResponse(HTTPResponseType responseType, std::unique_ptr<Response> &&response);
 
+    void retryHTTPRequest(std::unique_ptr<Response> &&res, uint64_t timeout);
 
     void removeCacheBaton();
     void removeHTTPBaton();
+    void removeBackoffTimer();
 
 private:
     const unsigned long thread_id;
-- 
cgit v1.2.1


From 9e44c0eae8a5e13bfddd00c7888988cb0bfb7c1f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Mon, 29 Sep 2014 14:02:42 +0200
Subject: add reachability

---
 include/mbgl/map/map.hpp              | 3 +++
 include/mbgl/storage/base_request.hpp | 4 ++++
 include/mbgl/storage/file_source.hpp  | 2 ++
 include/mbgl/storage/http_request.hpp | 1 +
 4 files changed, 10 insertions(+)

(limited to 'include')

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 85c9e8e6a5..a69943aa74 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -123,6 +123,9 @@ public:
     void toggleDebug();
     bool getDebug() const;
 
+    // Call this when the network reachability changed.
+    void setReachability(bool status);
+
 public:
     inline const TransformState &getState() const { return state; }
     inline util::ptr<FileSource> getFileSource() const { return fileSource; }
diff --git a/include/mbgl/storage/base_request.hpp b/include/mbgl/storage/base_request.hpp
index e9e6bfcb46..16ff24faa3 100644
--- a/include/mbgl/storage/base_request.hpp
+++ b/include/mbgl/storage/base_request.hpp
@@ -41,6 +41,10 @@ public:
     // This function must call notify().
     virtual void cancel() = 0;
 
+    // This function is called when the request should be reattempted immediately. This is typically
+    // reaction to a network status change.
+    virtual void retryImmediately();
+
 public:
     const unsigned long thread_id;
     const std::string path;
diff --git a/include/mbgl/storage/file_source.hpp b/include/mbgl/storage/file_source.hpp
index 5933aea483..4b17cd29a7 100644
--- a/include/mbgl/storage/file_source.hpp
+++ b/include/mbgl/storage/file_source.hpp
@@ -36,6 +36,8 @@ public:
 
     void prepare(std::function<void()> fn);
 
+    void retryAllPending();
+
 private:
     const unsigned long thread_id;
 
diff --git a/include/mbgl/storage/http_request.hpp b/include/mbgl/storage/http_request.hpp
index 05e152aeba..ec76f1147c 100644
--- a/include/mbgl/storage/http_request.hpp
+++ b/include/mbgl/storage/http_request.hpp
@@ -25,6 +25,7 @@ public:
     ~HTTPRequest();
 
     void cancel();
+    void retryImmediately();
 
 private:
     void startCacheRequest();
-- 
cgit v1.2.1


From a9039cf5d75f4da667d9279d61f7549c43f7ea51 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Tue, 30 Sep 2014 10:46:53 +0200
Subject: move file request baton to its own file

---
 include/mbgl/storage/file_request_baton.hpp | 35 +++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 include/mbgl/storage/file_request_baton.hpp

(limited to 'include')

diff --git a/include/mbgl/storage/file_request_baton.hpp b/include/mbgl/storage/file_request_baton.hpp
new file mode 100644
index 0000000000..0f1968ca13
--- /dev/null
+++ b/include/mbgl/storage/file_request_baton.hpp
@@ -0,0 +1,35 @@
+#ifndef MBGL_STORAGE_FILE_REQUEST_BATON
+#define MBGL_STORAGE_FILE_REQUEST_BATON
+
+#include <mbgl/storage/file_request.hpp>
+
+#include <uv.h>
+
+namespace mbgl {
+
+struct FileRequestBaton {
+    FileRequestBaton(FileRequest *request_, const std::string &path, uv_loop_t *loop);
+    ~FileRequestBaton();
+
+    void cancel();
+    static void file_opened(uv_fs_t *req);
+    static void file_stated(uv_fs_t *req);
+    static void file_read(uv_fs_t *req);
+    static void file_closed(uv_fs_t *req);
+    static void notify_error(uv_fs_t *req);
+    static void cleanup(uv_fs_t *req);
+
+    const unsigned long thread_id;
+    FileRequest *request = nullptr;
+    uv_fs_t req;
+    uv_file fd = -1;
+    bool canceled = false;
+    std::string body;
+    uv_buf_t buffer;
+};
+
+
+}
+
+
+#endif
-- 
cgit v1.2.1


From 8fcc74e2531f53b6e09584fb58022f852a32b26c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Tue, 30 Sep 2014 17:28:42 +0200
Subject: fix headless tests

---
 include/mbgl/map/tile_data.hpp | 2 +-
 include/mbgl/util/uv-worker.h  | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

(limited to 'include')

diff --git a/include/mbgl/map/tile_data.hpp b/include/mbgl/map/tile_data.hpp
index 07cf19c5c8..823523679a 100644
--- a/include/mbgl/map/tile_data.hpp
+++ b/include/mbgl/map/tile_data.hpp
@@ -41,7 +41,7 @@ public:
 
 public:
     TileData(Tile::ID id, Map &map, const util::ptr<SourceInfo> &source);
-    ~TileData();
+    virtual ~TileData();
 
     void request();
     void cancel();
diff --git a/include/mbgl/util/uv-worker.h b/include/mbgl/util/uv-worker.h
index a9c9aff500..eff1169a2b 100644
--- a/include/mbgl/util/uv-worker.h
+++ b/include/mbgl/util/uv-worker.h
@@ -21,11 +21,13 @@ struct uv_worker_s {
 #ifndef NDEBUG
     unsigned long thread_id;
 #endif
+    uv_loop_t *loop;
     uv_messenger_t *msgr;
     uv_chan_t chan;
     const char *name;
     int count;
     uv_worker_close_cb close_cb;
+    int active;
 };
 
 int uv_worker_init(uv_worker_t *worker, uv_loop_t *loop, int count, const char *name);
-- 
cgit v1.2.1


From d03b7aa31ad95827672208ab363d50666b2762b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Wed, 1 Oct 2014 13:26:49 +0200
Subject: properly ref/unref the handle and run the loop again for shutdown
 purposes

---
 include/mbgl/map/tile_data.hpp   | 2 +-
 include/mbgl/util/uv-messenger.h | 1 +
 include/mbgl/util/uv-worker.h    | 2 +-
 3 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'include')

diff --git a/include/mbgl/map/tile_data.hpp b/include/mbgl/map/tile_data.hpp
index 823523679a..07cf19c5c8 100644
--- a/include/mbgl/map/tile_data.hpp
+++ b/include/mbgl/map/tile_data.hpp
@@ -41,7 +41,7 @@ public:
 
 public:
     TileData(Tile::ID id, Map &map, const util::ptr<SourceInfo> &source);
-    virtual ~TileData();
+    ~TileData();
 
     void request();
     void cancel();
diff --git a/include/mbgl/util/uv-messenger.h b/include/mbgl/util/uv-messenger.h
index b082466b60..82b8ef2d9c 100644
--- a/include/mbgl/util/uv-messenger.h
+++ b/include/mbgl/util/uv-messenger.h
@@ -22,6 +22,7 @@ struct uv_messenger_s {
 int uv_messenger_init(uv_loop_t *loop, uv_messenger_t *msgr, uv_messenger_cb callback);
 void uv_messenger_send(uv_messenger_t *msgr, void *arg);
 void uv_messenger_stop(uv_messenger_t *msgr);
+void uv_messenger_ref(uv_messenger_t *msgr);
 void uv_messenger_unref(uv_messenger_t *msgr);
 
 #ifdef __cplusplus
diff --git a/include/mbgl/util/uv-worker.h b/include/mbgl/util/uv-worker.h
index eff1169a2b..451b6fb04d 100644
--- a/include/mbgl/util/uv-worker.h
+++ b/include/mbgl/util/uv-worker.h
@@ -27,7 +27,7 @@ struct uv_worker_s {
     const char *name;
     int count;
     uv_worker_close_cb close_cb;
-    int active;
+    unsigned int active_items;
 };
 
 int uv_worker_init(uv_worker_t *worker, uv_loop_t *loop, int count, const char *name);
-- 
cgit v1.2.1


From 6b1a86c37c26434442cc52d47ba554b5cb308e32 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Konstantin=20Ka=CC=88fer?= <mail@kkaefer.com>
Date: Wed, 1 Oct 2014 05:20:12 -0700
Subject: fix gcc cannot call member function without object error

---
 include/mbgl/util/ptr.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'include')

diff --git a/include/mbgl/util/ptr.hpp b/include/mbgl/util/ptr.hpp
index 5511083fc6..6e02f956f3 100644
--- a/include/mbgl/util/ptr.hpp
+++ b/include/mbgl/util/ptr.hpp
@@ -14,11 +14,11 @@ public:
     inline ptr(Args &&... args)
         : ::std::shared_ptr<T>(::std::forward<Args>(args)...) {}
 
-    inline auto operator->() const -> decltype(::std::shared_ptr<T>::operator->()) {
+    inline auto operator->() const -> decltype(this->::std::shared_ptr<T>::operator->()) {
         assert(*this);
         return ::std::shared_ptr<T>::operator->();
     }
-    inline auto operator*() const -> decltype(::std::shared_ptr<T>::operator*()) {
+    inline auto operator*() const -> decltype(this->::std::shared_ptr<T>::operator*()) {
         assert(*this);
         return ::std::shared_ptr<T>::operator*();
     }
-- 
cgit v1.2.1