Clear out GeometryTileWorker::layers during redoLayout

include/mbgl/util/optional.hpp

@@ -7,4 +7,7 @@ namespace mbgl {
 template <typename T>
 using optional = std::experimental::optional<T>;
 
+using nullopt_t = std::experimental::nullopt_t;
+constexpr auto nullopt = std::experimental::nullopt;
+
 } // namespace mbgl

src/mbgl/geometry/feature_index.cpp

@@ -59,7 +59,8 @@ void FeatureIndex::query(
         const optional<std::vector<std::string>>& filterLayerIDs,
         const GeometryTileData& geometryTileData,
         const CanonicalTileID& tileID,
-        const style::Style& style) const {
+        const style::Style& style,
+        const CollisionTile* collisionTile) const {
 
     mapbox::geometry::box<int16_t> box = mapbox::geometry::envelope(queryGeometry);
 
@@ -154,8 +155,4 @@ void FeatureIndex::addBucketLayerName(const std::string& bucketName, const std::
     bucketLayerIDs[bucketName].push_back(layerID);
 }
 
-void FeatureIndex::setCollisionTile(std::unique_ptr<CollisionTile> collisionTile_) {
-    collisionTile = std::move(collisionTile_);
-}
-
 } // namespace mbgl

src/mbgl/geometry/feature_index.hpp

