[core] move correlationID to separate parameter and add to RasterTile

10 files changed, 54 insertions, 54 deletions

diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
index 33911df9ed..fdbad8bd40 100644
--- a/src/mbgl/tile/geometry_tile.cpp
+++ b/src/mbgl/tile/geometry_tile.cpp
@@ -120,20 +120,21 @@ void GeometryTile::setLayers(const std::vector<Immutable<Layer::Impl>>& layers)
     worker.invoke(&GeometryTileWorker::setLayers, std::move(impls), correlationID);
 }
 
-void GeometryTile::onLayout(LayoutResult result) {
+void GeometryTile::onLayout(LayoutResult result, const uint64_t resultCorrelationID) {
     loaded = true;
     renderable = true;
     nonSymbolBuckets = std::move(result.nonSymbolBuckets);
     featureIndex = std::move(result.featureIndex);
     data = std::move(result.tileData);
     collisionTile.reset();
+    (void)resultCorrelationID;
     observer->onTileChanged(*this);
 }
 
-void GeometryTile::onPlacement(PlacementResult result) {
+void GeometryTile::onPlacement(PlacementResult result, const uint64_t resultCorrelationID) {
     loaded = true;
     renderable = true;
-    if (result.correlationID == correlationID) {
+    if (resultCorrelationID == correlationID) {
         pending = false;
     }
     symbolBuckets = std::move(result.symbolBuckets);
@@ -150,9 +151,10 @@ void GeometryTile::onPlacement(PlacementResult result) {
     observer->onTileChanged(*this);
 }
 
-void GeometryTile::onError(std::exception_ptr err) {
+void GeometryTile::onError(std::exception_ptr err, const uint64_t resultCorrelationID) {
     loaded = true;
     pending = false;
+    (void)resultCorrelationID;
     renderable = false;
     observer->onTileError(*this, err);
 }
diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp
index c45762742b..7088637a30 100644
--- a/src/mbgl/tile/geometry_tile.hpp
+++ b/src/mbgl/tile/geometry_tile.hpp
@@ -70,18 +70,15 @@ public:
         std::unordered_map<std::string, std::shared_ptr<Bucket>> nonSymbolBuckets;
         std::unique_ptr<FeatureIndex> featureIndex;
         std::unique_ptr<GeometryTileData> tileData;
-        uint64_t correlationID;
 
         LayoutResult(std::unordered_map<std::string, std::shared_ptr<Bucket>> nonSymbolBuckets_,
                      std::unique_ptr<FeatureIndex> featureIndex_,
-                     std::unique_ptr<GeometryTileData> tileData_,
-                     uint64_t correlationID_)
+                     std::unique_ptr<GeometryTileData> tileData_)
             : nonSymbolBuckets(std::move(nonSymbolBuckets_)),
               featureIndex(std::move(featureIndex_)),
-              tileData(std::move(tileData_)),
-              correlationID(correlationID_) {}
+              tileData(std::move(tileData_)) {}
     };
-    void onLayout(LayoutResult);
+    void onLayout(LayoutResult, uint64_t resultCorrelationID);
 
     class PlacementResult {
     public:
@@ -89,22 +86,19 @@ public:
         std::unique_ptr<CollisionTile> collisionTile;
         optional<AlphaImage> glyphAtlasImage;
         optional<PremultipliedImage> iconAtlasImage;
-        uint64_t correlationID;
 
         PlacementResult(std::unordered_map<std::string, std::shared_ptr<Bucket>> symbolBuckets_,
                         std::unique_ptr<CollisionTile> collisionTile_,
                         optional<AlphaImage> glyphAtlasImage_,
-                        optional<PremultipliedImage> iconAtlasImage_,
-                        uint64_t correlationID_)
+                        optional<PremultipliedImage> iconAtlasImage_)
             : symbolBuckets(std::move(symbolBuckets_)),
               collisionTile(std::move(collisionTile_)),
               glyphAtlasImage(std::move(glyphAtlasImage_)),
-              iconAtlasImage(std::move(iconAtlasImage_)),
-              correlationID(correlationID_) {}
+              iconAtlasImage(std::move(iconAtlasImage_)) {}
     };
-    void onPlacement(PlacementResult);
+    void onPlacement(PlacementResult, uint64_t resultCorrelationID);
 
-    void onError(std::exception_ptr);
+    void onError(std::exception_ptr, uint64_t resultCorrelationID);
     
     float yStretch() const override;
     
diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp
index c622d82e31..794efed549 100644
--- a/src/mbgl/tile/geometry_tile_worker.cpp
+++ b/src/mbgl/tile/geometry_tile_worker.cpp
@@ -88,7 +88,7 @@ void GeometryTileWorker::setData(std::unique_ptr<const GeometryTileData> data_,
             break;
         }
     } catch (...) {
-        parent.invoke(&GeometryTile::onError, std::current_exception());
+        parent.invoke(&GeometryTile::onError, std::current_exception(), correlationID);
     }
 }
 
