[core] Introduce usage tag for resources

Make the distinction if a resource is being requested for offline usage or if it will be used immediately. Fixes #14746
mapbox · May 27, 2019 · 6948c13 · 6948c13
1 parent 5e00a2a
commit 6948c13
Show file tree

Hide file tree

Showing 4 changed files with 39 additions and 9 deletions.
diff --git a/include/mbgl/storage/resource.hpp b/include/mbgl/storage/resource.hpp
@@ -29,6 +29,11 @@ class Resource {
         Low
     };
 
+    enum class Usage : bool {
+        Online,
+        Offline
+    };
+
     struct TileData {
         std::string urlTemplate;
         uint8_t pixelRatio;
@@ -60,6 +65,7 @@ class Resource {
     }
 
     void setPriority(Priority p) { priority = p; }
+    void setUsage(Usage u) { usage = u; }
 
     bool hasLoadingMethod(LoadingMethod method);
 
@@ -83,6 +89,7 @@ class Resource {
 
     Kind kind;
     LoadingMethod loadingMethod;
+    Usage usage{ Usage::Online };
     Priority priority;
     std::string url;
 

diff --git a/platform/default/include/mbgl/storage/offline_download.hpp b/platform/default/include/mbgl/storage/offline_download.hpp
@@ -62,7 +62,7 @@ class OfflineDownload {
     std::deque<Resource> resourcesRemaining;
     std::list<std::tuple<Resource, Response>> buffer;
 
-    void queueResource(Resource);
+    void queueResource(Resource&&);
     void queueTiles(style::SourceType, uint16_t tileSize, const Tileset&);
 };
 

diff --git a/platform/default/src/mbgl/storage/offline_download.cpp b/platform/default/src/mbgl/storage/offline_download.cpp
@@ -223,8 +223,12 @@ void OfflineDownload::activateDownload() {
     status = OfflineRegionStatus();
     status.downloadState = OfflineRegionDownloadState::Active;
     status.requiredResourceCount++;
-    ensureResource(Resource::style(definition.match([](auto& reg){ return reg.styleURL; }), Resource::Priority::Low),
-                   [&](Response styleResponse) {
+
+    auto styleResource = Resource::style(definition.match([](auto& reg){ return reg.styleURL; }));
+    styleResource.setPriority(Resource::Priority::Low);
+    styleResource.setUsage(Resource::Usage::Offline);
+
+    ensureResource(styleResource, [&](Response styleResponse) {
         status.requiredResourceCountIsPrecise = true;
 
         style::Parser parser;
@@ -242,7 +246,11 @@ void OfflineDownload::activateDownload() {
                     status.requiredResourceCount++;
                     requiredSourceURLs.insert(url);
 
-                    ensureResource(Resource::source(url, Resource::Priority::Low), [=](Response sourceResponse) {
+                    auto sourceResource = Resource::source(url);
+                    sourceResource.setPriority(Resource::Priority::Low);
+                    sourceResource.setUsage(Resource::Usage::Offline);
+
+                    ensureResource(sourceResource, [=](Response sourceResponse) {
                         style::conversion::Error error;
                         optional<Tileset> tileset = style::conversion::convertJSON<Tileset>(*sourceResponse.data, error);
                         if (tileset) {
@@ -361,24 +369,32 @@ void OfflineDownload::deactivateDownload() {
     requests.clear();
 }
 
-void OfflineDownload::queueResource(Resource resource) {
+void OfflineDownload::queueResource(Resource&& resource) {
     resource.setPriority(Resource::Priority::Low);
+    resource.setUsage(Resource::Usage::Offline);
     status.requiredResourceCount++;
     resourcesRemaining.push_front(std::move(resource));
 }
 
 void OfflineDownload::queueTiles(SourceType type, uint16_t tileSize, const Tileset& tileset) {
     tileCover(definition, type, tileSize, tileset.zoomRange, [&](const auto& tile) {
         status.requiredResourceCount++;
-        resourcesRemaining.push_back(Resource::tile(
-            tileset.tiles[0], definition.match([](auto& def) { return def.pixelRatio; }), tile.x,
-            tile.y, tile.z, tileset.scheme, Resource::Priority::Low));
+
+        auto tileResource = Resource::tile(
+                tileset.tiles[0], definition.match([](auto& def) { return def.pixelRatio; }),
+                tile.x, tile.y, tile.z, tileset.scheme);
+
+        tileResource.setPriority(Resource::Priority::Low);
+        tileResource.setUsage(Resource::Usage::Offline);
+
+        resourcesRemaining.push_back(std::move(tileResource));
     });
 }
 
 void OfflineDownload::ensureResource(const Resource& resource,
                                      std::function<void(Response)> callback) {
     assert(resource.priority == Resource::Priority::Low);
+    assert(resource.usage == Resource::Usage::Offline);
 
     auto workRequestsIt = requests.insert(requests.begin(), nullptr);
     *workRequestsIt = util::RunLoop::Get()->invokeCancellable([=]() {

diff --git a/test/storage/offline_download.test.cpp b/test/storage/offline_download.test.cpp
@@ -740,7 +740,7 @@ TEST(OfflineDownload, Deactivate) {
 }
 
 
-TEST(OfflineDownload, AllOfflineRequestsHaveLowPriority) {
+TEST(OfflineDownload, AllOfflineRequestsHaveLowPriorityAndOfflineUsage) {
     OfflineTest test;
     auto region = test.createRegion();
     ASSERT_TRUE(region);
@@ -751,36 +751,43 @@ TEST(OfflineDownload, AllOfflineRequestsHaveLowPriority) {
 
     test.fileSource.styleResponse = [&] (const Resource& resource) {
         EXPECT_TRUE(resource.priority == Resource::Priority::Low);
+        EXPECT_TRUE(resource.usage == Resource::Usage::Offline);
         return test.response("style.json");
     };
 
     test.fileSource.spriteImageResponse = [&] (const Resource& resource) {
         EXPECT_TRUE(resource.priority == Resource::Priority::Low);
+        EXPECT_TRUE(resource.usage == Resource::Usage::Offline);
         return test.response("sprite.png");
     };
 
     test.fileSource.imageResponse = [&] (const Resource& resource) {
         EXPECT_TRUE(resource.priority == Resource::Priority::Low);
+        EXPECT_TRUE(resource.usage == Resource::Usage::Offline);
         return test.response("radar.gif");
     };
 
     test.fileSource.spriteJSONResponse = [&] (const Resource& resource) {
         EXPECT_TRUE(resource.priority == Resource::Priority::Low);
+        EXPECT_TRUE(resource.usage == Resource::Usage::Offline);
         return test.response("sprite.json");
     };
 
     test.fileSource.glyphsResponse = [&] (const Resource& resource) {
         EXPECT_TRUE(resource.priority == Resource::Priority::Low);
+        EXPECT_TRUE(resource.usage == Resource::Usage::Offline);
         return test.response("glyph.pbf");
     };
 
     test.fileSource.sourceResponse = [&] (const Resource& resource) {
         EXPECT_TRUE(resource.priority == Resource::Priority::Low);
+        EXPECT_TRUE(resource.usage == Resource::Usage::Offline);
         return test.response("streets.json");
     };
 
     test.fileSource.tileResponse = [&] (const Resource& resource) {
         EXPECT_TRUE(resource.priority == Resource::Priority::Low);
+        EXPECT_TRUE(resource.usage == Resource::Usage::Offline);
         return test.response("0-0-0.vector.pbf");
     };