@@ -42,7 +42,8 @@ class FeatureIndex {
             const optional<std::vector<std::string>>& layerIDs,
             const GeometryTileData&,
             const CanonicalTileID&,
-            const style::Style&) const;
+            const style::Style&,
+            const CollisionTile*) const;
 
     static optional<GeometryCoordinates> translateQueryGeometry(
             const GeometryCoordinates& queryGeometry,
@@ -53,8 +54,6 @@ class FeatureIndex {
 
     void addBucketLayerName(const std::string& bucketName, const std::string& layerName);
 
-    void setCollisionTile(std::unique_ptr<CollisionTile>);
-
 private:
     void addFeature(
             std::unordered_map<std::string, std::vector<Feature>>& result,
@@ -67,7 +66,6 @@ class FeatureIndex {
             const float bearing,
             const float pixelsToTileUnits) const;
 
-    std::unique_ptr<CollisionTile> collisionTile;
     GridIndex<IndexedSubfeature> grid;
     unsigned int sortIndex = 0;
 

src/mbgl/text/collision_tile.cpp

@@ -168,7 +168,7 @@ Box CollisionTile::getTreeBox(const Point<float>& anchor, const CollisionBox& bo
     };
 }
 
-std::vector<IndexedSubfeature> CollisionTile::queryRenderedSymbols(const GeometryCoordinates& queryGeometry, float scale) {
+std::vector<IndexedSubfeature> CollisionTile::queryRenderedSymbols(const GeometryCoordinates& queryGeometry, float scale) const {
     std::vector<IndexedSubfeature> result;
     if (queryGeometry.empty() || (tree.empty() && ignoredTree.empty())) {
         return result;

src/mbgl/text/collision_tile.hpp

@@ -42,7 +42,7 @@ class CollisionTile {
     float placeFeature(const CollisionFeature&, bool allowOverlap, bool avoidEdges);
     void insertFeature(CollisionFeature&, float minPlacementScale, bool ignorePlacement);
 
-    std::vector<IndexedSubfeature> queryRenderedSymbols(const GeometryCoordinates&, float scale);
+    std::vector<IndexedSubfeature> queryRenderedSymbols(const GeometryCoordinates&, float scale) const;
 
     const PlacementConfig config;
 

src/mbgl/tile/geometry_tile.cpp

@@ -6,6 +6,7 @@
 #include <mbgl/style/layer_impl.hpp>
 #include <mbgl/style/layers/background_layer.hpp>
 #include <mbgl/style/layers/custom_layer.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/geometry/feature_index.hpp>
@@ -105,7 +106,7 @@ void GeometryTile::redoLayout() {
 
 void GeometryTile::onLayout(LayoutResult result) {
     availableData = DataAvailability::Some;
-    buckets = std::move(result.buckets);
+    nonSymbolBuckets = std::move(result.nonSymbolBuckets);
     featureIndex = std::move(result.featureIndex);
     data = std::move(result.tileData);
     observer->onTileChanged(*this);
@@ -115,10 +116,8 @@ void GeometryTile::onPlacement(PlacementResult result) {
     if (result.correlationID == correlationID) {
         availableData = DataAvailability::All;
     }
-    for (auto& bucket : result.buckets) {
-        buckets[bucket.first] = std::move(bucket.second);
-    }
-    featureIndex->setCollisionTile(std::move(result.collisionTile));
+    symbolBuckets = std::move(result.symbolBuckets);
+    collisionTile = std::move(result.collisionTile);
     observer->onTileChanged(*this);
 }
 
@@ -128,6 +127,7 @@ void GeometryTile::onError(std::exception_ptr err) {
 }
 
 Bucket* GeometryTile::getBucket(const Layer& layer) {
+    const auto& buckets = layer.is<SymbolLayer>() ? symbolBuckets : nonSymbolBuckets;
     const auto it = buckets.find(layer.baseImpl->id);
     if (it == buckets.end()) {
         return nullptr;
@@ -153,7 +153,8 @@ void GeometryTile::queryRenderedFeatures(
                         layerIDs,
                         *data,
                         id.canonical,
-                        style);
+                        style,
+                        collisionTile.get());
 }
 
 } // namespace mbgl

src/mbgl/tile/geometry_tile.hpp

@@ -50,7 +50,7 @@ class GeometryTile : public Tile {
 
     class LayoutResult {
     public:
-        std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
+        std::unordered_map<std::string, std::shared_ptr<Bucket>> nonSymbolBuckets;
         std::unique_ptr<FeatureIndex> featureIndex;
         std::unique_ptr<GeometryTileData> tileData;
         uint64_t correlationID;
@@ -59,7 +59,7 @@ class GeometryTile : public Tile {
 
     class PlacementResult {
     public:
-        std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
+        std::unordered_map<std::string, std::shared_ptr<Bucket>> symbolBuckets;
         std::unique_ptr<CollisionTile> collisionTile;
         uint64_t correlationID;
     };
@@ -80,9 +80,12 @@ class GeometryTile : public Tile {
     uint64_t correlationID = 0;
     optional<PlacementConfig> requestedConfig;
 
-    std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
+    std::unordered_map<std::string, std::shared_ptr<Bucket>> nonSymbolBuckets;
     std::unique_ptr<FeatureIndex> featureIndex;
     std::unique_ptr<const GeometryTileData> data;
+
+    std::unordered_map<std::string, std::shared_ptr<Bucket>> symbolBuckets;
+    std::unique_ptr<CollisionTile> collisionTile;
 };
 
 } // namespace mbgl

src/mbgl/tile/geometry_tile_worker.cpp

@@ -215,6 +215,8 @@ void GeometryTileWorker::redoLayout() {
     BucketParameters parameters { id, obsolete, *featureIndex, mode };
 
     std::vector<std::vector<std::unique_ptr<Layer>>> groups = groupByLayout(std::move(*layers));
+    layers = nullopt;
+
     for (auto& group : groups) {
         if (obsolete) {
             return;
@@ -280,7 +282,7 @@ bool GeometryTileWorker::hasPendingSymbolDependencies() const {
 }
 
 void GeometryTileWorker::attemptPlacement() {
-    if (!data || !layers || !placementConfig) {
+    if (!placementConfig) {
         return;
     }
 

test/tile/vector_tile.test.cpp

@@ -8,8 +8,14 @@
 #include <mbgl/map/transform.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/update_parameters.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
+#include <mbgl/renderer/symbol_bucket.hpp>
+#include <mbgl/text/collision_tile.hpp>
+#include <mbgl/geometry/feature_index.hpp>
 #include <mbgl/annotation/annotation_manager.hpp>
 
+#include <memory>
+
 using namespace mbgl;
 
 class VectorTileTest {
@@ -47,3 +53,32 @@ TEST(VectorTile, onError) {
     tile.onError(std::make_exception_ptr(std::runtime_error("test")));
     EXPECT_TRUE(tile.isRenderable());
 }
+
+TEST(VectorTile, Issue7615) {
+    VectorTileTest test;
+    VectorTile tile(OverscaledTileID(0, 0, 0), "source", test.updateParameters, test.tileset);
+
+    style::SymbolLayer symbolLayer("symbol", "source");
+    auto symbolBucket = std::make_shared<SymbolBucket>(
+        MapMode::Continuous, style::SymbolLayoutProperties::Evaluated(), false, false);
+
+    // Simulate placement of a symbol layer.
+    tile.onPlacement(GeometryTile::PlacementResult {
+        {{
+            symbolLayer.getID(),
+            symbolBucket
+        }},
+        nullptr,
+        0
+    });
+
+    // Subsequent onLayout should not cause the existing symbol bucket to be discarded.
+    tile.onLayout(GeometryTile::LayoutResult {
+        {},
+        nullptr,
+        nullptr,
+        0
+    });
+
+    EXPECT_EQ(symbolBucket.get(), tile.getBucket(symbolLayer));
+}