Compilation fixes

bin/cache.cpp

@@ -92,7 +92,7 @@ int main(int argc, char* argv[]) {
 
     mbgl::util::RunLoop loop;
     std::shared_ptr<mbgl::FileSource> dbfs = mbgl::FileSourceManager::get()->getFileSource(
-        mbgl::FileSourceType::Database, mbgl::ResourceOptions().withCachePath(args::get(cacheValue), mbgl::ClientOptions() ));
+        mbgl::FileSourceType::Database, mbgl::ResourceOptions().withCachePath(args::get(cacheValue)), mbgl::ClientOptions());
     dbfs->forward(resource, response, [&loop] { loop.stop(); });
     loop.run();
     return 0;

bin/offline.cpp

@@ -173,8 +173,8 @@ int main(int argc, char *argv[]) {
             FileSourceType::Database,
             ResourceOptions().withApiKey(apiKey)
               .withTileServerOptions(mapTilerConfiguration)
-              .withCachePath(output)),
-            ClientOptions()));
+              .withCachePath(output),
+            ClientOptions())));
 
     std::unique_ptr<OfflineRegion> region;
 

include/mbgl/storage/database_file_source.hpp

@@ -2,13 +2,12 @@
 
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/storage/offline.hpp>
-#include <mbgl/util/client_options.hpp>
 #include <mbgl/util/expected.hpp>
 #include <mbgl/util/optional.hpp>
