Refactor TileDataMonitors

include/mbgl/storage/default_file_source.hpp

@@ -26,6 +26,10 @@ class DefaultFileSource : public FileSource {
                       uint64_t maximumCacheSize = util::DEFAULT_MAX_CACHE_SIZE);
     ~DefaultFileSource() override;
 
+    bool supportsOptionalRequests() const override {
+        return true;
+    }
+
     void setAccessToken(const std::string&);
     std::string getAccessToken() const;
 

include/mbgl/storage/file_source.hpp

@@ -23,6 +23,14 @@ class FileSource : private util::noncopyable {
     // If the request is cancelled before the callback is executed, the callback will
     // not be executed.
     virtual std::unique_ptr<AsyncRequest> request(const Resource&, Callback) = 0;
+
+    // When a file source supports optional requests, it must return true.
+    // Optional requests are requests that aren't as urgent, but could be useful, e.g.
+    // to cover part of the map while loading. The FileSource should only do cheap actions to
+    // retrieve the data, e.g. load it from a cache, but not from the internet.
+    virtual bool supportsOptionalRequests() const {
+        return false;
+    }
 };
 
 } // namespace mbgl

src/mbgl/algorithm/update_renderables.hpp

@@ -39,19 +39,21 @@ void updateRenderables(GetTileDataFn getTileData,
 
         // if (source has the tile and bucket is loaded) {
         if (data->isRenderable()) {
-            retainTileData(*data);
+            retainTileData(*data, true);
             renderTile(idealRenderTileID, *data);
         } else {
+            bool triedPrevious = data->hasTriedOptional();
+
             // The tile isn't loaded yet, but retain it anyway because it's an ideal tile.
-            retainTileData(*data);
+            retainTileData(*data, true);
             covered = true;
             overscaledZ = dataTileZoom + 1;
             if (overscaledZ > info.maxZoom) {
                 // We're looking for an overzoomed child tile.
                 const auto childDataTileID = idealDataTileID.scaledTo(overscaledZ);
                 data = getTileData(childDataTileID);
                 if (data && data->isRenderable()) {
-                    retainTileData(*data);
+                    retainTileData(*data, false);
                     renderTile(idealRenderTileID, *data);
                 } else {
                     covered = false;
@@ -62,7 +64,7 @@ void updateRenderables(GetTileDataFn getTileData,
                     const OverscaledTileID childDataTileID(overscaledZ, childTileID);
                     data = getTileData(childDataTileID);
                     if (data && data->isRenderable()) {
-                        retainTileData(*data);
+                        retainTileData(*data, false);
                         renderTile(childDataTileID.unwrapTo(idealRenderTileID.wrap), *data);
                     } else {
                         // At least one child tile doesn't exist, so we are going to look for
@@ -88,11 +90,19 @@ void updateRenderables(GetTileDataFn getTileData,
                     }
 
                     data = getTileData(parentDataTileID);
-                    if (data && data->isRenderable()) {
-                        retainTileData(*data);
-                        renderTile(parentRenderTileID, *data);
-                        // Break parent tile ascent, since we found one.
-                        break;
+                    if (!data && triedPrevious) {
+                        data = createTileData(parentDataTileID);
+                    }
+
+                    if (data) {
+                        triedPrevious = data->hasTriedOptional();
+                        retainTileData(*data, false);
+
+                        if (data->isRenderable()) {
+                            renderTile(parentRenderTileID, *data);
+                            // Break parent tile ascent, since we found one.
+                            break;
+                        }
                     }
                 }
             }

src/mbgl/annotation/annotation_manager.cpp

@@ -5,6 +5,7 @@
 #include <mbgl/annotation/fill_annotation_impl.hpp>
 #include <mbgl/annotation/style_sourced_annotation_impl.hpp>
 #include <mbgl/style/source.hpp>
+#include <mbgl/tile/annotation_tile_data.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/layers/symbol_layer_impl.hpp>
@@ -134,18 +135,18 @@ void AnnotationManager::updateStyle(Style& style) {
 
     obsoleteShapeAnnotationLayers.clear();
 
-    for (auto& monitor : monitors) {
-        monitor->update(getTile(monitor->tileID.canonical));
+    for (auto& data : monitors) {
+        data->setData(getTile(data->id.canonical), {}, {});
     }
 }
 
-void AnnotationManager::addTileMonitor(AnnotationTileMonitor& monitor) {
-    monitors.insert(&monitor);
-    monitor.update(getTile(monitor.tileID.canonical));
+void AnnotationManager::addTileData(AnnotationTileData& data) {
+    monitors.insert(&data);
+    data.setData(getTile(data.id.canonical), {}, {});
 }
 
-void AnnotationManager::removeTileMonitor(AnnotationTileMonitor& monitor) {
-    monitors.erase(&monitor);
+void AnnotationManager::removeTileData(AnnotationTileData& data) {
+    monitors.erase(&data);
 }
 
 void AnnotationManager::addIcon(const std::string& name, std::shared_ptr<const SpriteImage> sprite) {

src/mbgl/annotation/annotation_manager.hpp

@@ -15,7 +15,7 @@
 namespace mbgl {
 
 class AnnotationTile;
-class AnnotationTileMonitor;
+class AnnotationTileData;
 class SymbolAnnotationImpl;
 class ShapeAnnotationImpl;
 
@@ -41,8 +41,8 @@ class AnnotationManager : private util::noncopyable {
 
     void updateStyle(style::Style&);
 
-    void addTileMonitor(AnnotationTileMonitor&);
-    void removeTileMonitor(AnnotationTileMonitor&);
+    void addTileData(AnnotationTileData&);
+    void removeTileData(AnnotationTileData&);
 
     static const std::string SourceID;
     static const std::string PointLayerID;
@@ -65,7 +65,7 @@ class AnnotationManager : private util::noncopyable {
     SymbolAnnotationMap symbolAnnotations;
     ShapeAnnotationMap shapeAnnotations;
     std::vector<std::string> obsoleteShapeAnnotationLayers;
-    std::set<AnnotationTileMonitor*> monitors;
+    std::set<AnnotationTileData*> monitors;
 
     SpriteStore spriteStore;
     SpriteAtlas spriteAtlas;

src/mbgl/annotation/annotation_tile.cpp

@@ -32,23 +32,4 @@ util::ptr<GeometryTileLayer> AnnotationTile::getLayer(const std::string& name) c
     return nullptr;
 }
 
-AnnotationTileMonitor::AnnotationTileMonitor(const OverscaledTileID& tileID_, AnnotationManager& annotationManager_)
-    : tileID(tileID_),
-      annotationManager(annotationManager_) {
-}
-
-AnnotationTileMonitor::~AnnotationTileMonitor() {
-    annotationManager.removeTileMonitor(*this);
-}
-
-std::unique_ptr<AsyncRequest> AnnotationTileMonitor::monitorTile(const GeometryTileMonitor::Callback& callback_) {
-    callback = callback_;
-    annotationManager.addTileMonitor(*this);
-    return nullptr;
-}
-
-void AnnotationTileMonitor::update(std::unique_ptr<GeometryTile> tile) {
-    callback(nullptr, std::move(tile), {}, {});
-}
-
 } // namespace mbgl

src/mbgl/annotation/annotation_tile.hpp

@@ -1,10 +1,6 @@
 #pragma once
 
 #include <mbgl/tile/geometry_tile.hpp>
-#include <mbgl/tile/tile_id.hpp>
-
-#include <map>
-#include <unordered_map>
 
 namespace mbgl {
 
@@ -40,24 +36,7 @@ class AnnotationTile : public GeometryTile {
 public:
     util::ptr<GeometryTileLayer> getLayer(const std::string&) const override;
 
-    std::map<std::string, util::ptr<AnnotationTileLayer>> layers;
-};
-
-class AnnotationManager;
-
-class AnnotationTileMonitor : public GeometryTileMonitor {
-public:
-    AnnotationTileMonitor(const OverscaledTileID&, AnnotationManager&);
-    ~AnnotationTileMonitor();
-
-    void update(std::unique_ptr<GeometryTile>);
-    std::unique_ptr<AsyncRequest> monitorTile(const GeometryTileMonitor::Callback&) override;
-
-    OverscaledTileID tileID;
-
-private:
-    AnnotationManager& annotationManager;
-    GeometryTileMonitor::Callback callback;
+    std::unordered_map<std::string, util::ptr<AnnotationTileLayer>> layers;
 };
 
 } // namespace mbgl

src/mbgl/annotation/symbol_annotation_impl.cpp

@@ -1,5 +1,6 @@
 #include <mbgl/annotation/symbol_annotation_impl.hpp>
 #include <mbgl/annotation/annotation_tile.hpp>
+#include <mbgl/tile/tile_id.hpp>
 #include <mbgl/math/clamp.hpp>
 
 namespace mbgl {

src/mbgl/map/map.cpp

@@ -37,7 +37,7 @@ class Map::Impl : public style::Observer {
 public:
     Impl(View&, FileSource&, MapMode, GLContextMode, ConstrainMode, ViewportMode);
 
-    void onResourceLoaded() override;
+    void onNeedsRepaint() override;
     void onResourceError(std::exception_ptr) override;
 
     void update();
@@ -836,7 +836,7 @@ void Map::onLowMemory() {
     impl->view.invalidate();
 }
 
-void Map::Impl::onResourceLoaded() {
+void Map::Impl::onNeedsRepaint() {
     updateFlags |= Update::Repaint;
     asyncUpdate.send();
 }

src/mbgl/style/observer.hpp

@@ -15,10 +15,10 @@ class Observer : public GlyphStoreObserver,
      * In addition to the individual glyph, sprite, and source events, the
      * following "rollup" events are provided for convenience. They are
      * strictly additive; e.g. when a source is loaded, both `onSourceLoaded`
-     * and `onResourceLoaded` will be called.
+     * and `onNeedsRepaint` will be called.
      */
-     virtual void onResourceLoaded() {};
-     virtual void onResourceError(std::exception_ptr) {};
+    virtual void onNeedsRepaint() {}
+    virtual void onResourceError(std::exception_ptr) {}
 };
 
 } // namespace style