[core] introduce TileDataObserver

avoids passing around bound callback functions

2 files changed, 24 insertions, 31 deletions

diff --git a/src/mbgl/style/source.cpp b/src/mbgl/style/source.cpp
index 51e6334440..a31c804b01 100644
--- a/src/mbgl/style/source.cpp
+++ b/src/mbgl/style/source.cpp
@@ -197,9 +197,6 @@ std::unique_ptr<TileData> Source::createTile(const OverscaledTileID& overscaledT
         return data;
     }
 
-    auto callback = std::bind(&Source::tileLoadingCallback, this, overscaledTileID,
-                              std::placeholders::_1, true);
-
     // If we don't find working tile data, we're just going to load it.
     if (type == SourceType::Raster) {
         assert(!tileset->tiles.empty());
@@ -207,7 +204,8 @@ std::unique_ptr<TileData> Source::createTile(const OverscaledTileID& overscaledT
             tileset->tiles.at(0), parameters.pixelRatio, overscaledTileID.canonical.x,
             overscaledTileID.canonical.y, overscaledTileID.canonical.z);
         auto data = std::make_unique<RasterTileData>(overscaledTileID, parameters.texturePool,
-                                                     parameters.worker, callback);
+                                                     parameters.worker);
+        data->setObserver(this);
         data->setTileSource(
             std::make_unique<ImageTileSource>(*data, resource, parameters.fileSource));
 
@@ -216,7 +214,8 @@ std::unique_ptr<TileData> Source::createTile(const OverscaledTileID& overscaledT
         return std::move(data);
     } else {
         auto data = std::make_unique<GeometryTileData>(overscaledTileID, id, parameters.style,
-                                                       parameters.mode, callback);
+                                                       parameters.mode);
+        data->setObserver(this);
         if (type == SourceType::Vector) {
             assert(!tileset->tiles.empty());
             const auto resource = Resource::tile(
@@ -327,6 +326,9 @@ bool Source::update(const UpdateParameters& parameters) {
         }
     }
 
+    const PlacementConfig newConfig{ parameters.transformState.getAngle(),
+                                     parameters.transformState.getPitch(),
+                                     parameters.debugOptions & MapDebugOptions::Collision };
     for (auto& pair : tileDataMap) {
         auto tileData = pair.second.get();
         if (parameters.shouldReparsePartialTiles && tileData->isIncomplete()) {
@@ -334,10 +336,7 @@ bool Source::update(const UpdateParameters& parameters) {
                 allTilesUpdated = false;
             }
         } else {
-            tileData->redoPlacement({ parameters.transformState.getAngle(),
-                                      parameters.transformState.getPitch(),
-                                      parameters.debugOptions & MapDebugOptions::Collision },
-                                    [this]() { observer->onPlacementRedone(); });
+            tileData->redoPlacement(newConfig);
         }
     }
 
@@ -406,28 +405,17 @@ void Source::setObserver(SourceObserver* observer_) {
     observer = observer_;
 }
 
-void Source::tileLoadingCallback(const OverscaledTileID& tileID,
-                                 std::exception_ptr error,
-                                 bool isNewTile) {
-    auto it = tileDataMap.find(tileID);
-    if (it == tileDataMap.end()) {
-        return;
-    }
-
-    auto& tileData = it->second;
-    if (!tileData) {
-        return;
-    }
+void Source::onTileLoaded(TileData& tileData, bool isNewTile) {
+    tileData.redoPlacement();
+    observer->onTileLoaded(*this, tileData.id, isNewTile);
+}
 
-    if (error) {
-        observer->onTileError(*this, tileID, error);
-        return;
-    }
+void Source::onTileError(TileData& tileData, std::exception_ptr error) {
+    observer->onTileError(*this, tileData.id, error);
+}
 
-    tileData->redoPlacement([this]() {
-        observer->onPlacementRedone();
-    });
-    observer->onTileLoaded(*this, tileID, isNewTile);
+void Source::onPlacementRedone(TileData&) {
+    observer->onPlacementRedone();
 }
 
 void Source::dumpDebugLogs() const {
diff --git a/src/mbgl/style/source.hpp b/src/mbgl/style/source.hpp
index 07e1aeaf58..4eae37a2a4 100644
--- a/src/mbgl/style/source.hpp
+++ b/src/mbgl/style/source.hpp
@@ -1,10 +1,12 @@
 #pragma once
 
 #include <mbgl/tile/tile_id.hpp>
+#include <mbgl/tile/tile_data_observer.hpp>
 #include <mbgl/tile/tile_data.hpp>
 #include <mbgl/tile/tile_cache.hpp>
 #include <mbgl/style/types.hpp>
 
+#include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/rapidjson.hpp>
 #include <mbgl/util/feature.hpp>
@@ -36,7 +38,7 @@ class UpdateParameters;
 class QueryParameters;
 class SourceObserver;
 
-class Source : private util::noncopyable {
+class Source : public TileDataObserver, private util::noncopyable {
 public:
     Source(SourceType,
            const std::string& id,
@@ -87,7 +89,10 @@ public:
     bool enabled = false;
 
 private:
-    void tileLoadingCallback(const OverscaledTileID&, std::exception_ptr, bool isNewTile);
+    // TileDataObserver implementation.
+    void onTileLoaded(TileData&, bool isNewTile) override;
+    void onTileError(TileData&, std::exception_ptr) override;
+    void onPlacementRedone(TileData&) override;
 
     std::unique_ptr<TileData> createTile(const OverscaledTileID&, const UpdateParameters&);