When opening many maps and sharing the same filesource:
- Say we open around 30 maps and they all have the same style.
- They will all request the same sprite.json, but Qt filesource will
restrict simultaneous request to 20.
- Mapbox GL will send some sprite.json to the filesource and queue
some internally along with other requests.
- When the first sprite.json arrives and the Qt filesource calls the
callback, Mapbox GL will synchronously push queued requests to the
Qt filesource when a request is handled.
- We are walking a QVector dispatching sprite.json requests, but more
requests get added to this QVector while we are walking it using an
iterator.
- That corrupts the iterator and we get a crash.
The fix is simple, just pop items from the QVector until it is empty
instead of using iterators.
The `style::Layer` class now exposes all the properties contained at `style::LayerImpl`.
This allowed to drop `style::Layer::accept()` method usage, avoid the repeated generated code
and thus save some binary size.
This patch is a part of the layers modularization effort.
Render threads won't have a scheduler, so we create one that is
shared by all the maps rendering at this thread. The bad side
effect of this is that we need to wake up the render thread
to process events.
Mapbox GL should get rid of processing events on the render
thread. This solution is a workaround.
GLIBC 2.27 added new versioned symbols of powf and logf, while the double versions of pow and log remained stable.
Prefer the double version to avoid introducing a dependency on a newer version of GLIBC than strictly necessary.
See https://lists.gnu.org/archive/html/info-gnu/2018-02/msg00000.html
Unfortuntely, it's difficult to avoid all exceptions, because sqlite3_open_v2 does not reliably return SQLITE_NOTADB if the file is not a database. However, this should avoid cases where developers misinterpret the SQLITE_CANTOPEN exception as a crash, which is the common case.
Previously all QMapboxGL objects were sharing the same cache created
by the first instantiated object. Now it will share the cache only
if it points to the same path.
Fixes#11766
Once again QVariant getting confused about its contents
datatype. With this patch we use QString directly and
copy the contents, which should be cheap with Qt implicity
sharing.
Because a message we queue from the foreground may cause the background to complete, exit, and tear down the AsyncTask, we have to block queue processing until we've finished our call to AsyncTask::send().
Broadening the scope of a mutex is scary, but I audited the code of our four implementations of AsyncTask and I don't see any way this could cause a deadlock.