@@ -112,7 +112,7 @@ void GeometryTileWorker::setLayers(std::vector<Immutable<Layer::Impl>> layers_,
             break;
         }
     } catch (...) {
-        parent.invoke(&GeometryTile::onError, std::current_exception());
+        parent.invoke(&GeometryTile::onError, std::current_exception(), correlationID);
     }
 }
 
@@ -136,7 +136,7 @@ void GeometryTileWorker::setPlacementConfig(PlacementConfig placementConfig_, ui
             break;
         }
     } catch (...) {
-        parent.invoke(&GeometryTile::onError, std::current_exception());
+        parent.invoke(&GeometryTile::onError, std::current_exception(), correlationID);
     }
 }
 
@@ -161,7 +161,7 @@ void GeometryTileWorker::symbolDependenciesChanged() {
             break;
         }
     } catch (...) {
-        parent.invoke(&GeometryTile::onError, std::current_exception());
+        parent.invoke(&GeometryTile::onError, std::current_exception(), correlationID);
     }
 }
 
@@ -187,7 +187,7 @@ void GeometryTileWorker::coalesced() {
             break;
         }
     } catch (...) {
-        parent.invoke(&GeometryTile::onError, std::current_exception());
+        parent.invoke(&GeometryTile::onError, std::current_exception(), correlationID);
     }
 }
 
@@ -353,9 +353,8 @@ void GeometryTileWorker::redoLayout() {
     parent.invoke(&GeometryTile::onLayout, GeometryTile::LayoutResult {
         std::move(buckets),
         std::move(featureIndex),
-        *data ? (*data)->clone() : nullptr,
-        correlationID
-    });
+        *data ? (*data)->clone() : nullptr
+    }, correlationID);
 
     attemptPlacement();
 }
@@ -418,9 +417,8 @@ void GeometryTileWorker::attemptPlacement() {
         std::move(buckets),
         std::move(collisionTile),
         std::move(glyphAtlasImage),
-        std::move(iconAtlasImage),
-        correlationID
-    });
+        std::move(iconAtlasImage)
+    }, correlationID);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/tile/raster_tile.cpp b/src/mbgl/tile/raster_tile.cpp
index 1260fd1edd..629ab9cc1f 100644
--- a/src/mbgl/tile/raster_tile.cpp
+++ b/src/mbgl/tile/raster_tile.cpp
@@ -27,28 +27,37 @@ RasterTile::~RasterTile() = default;
 void RasterTile::cancel() {
 }
 
+// Called instead of setData() when the data source returns an error while loading this tile.
 void RasterTile::setError(std::exception_ptr err) {
     loaded = true;
     renderable = false;
     observer->onTileError(*this, err);
 }
 
+// Called when new data is available for this tile. It can be called even if there is already data
+// in this tile.
 void RasterTile::setData(std::shared_ptr<const std::string> data,
                              optional<Timestamp> modified_,
                              optional<Timestamp> expires_) {
     modified = modified_;
     expires = expires_;
-    worker.invoke(&RasterTileWorker::parse, data);
+
+    ++correlationID;
+    worker.invoke(&RasterTileWorker::parse, data, correlationID);
 }
 