-#include <mbgl/storage/resource_options.hpp>
 
 namespace mbgl {
 
+class ClientOptions;
 class ResourceOptions;
 
 // TODO: Split DatabaseFileSource into Ambient cache and Database interfaces.

include/mbgl/storage/file_source_manager.hpp

@@ -5,6 +5,7 @@
 
 namespace mbgl {
 
+class ClientOptions;
 class ResourceOptions;
 
 /**

platform/android/MapboxGLAndroidSDK/src/cpp/asset_manager_file_source.cpp

@@ -94,4 +94,13 @@ void AssetManagerFileSource::setResourceOptions(ResourceOptions options) {
 ResourceOptions AssetManagerFileSource::getResourceOptions() {
     return impl->actor().ask(&Impl::getResourceOptions).get();
 }
+
+void AssetManagerFileSource::setClientOptions(ClientOptions options) {
+    impl->actor().invoke(&Impl::setClientOptions, options.clone());
+}
+
+ClientOptions AssetManagerFileSource::getClientOptions() {
+    return impl->actor().ask(&Impl::getClientOptions).get();
+}
+
 } // namespace mbgl

platform/android/MapboxGLAndroidSDK/src/cpp/asset_manager_file_source.hpp

@@ -26,7 +26,7 @@ class AssetManagerFileSource : public FileSource {
     ResourceOptions getResourceOptions() override;
 
     void setClientOptions(ClientOptions options) override;
-    ClientOptions setClientOptions() override;
+    ClientOptions getClientOptions() override;
 
 private:
     class Impl;

platform/android/MapboxGLAndroidSDK/src/cpp/file_source.cpp

@@ -26,7 +26,7 @@ FileSource::FileSource(jni::JNIEnv& _env, const jni::String& apiKey, const jni::
     mapbox::sqlite::setTempPath(path);
 
     mbgl::FileSourceManager::get()->registerFileSourceFactory(
-        mbgl::FileSourceType::Asset, [](const mbgl::ResourceOptions& resourceOptions, mbgl::ClientOptions& clientOptions) {
+        mbgl::FileSourceType::Asset, [](const mbgl::ResourceOptions& resourceOptions, const mbgl::ClientOptions& clientOptions) {
             auto env{android::AttachEnv()};
             std::unique_ptr<mbgl::FileSource> assetFileSource;
             if (android::Mapbox::hasInstance(*env)) {

platform/android/MapboxGLAndroidSDK/src/cpp/snapshotter/map_snapshotter.cpp

@@ -46,6 +46,7 @@ MapSnapshotter::MapSnapshotter(jni::JNIEnv& _env,
         size,
         pixelRatio,
         mbgl::android::FileSource::getSharedResourceOptions(_env, _jFileSource),
+        mbgl::android::FileSource::getSharedClientOptions(_env, _jFileSource),
         *this,
         _localIdeographFontFamily ? jni::Make<std::string>(_env, _localIdeographFontFamily) : optional<std::string>{});
 

platform/default/include/mbgl/map/map_snapshotter.hpp

@@ -12,6 +12,7 @@
 namespace mbgl {
 
 struct CameraOptions;
+class ClientOptions;
 class LatLngBounds;
 class ResourceOptions;
 
@@ -34,10 +35,11 @@ class MapSnapshotter {
     MapSnapshotter(Size size,
                    float pixelRatio,
                    const ResourceOptions&,
+                   const ClientOptions&,
                    MapSnapshotterObserver&,
                    optional<std::string> localFontFamily = nullopt);
 
-    MapSnapshotter(Size size, float pixelRatio, const ResourceOptions&);
+    MapSnapshotter(Size size, float pixelRatio, const ResourceOptions&, const ClientOptions&);
 
     ~MapSnapshotter();
 

platform/default/src/mbgl/map/map_snapshotter.cpp

@@ -10,6 +10,7 @@
 #include <mbgl/renderer/update_parameters.hpp>
 #include <mbgl/storage/resource_options.hpp>
 #include <mbgl/style/style.hpp>
+#include <mbgl/util/client_options.hpp>
 #include <mbgl/util/event.hpp>
 #include <mbgl/util/exception.hpp>
 #include <mbgl/util/logging.hpp>
@@ -151,14 +152,16 @@ class MapSnapshotter::Impl final : public MapObserver {
     Impl(Size size,
          float pixelRatio,
          const ResourceOptions& resourceOptions,
+         const ClientOptions& clientOptions,
          MapSnapshotterObserver& observer_,
          optional<std::string> localFontFamily)
         : observer(observer_),
           frontend(size, pixelRatio, std::move(localFontFamily)),
           map(frontend,
               *this,
               MapOptions().withMapMode(MapMode::Static).withSize(size).withPixelRatio(pixelRatio),
-              resourceOptions) {}
+              resourceOptions,
+              clientOptions) {}
 
     void setRegion(const LatLngBounds& region) {
         mbgl::EdgeInsets insets{0, 0, 0, 0};
@@ -252,13 +255,14 @@ class MapSnapshotter::Impl final : public MapObserver {
 MapSnapshotter::MapSnapshotter(Size size,
                                float pixelRatio,
                                const ResourceOptions& resourceOptions,
+                               const ClientOptions& clientOptions,
                                MapSnapshotterObserver& observer,
                                optional<std::string> localFontFamily)
     : impl(std::make_unique<MapSnapshotter::Impl>(
-          size, pixelRatio, resourceOptions, observer, std::move(localFontFamily))) {}
+          size, pixelRatio, resourceOptions, clientOptions, observer, std::move(localFontFamily))) {}
 
-MapSnapshotter::MapSnapshotter(Size size, float pixelRatio, const ResourceOptions& resourceOptions)
-    : MapSnapshotter(size, pixelRatio, resourceOptions, MapSnapshotterObserver::nullObserver()) {}
+MapSnapshotter::MapSnapshotter(Size size, float pixelRatio, const ResourceOptions& resourceOptions, const ClientOptions& clientOptions)
+    : MapSnapshotter(size, pixelRatio, resourceOptions, clientOptions, MapSnapshotterObserver::nullObserver()) {}
 
 MapSnapshotter::~MapSnapshotter() = default;
 

platform/default/src/mbgl/storage/database_file_source.cpp

@@ -155,14 +155,14 @@ class DatabaseFileSourceThread {
 
 class DatabaseFileSource::Impl {
 public:
-    Impl(std::shared_ptr<FileSource> onlineFileSource, const ResourceOptions& resourceOptions, const ClientOptions& clientOptions) :
+    Impl(std::shared_ptr<FileSource> onlineFileSource, const ResourceOptions& resourceOpts, const ClientOptions& clientOpts) :
         thread(std::make_unique<util::Thread<DatabaseFileSourceThread>>(
               util::makeThreadPrioritySetter(platform::EXPERIMENTAL_THREAD_PRIORITY_DATABASE),
               "DatabaseFileSource",
               std::move(onlineFileSource),
-              resourceOptions.cachePath())),
-        resourceOptions(resourceOptions.clone()),
-        clientOptions(clientOptions.clone()) {}
+              resourceOpts.cachePath())),
+        resourceOptions(resourceOpts.clone()),
+        clientOptions(clientOpts.clone()) {}
 
     ActorRef<DatabaseFileSourceThread> actor() const { return thread->actor(); }
 

platform/glfw/glfw_view.cpp

@@ -121,11 +121,12 @@ void glfwError(int error, const char *description) {
     mbgl::Log::Error(mbgl::Event::OpenGL, "GLFW error (%i): %s", error, description);
 }
 
-GLFWView::GLFWView(bool fullscreen_, bool benchmark_, const mbgl::ResourceOptions &options)
+GLFWView::GLFWView(bool fullscreen_, bool benchmark_, const mbgl::ResourceOptions &resourceOptions, const mbgl::ClientOptions &clientOptions)
     : fullscreen(fullscreen_),
       benchmark(benchmark_),
       snapshotterObserver(std::make_unique<SnapshotObserver>()),
-      mapResourceOptions(options.clone()) {
+      mapResourceOptions(resourceOptions.clone()),
+      mapClientOptions(clientOptions.clone()) {
     glfwSetErrorCallback(glfwError);
 
     std::srand(static_cast<unsigned int>(std::time(nullptr)));
@@ -726,7 +727,7 @@ void GLFWView::popAnnotation() {
 void GLFWView::makeSnapshot(bool withOverlay) {
     if (!snapshotter || snapshotter->getStyleURL() != map->getStyle().getURL()) {
         snapshotter = std::make_unique<mbgl::MapSnapshotter>(
-            map->getMapOptions().size(), map->getMapOptions().pixelRatio(), mapResourceOptions, *snapshotterObserver);
+            map->getMapOptions().size(), map->getMapOptions().pixelRatio(), mapResourceOptions, mapClientOptions, *snapshotterObserver);
         snapshotter->setStyleURL(map->getStyle().getURL());
     }
 

platform/glfw/glfw_view.hpp

@@ -25,7 +25,7 @@ class RendererBackend;
 
 class GLFWView : public mbgl::MapObserver {
 public:
-    GLFWView(bool fullscreen, bool benchmark, const mbgl::ResourceOptions &options);
+    GLFWView(bool fullscreen, bool benchmark, const mbgl::ResourceOptions &resourceOptions, const mbgl::ClientOptions &clientOptions);
     ~GLFWView() override;
 
     float getPixelRatio() const;
@@ -152,6 +152,7 @@ class GLFWView : public mbgl::MapObserver {
     std::unique_ptr<mbgl::MapSnapshotter> snapshotter;
     std::unique_ptr<SnapshotObserver> snapshotterObserver;
     mbgl::ResourceOptions mapResourceOptions;
+    mbgl::ClientOptions mapClientOptions;
 
 #if defined(MBGL_RENDER_BACKEND_OPENGL) && !defined(MBGL_LAYER_CUSTOM_DISABLE_ALL)
     bool puckFollowsCameraCenter = false;

platform/glfw/main.cpp

@@ -101,11 +101,11 @@ int main(int argc, char *argv[]) {
 
     auto mapTilerConfiguration = mbgl::TileServerOptions::MapTilerConfiguration();
     mbgl::ResourceOptions resourceOptions;
-    mbgl::ClientOptions clientOptions;
     resourceOptions.withCachePath(cacheDB).withApiKey(apikey).withTileServerOptions(mapTilerConfiguration);
+    mbgl::ClientOptions clientOptions;
     auto orderedStyles = mapTilerConfiguration.defaultStyles();
 
-    GLFWView backend(fullscreen, benchmark, resourceOptions);
+    GLFWView backend(fullscreen, benchmark, resourceOptions, clientOptions);
     view = &backend;
 
     std::shared_ptr<mbgl::FileSource> onlineFileSource =

platform/ios/platform/darwin/src/MGLMapSnapshotter.mm

@@ -7,6 +7,7 @@
 #import <mbgl/map/map_snapshotter.hpp>
 #import <mbgl/map/camera.hpp>
 #import <mbgl/storage/resource_options.hpp>
+#import <mbgl/util/client_options.hpp>
 #import <mbgl/util/string.hpp>
 
 #import "MGLOfflineStorage_Private.h"
@@ -718,6 +719,8 @@ - (void)configureWithOptions:(MGLMapSnapshotOptions *)options {
         .withTileServerOptions(*tileServerOptions)
         .withCachePath(MGLOfflineStorage.sharedOfflineStorage.databasePath.UTF8String)
         .withAssetPath(NSBundle.mainBundle.resourceURL.path.UTF8String);
+    mbgl::ClientOptions clientOptions;
+
     auto apiKey = [[MGLSettings sharedSettings] apiKey];
     if (apiKey) {
         resourceOptions.withApiKey([apiKey UTF8String]);
@@ -727,7 +730,7 @@ - (void)configureWithOptions:(MGLMapSnapshotOptions *)options {
     auto localFontFamilyName = config.localFontFamilyName ? std::string(config.localFontFamilyName.UTF8String) : nullptr;
     _delegateHost = std::make_unique<MGLMapSnapshotterDelegateHost>(self);
     _mbglMapSnapshotter = std::make_unique<mbgl::MapSnapshotter>(
-                                                                 size, pixelRatio, resourceOptions, *_delegateHost, localFontFamilyName);
+                                                                 size, pixelRatio, resourceOptions, clientOptions, *_delegateHost, localFontFamilyName);
 
     _mbglMapSnapshotter->setStyleURL(std::string(options.styleURL.absoluteString.UTF8String));
 

platform/ios/platform/ios/src/MGLMapView.mm

@@ -15,6 +15,7 @@
 #include <mbgl/gl/custom_layer.hpp>
 #include <mbgl/renderer/renderer.hpp>
 #include <mbgl/math/wrap.hpp>
+#include <mbgl/util/client_options.hpp>
 #include <mbgl/util/exception.hpp>
 #include <mbgl/util/geo.hpp>
 #include <mbgl/util/constants.hpp>
@@ -499,14 +500,15 @@ - (void)commonInit
     resourceOptions.withCachePath(MGLOfflineStorage.sharedOfflineStorage.databasePath.UTF8String)
                    .withAssetPath([NSBundle mainBundle].resourceURL.path.UTF8String)
                    .withTileServerOptions(*tileServerOptions);
-
+    mbgl::ClientOptions clientOptions;
+
     auto apiKey = [[MGLSettings sharedSettings] apiKey];
     if (apiKey) {
         resourceOptions.withApiKey([apiKey UTF8String]);
     }
 
     NSAssert(!_mbglMap, @"_mbglMap should be NULL");
-    _mbglMap = std::make_unique<mbgl::Map>(*_rendererFrontend, *_mbglView, mapOptions, resourceOptions);
+    _mbglMap = std::make_unique<mbgl::Map>(*_rendererFrontend, *_mbglView, mapOptions, resourceOptions, clientOptions);
 
     // start paused if launch into the background
     if (background) {

platform/ios/platform/macos/src/MGLMapView.mm

@@ -34,6 +34,7 @@
 #import <mbgl/storage/network_status.hpp>
 #import <mbgl/storage/resource_options.hpp>
 #import <mbgl/math/wrap.hpp>
+#import <mbgl/util/client_options.hpp>
 #import <mbgl/util/constants.hpp>
 #import <mbgl/util/chrono.hpp>
 #import <mbgl/util/exception.hpp>
@@ -298,13 +299,14 @@ - (void)commonInit {
     resourceOptions.withTileServerOptions(*tileServerOptions)
                    .withCachePath(MGLOfflineStorage.sharedOfflineStorage.databasePath.UTF8String)
                    .withAssetPath([NSBundle mainBundle].resourceURL.path.UTF8String);
-
+    mbgl::ClientOptions clientOptions;
+
     auto apiKey = [[MGLSettings sharedSettings] apiKey];
     if (apiKey) {
         resourceOptions.withApiKey([apiKey UTF8String]);
     }                     
 
-    _mbglMap = std::make_unique<mbgl::Map>(*_rendererFrontend, *_mbglView, mapOptions, resourceOptions);
+    _mbglMap = std::make_unique<mbgl::Map>(*_rendererFrontend, *_mbglView, mapOptions, resourceOptions, clientOptions);
 
     // Notify map object when network reachability status changes.
     _reachability = [MGLReachability reachabilityForInternetConnection];

platform/node/src/node_map.hpp

@@ -104,7 +104,7 @@ struct NodeFileSource : public mbgl::FileSource {
     bool canRequest(const mbgl::Resource&) const override;
     void setResourceOptions(mbgl::ResourceOptions) override;
     mbgl::ResourceOptions getResourceOptions() override;
-    void setResourceOptions(mbgl::ClientOptions) override;
+    void setClientOptions(mbgl::ClientOptions) override;
     mbgl::ClientOptions getClientOptions() override;
     NodeMap* nodeMap;
     mbgl::ResourceOptions _resourceOptions;

render-test/file_source.cpp

@@ -16,11 +16,12 @@ std::atomic_size_t transferredSize{0};
 std::atomic_bool active{false};
 std::atomic_bool offline{true};
 
-ProxyFileSource::ProxyFileSource(std::shared_ptr<FileSource> defaultResourceLoader_, const ResourceOptions& resourceOptions, const ClientOptions& clientOptions)
-    : defaultResourceLoader(std::move(defaultResourceLoader_)) {
+ProxyFileSource::ProxyFileSource(std::shared_ptr<FileSource> defaultResourceLoader_, const ResourceOptions& resourceOpts, const ClientOptions& clientOpts)
+    : defaultResourceLoader(std::move(defaultResourceLoader_)),
+      resourceOptions(resourceOpts.clone()), clientOptions(clientOpts.clone()) {
     assert(defaultResourceLoader);
     if (offline) {
-        std::shared_ptr<FileSource> dbfs = FileSourceManager::get()->getFileSource(FileSourceType::Database, resourceOptions, clientOptions);
+        std::shared_ptr<FileSource> dbfs = FileSourceManager::get()->getFileSource(FileSourceType::Database, resourceOpts, clientOpts);
         dbfs->setProperty(READ_ONLY_MODE_KEY, true);
     }
 } 

render-test/file_source.hpp

@@ -4,11 +4,12 @@
 
 namespace mbgl {
 
+class ClientOptions;
 class ResourceOptions;
 
 class ProxyFileSource : public FileSource {
 public:
-    ProxyFileSource(std::shared_ptr<FileSource>, const ResourceOptions&);
+    ProxyFileSource(std::shared_ptr<FileSource>, const ResourceOptions&, const ClientOptions&);
     ~ProxyFileSource();
 
     std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;

render-test/runner.cpp

@@ -739,7 +739,8 @@ void TestRunner::run(TestMetadata& metadata) {
     if (maps.find(key) == maps.end()) {
         maps[key] = std::make_unique<TestRunner::Impl>(
             metadata,
-            mbgl::ResourceOptions().withCachePath(manifest.getCachePath()).withApiKey(manifest.getApiKey()));
+            mbgl::ResourceOptions().withCachePath(manifest.getCachePath()).withApiKey(manifest.getApiKey()),
+            mbgl::ClientOptions());
     }
 
     ctx.runnerImpl = maps[key].get();

src/mbgl/storage/http_file_source.hpp

@@ -2,10 +2,10 @@
 
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/storage/resource.hpp>
-#include <mbgl/storage/resource_options.hpp>
 
 namespace mbgl {
 
+class ClientOptions;
 class ResourceOptions;
 
 class HTTPFileSource : public FileSource {

src/mbgl/storage/main_resource_loader.hpp

@@ -1,11 +1,10 @@
 #pragma once
 
 #include <mbgl/storage/file_source.hpp>
-#include <mbgl/storage/resource_options.hpp>
-#include <mbgl/util/client_options.hpp>
 
 namespace mbgl {
 
+class ClientOptions;
 class ResourceTransform;
 class ResourceOptions;