[core] Merge Sprite into SpriteStore

5 files changed, 148 insertions, 187 deletions

diff --git a/src/mbgl/sprite/sprite.cpp b/src/mbgl/sprite/sprite.cpp
deleted file mode 100644
index 881a6ff8ed..0000000000
--- a/src/mbgl/sprite/sprite.cpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#include <mbgl/sprite/sprite.hpp>
-#include <mbgl/platform/log.hpp>
-#include <mbgl/platform/platform.hpp>
-#include <mbgl/storage/file_source.hpp>
-#include <mbgl/storage/resource.hpp>
-#include <mbgl/storage/response.hpp>
-#include <mbgl/storage/request_holder.hpp>
-#include <mbgl/util/exception.hpp>
-#include <mbgl/util/raster.hpp>
-#include <mbgl/util/thread.hpp>
-#include <mbgl/util/uv_detail.hpp>
-#include <mbgl/util/mapbox.hpp>
-
-#include <rapidjson/document.h>
-
-#include <string>
-#include <sstream>
-
-namespace mbgl {
-
-struct Sprite::Loader {
-    std::shared_ptr<const std::string> image;
-    std::shared_ptr<const std::string> json;
-    RequestHolder jsonRequest;
-    RequestHolder spriteRequest;
-};
-
-Sprite::Sprite(const std::string& baseUrl, float pixelRatio_)
-    : pixelRatio(pixelRatio_ > 1 ? 2 : 1) {
-    if (baseUrl.empty()) {
-        // Treat a non-existent sprite as a successfully loaded empty sprite.
-        loaded = true;
-        return;
-    }
-
-    std::string spriteURL(baseUrl + (pixelRatio_ > 1 ? "@2x" : "") + ".png");
-    std::string jsonURL(baseUrl + (pixelRatio_ > 1 ? "@2x" : "") + ".json");
-
-    loader = std::make_unique<Loader>();
-
-    FileSource* fs = util::ThreadContext::getFileSource();
-    loader->jsonRequest = fs->request({ Resource::Kind::SpriteJSON, jsonURL }, util::RunLoop::getLoop(),
-                                      [this, jsonURL](const Response& res) {
-        if (res.stale) {
-            // Only handle fresh responses.
-            return;
-        }
-        loader->jsonRequest = nullptr;
-
-        if (res.error) {
-            std::stringstream message;
-            message << "Failed to load [" << jsonURL << "]: " << res.error->message;
-            emitSpriteLoadingFailed(message.str());
-            return;
-        } else {
-            loader->json = res.data;
-        }
-        emitSpriteLoadedIfComplete();
-    });
-
-    loader->spriteRequest =
-        fs->request({ Resource::Kind::SpriteImage, spriteURL }, util::RunLoop::getLoop(),
-                    [this, spriteURL](const Response& res) {
-            if (res.stale) {
-                // Only handle fresh responses.
-                return;
-            }
-            loader->spriteRequest = nullptr;
-
-            if (res.error) {
-                std::stringstream message;
-                message << "Failed to load [" << spriteURL << "]: " << res.error->message;
-                emitSpriteLoadingFailed(message.str());
-                return;
-            } else {
-                loader->image = res.data;
-            }
-            emitSpriteLoadedIfComplete();
-        });
-}
-
-Sprite::~Sprite() {
-}
-
-void Sprite::emitSpriteLoadedIfComplete() {
-    assert(loader);
-
-    if (!loader->image || !loader->json || !observer) {
-        return;
-    }
-
-    auto local = std::move(loader);
-    auto result = parseSprite(*local->image, *local->json);
-    if (result.is<Sprites>()) {
-        loaded = true;
-        observer->onSpriteLoaded(result.get<Sprites>());
-    } else {
-        emitSpriteLoadingFailed(result.get<std::string>());
-    }
-}
-
-void Sprite::emitSpriteLoadingFailed(const std::string& message) {
-    if (!observer) {
-        return;
-    }
-
-    auto error = std::make_exception_ptr(util::SpriteLoadingException(message));
-    observer->onSpriteLoadingFailed(error);
-}
-
-void Sprite::setObserver(Observer* observer_) {
-    observer = observer_;
-}
-
-void Sprite::dumpDebugLogs() const {
-    Log::Info(Event::General, "Sprite::loaded: %d", loaded);
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/sprite/sprite.hpp b/src/mbgl/sprite/sprite.hpp
deleted file mode 100644
index d204b42e85..0000000000
--- a/src/mbgl/sprite/sprite.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef MBGL_SPRITE
-#define MBGL_SPRITE
-
-#include <mbgl/sprite/sprite_parser.hpp>
-#include <mbgl/util/image.hpp>
-#include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/ptr.hpp>
-#include <mbgl/storage/request.hpp>
-
-#include <cstdint>
-#include <atomic>
-#include <iosfwd>
-#include <string>
-#include <unordered_map>
-
-namespace mbgl {
-
-class Request;
-
-class Sprite : private util::noncopyable {
-public:
-    class Observer {
-    public:
-        virtual ~Observer() = default;
-
-        virtual void onSpriteLoaded(const Sprites& sprites) = 0;
-        virtual void onSpriteLoadingFailed(std::exception_ptr error) = 0;
-    };
-
-    Sprite(const std::string& baseUrl, float pixelRatio);
-    ~Sprite();
-
-    inline bool isLoaded() const {
-        return loaded;
-    }
-
-    void dumpDebugLogs() const;
-
-    const float pixelRatio;
-
-    void setObserver(Observer* observer);
-
-private:
-    void emitSpriteLoadedIfComplete();
-    void emitSpriteLoadingFailed(const std::string& message);
-
-    struct Loader;
-    std::unique_ptr<Loader> loader;
-
-    bool loaded = false;
-
-    Observer* observer = nullptr;
-};
-
-} // namespace mbgl
-
-#endif
diff --git a/src/mbgl/sprite/sprite_atlas.cpp b/src/mbgl/sprite/sprite_atlas.cpp
index 22c2ba8b95..45b0511c68 100644
--- a/src/mbgl/sprite/sprite_atlas.cpp
+++ b/src/mbgl/sprite/sprite_atlas.cpp
@@ -10,13 +10,10 @@
 #include <mbgl/util/scaling.hpp>
 #include <mbgl/util/thread_context.hpp>
 
-#include <mbgl/sprite/sprite.hpp>
-
 #include <cassert>
 #include <cmath>
 #include <algorithm>
 
-
 using namespace mbgl;
 
 SpriteAtlas::SpriteAtlas(dimension width_, dimension height_, float pixelRatio_, SpriteStore& store_)
diff --git a/src/mbgl/sprite/sprite_store.cpp b/src/mbgl/sprite/sprite_store.cpp
index fb6833114e..27b33e51e3 100644
--- a/src/mbgl/sprite/sprite_store.cpp
+++ b/src/mbgl/sprite/sprite_store.cpp
@@ -1,9 +1,122 @@
 #include <mbgl/sprite/sprite_store.hpp>
-
+#include <mbgl/sprite/sprite_parser.hpp>
 #include <mbgl/platform/log.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/storage/resource.hpp>
+#include <mbgl/storage/response.hpp>
+#include <mbgl/storage/request_holder.hpp>
+#include <mbgl/util/exception.hpp>
+#include <mbgl/util/thread_context.hpp>
+#include <mbgl/util/run_loop.hpp>
+
+#include <string>
+#include <sstream>
 
 namespace mbgl {
 
+struct SpriteStore::Loader {
+    std::shared_ptr<const std::string> image;
+    std::shared_ptr<const std::string> json;
+    RequestHolder jsonRequest;
+    RequestHolder spriteRequest;
+};
+
+SpriteStore::SpriteStore(float pixelRatio_)
+    : pixelRatio(pixelRatio_ > 1 ? 2 : 1) {
+}
+
+SpriteStore::~SpriteStore() = default;
+
+void SpriteStore::setURL(const std::string& url) {
+    if (url.empty()) {
+        // Treat a non-existent sprite as a successfully loaded empty sprite.
+        loaded = true;
+        return;
+    }
+
+    std::string spriteURL(url + (pixelRatio > 1 ? "@2x" : "") + ".png");
+    std::string jsonURL(url + (pixelRatio > 1 ? "@2x" : "") + ".json");
+
+    loader = std::make_unique<Loader>();
+
+    FileSource* fs = util::ThreadContext::getFileSource();
+    loader->jsonRequest = fs->request({ Resource::Kind::SpriteJSON, jsonURL }, util::RunLoop::getLoop(),
+                                      [this, jsonURL](const Response& res) {
+        if (res.stale) {
+            // Only handle fresh responses.
+            return;
+        }
+        loader->jsonRequest = nullptr;
+
+        if (res.error) {
+            std::stringstream message;
+            message << "Failed to load [" << jsonURL << "]: " << res.error->message;
+            emitSpriteLoadingFailed(message.str());
+            return;
+        } else {
+            loader->json = res.data;
+        }
+        emitSpriteLoadedIfComplete();
+    });
+
+    loader->spriteRequest =
+        fs->request({ Resource::Kind::SpriteImage, spriteURL }, util::RunLoop::getLoop(),
+                    [this, spriteURL](const Response& res) {
+            if (res.stale) {
+                // Only handle fresh responses.
+                return;
+            }
+            loader->spriteRequest = nullptr;
+
+            if (res.error) {
+                std::stringstream message;
+                message << "Failed to load [" << spriteURL << "]: " << res.error->message;
+                emitSpriteLoadingFailed(message.str());
+                return;
+            } else {
+                loader->image = res.data;
+            }
+            emitSpriteLoadedIfComplete();
+        });
+}
+
+void SpriteStore::emitSpriteLoadedIfComplete() {
+    assert(loader);
+
+    if (!loader->image || !loader->json) {
+        return;
+    }
+
+    auto local = std::move(loader);
+    auto result = parseSprite(*local->image, *local->json);
+    if (result.is<Sprites>()) {
+        loaded = true;
+        setSprites(result.get<Sprites>());
+        if (observer) {
+            observer->onSpriteLoaded();
+        }
+    } else {
+        emitSpriteLoadingFailed(result.get<std::string>());
+    }
+}
+
+void SpriteStore::emitSpriteLoadingFailed(const std::string& message) {
+    if (!observer) {
+        return;
+    }
+
+    auto error = std::make_exception_ptr(util::SpriteLoadingException(message));
+    observer->onSpriteLoadingFailed(error);
+}
+
+void SpriteStore::setObserver(Observer* observer_) {
+    observer = observer_;
+}
+
+void SpriteStore::dumpDebugLogs() const {
+    Log::Info(Event::General, "SpriteStore::loaded: %d", loaded);
+}
+
 void SpriteStore::setSprite(const std::string& name, std::shared_ptr<const SpriteImage> sprite) {
     std::lock_guard<std::mutex> lock(mutex);
     _setSprite(name, sprite);
diff --git a/src/mbgl/sprite/sprite_store.hpp b/src/mbgl/sprite/sprite_store.hpp
index ed903f074b..98b43ac8e4 100644
--- a/src/mbgl/sprite/sprite_store.hpp
+++ b/src/mbgl/sprite/sprite_store.hpp
@@ -2,24 +2,39 @@
 #define MBGL_SPRITE_STORE
 
 #include <mbgl/sprite/sprite_image.hpp>
-
 #include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/geo.hpp>
 
 #include <map>
-#include <set>
-#include <vector>
 #include <memory>
 #include <mutex>
-#include <cstdint>
 
 namespace mbgl {
 
-// The SpriteStore object holds Sprite images.
 class SpriteStore : private util::noncopyable {
+public:
     using Sprites = std::map<std::string, std::shared_ptr<const SpriteImage>>;
 
-public:
+    class Observer {
+    public:
+        virtual ~Observer() = default;
+
+        virtual void onSpriteLoaded() = 0;
+        virtual void onSpriteLoadingFailed(std::exception_ptr) = 0;
+    };
+
+    SpriteStore(float pixelRatio);
+    ~SpriteStore();
+
+    void setURL(const std::string&);
+
+    bool isLoaded() const {
+        return loaded;
+    }
+
+    void dumpDebugLogs() const;
+
+    void setObserver(Observer* observer);
+
     // Adds/replaces a Sprite image.
     void setSprite(const std::string&, std::shared_ptr<const SpriteImage> = nullptr);
 
@@ -35,9 +50,21 @@ public:
     // Returns Sprite images that changed since the last invocation of this function.
     Sprites getDirty();
 
+    const float pixelRatio;
+
 private:
     void _setSprite(const std::string&, const std::shared_ptr<const SpriteImage>& = nullptr);
 
+    void emitSpriteLoadedIfComplete();
+    void emitSpriteLoadingFailed(const std::string& message);
+
+    struct Loader;
+    std::unique_ptr<Loader> loader;
+
+    bool loaded = false;
+
+    Observer* observer = nullptr;
+
     // Lock for sprites and dirty maps.
     std::mutex mutex;