-void RasterTile::onParsed(std::unique_ptr<RasterBucket> result) {
+// Invoked once the worker thread finished parsing the image.
+void RasterTile::onParsed(std::unique_ptr<RasterBucket> result, const uint64_t resultCorrelationID) {
+    (void)resultCorrelationID;
     bucket = std::move(result);
     loaded = true;
     renderable = bucket ? true : false;
     observer->onTileChanged(*this);
 }
 
-void RasterTile::onError(std::exception_ptr err) {
+// Invoked when the worker thread fails to parse the image.
+void RasterTile::onError(std::exception_ptr err, const uint64_t resultCorrelationID) {
+    (void)resultCorrelationID;
     bucket.reset();
     loaded = true;
     renderable = false;
diff --git a/src/mbgl/tile/raster_tile.hpp b/src/mbgl/tile/raster_tile.hpp
index 28a27b2b37..9363ab02b3 100644
--- a/src/mbgl/tile/raster_tile.hpp
+++ b/src/mbgl/tile/raster_tile.hpp
@@ -36,8 +36,8 @@ public:
 
     void setMask(TileMask&&) override;
 
-    void onParsed(std::unique_ptr<RasterBucket> result);
-    void onError(std::exception_ptr);
+    void onParsed(std::unique_ptr<RasterBucket> result, uint64_t resultCorrelationID);
+    void onError(std::exception_ptr, uint64_t resultCorrelationID);
 
 private:
     TileLoader<RasterTile> loader;
@@ -45,6 +45,8 @@ private:
     std::shared_ptr<Mailbox> mailbox;
     Actor<RasterTileWorker> worker;
 
+    uint64_t correlationID = 0;
+
     // Contains the Bucket object for the tile. Buckets are render
     // objects and they get added by tile parsing operations.
     std::unique_ptr<RasterBucket> bucket;
diff --git a/src/mbgl/tile/raster_tile_worker.cpp b/src/mbgl/tile/raster_tile_worker.cpp
index 3c8af97b40..e42a78c26a 100644
--- a/src/mbgl/tile/raster_tile_worker.cpp
+++ b/src/mbgl/tile/raster_tile_worker.cpp
@@ -10,17 +10,17 @@ RasterTileWorker::RasterTileWorker(ActorRef<RasterTileWorker>, ActorRef<RasterTi
     : parent(std::move(parent_)) {
 }
 
-void RasterTileWorker::parse(std::shared_ptr<const std::string> data) {
+void RasterTileWorker::parse(std::shared_ptr<const std::string> data, const uint64_t correlationID) {
     if (!data) {
-        parent.invoke(&RasterTile::onParsed, nullptr); // No data; empty tile.
+        parent.invoke(&RasterTile::onParsed, nullptr, correlationID); // No data; empty tile.
         return;
     }
 
     try {
         auto bucket = std::make_unique<RasterBucket>(decodeImage(*data));
-        parent.invoke(&RasterTile::onParsed, std::move(bucket));
+        parent.invoke(&RasterTile::onParsed, std::move(bucket), correlationID);
     } catch (...) {
-        parent.invoke(&RasterTile::onError, std::current_exception());
+        parent.invoke(&RasterTile::onError, std::current_exception(), correlationID);
     }
 }
 
diff --git a/src/mbgl/tile/raster_tile_worker.hpp b/src/mbgl/tile/raster_tile_worker.hpp
index 44bc37ca5d..520973c3c3 100644
--- a/src/mbgl/tile/raster_tile_worker.hpp
+++ b/src/mbgl/tile/raster_tile_worker.hpp
@@ -13,7 +13,7 @@ class RasterTileWorker {
 public:
     RasterTileWorker(ActorRef<RasterTileWorker>, ActorRef<RasterTile>);
 
-    void parse(std::shared_ptr<const std::string> data);
+    void parse(std::shared_ptr<const std::string> data, uint64_t correlationID);
 
 private:
     ActorRef<RasterTile> parent;
diff --git a/test/tile/annotation_tile.test.cpp b/test/tile/annotation_tile.test.cpp
index c58b980ecd..2d3285eae1 100644
--- a/test/tile/annotation_tile.test.cpp
+++ b/test/tile/annotation_tile.test.cpp
@@ -62,8 +62,7 @@ TEST(AnnotationTile, Issue8289) {
         std::unordered_map<std::string, std::shared_ptr<Bucket>>(),
         std::make_unique<FeatureIndex>(),
         std::move(data),
-        0
-    });
+    }, 0);
 
     auto collisionTile = std::make_unique<CollisionTile>(PlacementConfig());
 
@@ -77,16 +76,14 @@ TEST(AnnotationTile, Issue8289) {
         std::move(collisionTile),
         {},
         {},
-        0
-    });
+    }, 0);
 
     // Simulate a second layout with empty data.
     tile.onLayout(GeometryTile::LayoutResult {
         std::unordered_map<std::string, std::shared_ptr<Bucket>>(),
         std::make_unique<FeatureIndex>(),
         std::make_unique<AnnotationTileData>(),
-        0
-    });
+    }, 0);
 
     std::unordered_map<std::string, std::vector<Feature>> result;
     GeometryCoordinates queryGeometry {{ Point<int16_t>(0, 0) }};
diff --git a/test/tile/raster_tile.test.cpp b/test/tile/raster_tile.test.cpp
index e96e09bacf..c32ee232b2 100644
--- a/test/tile/raster_tile.test.cpp
+++ b/test/tile/raster_tile.test.cpp
@@ -44,7 +44,7 @@ public:
 TEST(RasterTile, setError) {
     RasterTileTest test;
     RasterTile tile(OverscaledTileID(0, 0, 0), test.tileParameters, test.tileset);
-    tile.setError(std::make_exception_ptr(std::runtime_error("test")));
+    tile.setError(std::make_exception_ptr(std::runtime_error("test")), 0);
     EXPECT_FALSE(tile.isRenderable());
     EXPECT_TRUE(tile.isLoaded());
     EXPECT_TRUE(tile.isComplete());
@@ -53,7 +53,7 @@ TEST(RasterTile, setError) {
 TEST(RasterTile, onError) {
     RasterTileTest test;
     RasterTile tile(OverscaledTileID(0, 0, 0), test.tileParameters, test.tileset);
-    tile.onError(std::make_exception_ptr(std::runtime_error("test")));
+    tile.onError(std::make_exception_ptr(std::runtime_error("test")), 0);
     EXPECT_FALSE(tile.isRenderable());
     EXPECT_TRUE(tile.isLoaded());
     EXPECT_TRUE(tile.isComplete());
@@ -62,7 +62,7 @@ TEST(RasterTile, onError) {
 TEST(RasterTile, onParsed) {
     RasterTileTest test;
     RasterTile tile(OverscaledTileID(0, 0, 0), test.tileParameters, test.tileset);
-    tile.onParsed(std::make_unique<RasterBucket>(PremultipliedImage{}));
+    tile.onParsed(std::make_unique<RasterBucket>(PremultipliedImage{}), 0);
     EXPECT_TRUE(tile.isRenderable());
     EXPECT_TRUE(tile.isLoaded());
     EXPECT_TRUE(tile.isComplete());
@@ -71,7 +71,7 @@ TEST(RasterTile, onParsed) {
 TEST(RasterTile, onParsedEmpty) {
     RasterTileTest test;
     RasterTile tile(OverscaledTileID(0, 0, 0), test.tileParameters, test.tileset);
-    tile.onParsed(nullptr);
+    tile.onParsed(nullptr, 0);
     EXPECT_FALSE(tile.isRenderable());
     EXPECT_TRUE(tile.isLoaded());
     EXPECT_TRUE(tile.isComplete());
diff --git a/test/tile/vector_tile.test.cpp b/test/tile/vector_tile.test.cpp
index 45eab21576..da9512bc48 100644
--- a/test/tile/vector_tile.test.cpp
+++ b/test/tile/vector_tile.test.cpp
@@ -50,7 +50,7 @@ public:
 TEST(VectorTile, setError) {
     VectorTileTest test;
     VectorTile tile(OverscaledTileID(0, 0, 0), "source", test.tileParameters, test.tileset);
-    tile.setError(std::make_exception_ptr(std::runtime_error("test")));
+    tile.setError(std::make_exception_ptr(std::runtime_error("test")), 0);
     EXPECT_FALSE(tile.isRenderable());
     EXPECT_TRUE(tile.isLoaded());
     EXPECT_TRUE(tile.isComplete());
@@ -59,7 +59,7 @@ TEST(VectorTile, setError) {
 TEST(VectorTile, onError) {
     VectorTileTest test;
     VectorTile tile(OverscaledTileID(0, 0, 0), "source", test.tileParameters, test.tileset);
-    tile.onError(std::make_exception_ptr(std::runtime_error("test")));
+    tile.onError(std::make_exception_ptr(std::runtime_error("test")), 0);
     EXPECT_FALSE(tile.isRenderable());
     EXPECT_TRUE(tile.isLoaded());
     EXPECT_TRUE(tile.isComplete());
@@ -86,16 +86,14 @@ TEST(VectorTile, Issue7615) {
         nullptr,
         {},
         {},
-        0
-    });
+    }, 0);
 
     // Subsequent onLayout should not cause the existing symbol bucket to be discarded.
     tile.onLayout(GeometryTile::LayoutResult {
         std::unordered_map<std::string, std::shared_ptr<Bucket>>(),
         nullptr,
         nullptr,
-        0
-    });
+    }, 0);
 
     EXPECT_EQ(symbolBucket.get(), tile.getBucket(*symbolLayer.baseImpl));
 }