[core] Make the BackgroundScheduler a singleton

- Do not carry it over everywhere as parameter, it is a shared
  instance anyway and the lifecycle is pretty much the app lifecycle
  from the moment we instantiate a map.
- Rename to BackgroundScheduler because it is a Scheduler that will
  do tasks in the background, we don't make assumptions if it is a
  thread pool or a single thread.
- Most importantly, remove the dependency from `core` on `platform`.

2 files changed, 40 insertions, 59 deletions

diff --git a/test/actor/actor.test.cpp b/test/actor/actor.test.cpp
index 02308b7ce0..6db95a83f1 100644
--- a/test/actor/actor.test.cpp
+++ b/test/actor/actor.test.cpp
@@ -1,8 +1,8 @@
 #include <mbgl/actor/actor.hpp>
-#include <mbgl/util/default_thread_pool.hpp>
-#include <mbgl/util/run_loop.hpp>
 
+#include <mbgl/actor/scheduler.hpp>
 #include <mbgl/test/util.hpp>
+#include <mbgl/util/run_loop.hpp>
 
 #include <chrono>
 #include <functional>
@@ -20,9 +20,8 @@ TEST(Actor, Construction) {
         };
     };
 
-    ThreadPool pool { 1 };
     bool constructed = false;
-    Actor<Test> test(pool, std::ref(constructed));
+    Actor<Test> test(Scheduler::GetBackground(), std::ref(constructed));
 
     EXPECT_TRUE(constructed);
 }
@@ -33,14 +32,13 @@ TEST(Actor, Destruction) {
         ~Test() {
             destructed = true;
         }
-        
+
         bool& destructed;
     };
 
-    ThreadPool pool { 1 };
     bool destructed = false;
     {
-        Actor<Test> test(pool, std::ref(destructed));
+        Actor<Test> test(Scheduler::GetBackground(), std::ref(destructed));
     }
 
     EXPECT_TRUE(destructed);
@@ -72,15 +70,13 @@ TEST(Actor, DestructionBlocksOnReceive) {
         }
     };
 
-    ThreadPool pool { 1 };
-
     std::promise<void> enteredPromise;
     std::future<void> enteredFuture = enteredPromise.get_future();
 
     std::promise<void> exitingPromise;
     std::future<void> exitingFuture = exitingPromise.get_future();
 
-    Actor<Test> test(pool, std::move(enteredPromise), std::move(exitingFuture));
+    Actor<Test> test(Scheduler::GetBackground(), std::move(enteredPromise), std::move(exitingFuture));
 
     test.self().invoke(&Test::wait);
     enteredFuture.wait();
@@ -157,11 +153,9 @@ TEST(Actor, DestructionAllowedInReceiveOnSameThread) {
         }
     };
 
-    ThreadPool pool { 1 };
-
     std::promise<void> callbackFiredPromise;
-
-    auto test = std::make_unique<Actor<Test>>(pool);
+    auto retainer = Scheduler::GetBackground();
+    auto test = std::make_unique<Actor<Test>>(retainer);
 
     // Callback (triggered while mutex is locked in Mailbox::receive())
     test->self().invoke(&Test::callMeBack, [&]() {
@@ -189,12 +183,10 @@ TEST(Actor, SelfDestructionDoesntCrashWaitingReceivingThreads) {
     };
 
 
-    ThreadPool pool { 2 };
-
     std::promise<void> actorClosedPromise;
 
-    auto closingActor = std::make_unique<Actor<Test>>(pool);
-    auto waitingActor = std::make_unique<Actor<Test>>(pool);
+    auto closingActor = std::make_unique<Actor<Test>>(Scheduler::GetBackground());
+    auto waitingActor = std::make_unique<Actor<Test>>(Scheduler::GetBackground());
 
     std::atomic<bool> waitingMessageProcessed {false};
 
@@ -251,11 +243,9 @@ TEST(Actor, OrderedMailbox) {
         }
     };
 
-    ThreadPool pool { 1 };
-
     std::promise<void> endedPromise;
     std::future<void> endedFuture = endedPromise.get_future();
-    Actor<Test> test(pool, std::move(endedPromise));
+    Actor<Test> test(Scheduler::GetBackground(), std::move(endedPromise));
 
     for (auto i = 1; i <= 10; ++i) {
         test.self().invoke(&Test::receive, i);
@@ -287,11 +277,9 @@ TEST(Actor, NonConcurrentMailbox) {
         }
     };
 
-    ThreadPool pool { 10 };
-
     std::promise<void> endedPromise;
     std::future<void> endedFuture = endedPromise.get_future();
-    Actor<Test> test(pool, std::move(endedPromise));
+    Actor<Test> test(Scheduler::GetBackground(), std::move(endedPromise));
 
     for (auto i = 1; i <= 10; ++i) {
         test.self().invoke(&Test::receive, i);
@@ -313,13 +301,12 @@ TEST(Actor, Ask) {
         }
     };
 
-    ThreadPool pool { 2 };
-    Actor<Test> test(pool);
+    Actor<Test> test(Scheduler::GetBackground());
 
     auto result = test.self().ask(&Test::doubleIt, 1);
 
     ASSERT_TRUE(result.valid());
-    
+
     auto status = result.wait_for(std::chrono::seconds(1));
     ASSERT_EQ(std::future_status::ready, status);
     ASSERT_EQ(2, result.get());
@@ -339,9 +326,8 @@ TEST(Actor, AskVoid) {
         }
     };
 
-    ThreadPool pool { 1 };
     bool executed = false;
-    Actor<Test> actor(pool, executed);
+    Actor<Test> actor(Scheduler::GetBackground(), executed);
 
     actor.self().ask(&Test::doIt).get();
     EXPECT_TRUE(executed);
@@ -349,31 +335,30 @@ TEST(Actor, AskVoid) {
 
 TEST(Actor, NoSelfActorRef) {
     // Not all actors need a reference to self
-    
+
     // Trivially constructable
     struct Trivial {};
-    
-    ThreadPool pool { 2 };
-    Actor<Trivial> trivial(pool);
-    
-    
+
+    Actor<Trivial> trivial(Scheduler::GetBackground());
+
+
     // With arguments
     struct WithArguments {
         std::promise<void> promise;
-        
+
         WithArguments(std::promise<void> promise_)
         : promise(std::move(promise_)) {
         }
-        
+
         void receive() {
             promise.set_value();
         }
     };
-    
+
     std::promise<void> promise;
     auto future = promise.get_future();
-    Actor<WithArguments> withArguments(pool, std::move(promise));
-    
+    Actor<WithArguments> withArguments(Scheduler::GetBackground(), std::move(promise));
+
     withArguments.self().invoke(&WithArguments::receive);
     future.wait();
 }
@@ -386,32 +371,32 @@ TEST(Actor, TwoPhaseConstruction) {
     struct Test {
         Test(ActorRef<Test>, std::shared_ptr<bool> destroyed_)
             : destroyed(std::move(destroyed_)) {};
-        
+
         ~Test() {
             *destroyed = true;
         }
-        
+
         void callMe(std::promise<void> p) {
             p.set_value();
         }
-        
+
         void stop() {
             util::RunLoop::Get()->stop();
         }
-        
+
         std::shared_ptr<bool> destroyed;
     };
 
     AspiringActor<Test> parent;
-    
+
     auto destroyed = std::make_shared<bool>(false);
-    
+
     std::promise<void> queueExecuted;
     auto queueExecutedFuture = queueExecuted.get_future();
-    
+
     parent.self().invoke(&Test::callMe, std::move(queueExecuted));
     parent.self().invoke(&Test::stop);
-    
+
     auto thread = std::thread([
         capturedArgs = std::make_tuple(destroyed),
         &parent
@@ -420,11 +405,11 @@ TEST(Actor, TwoPhaseConstruction) {
         EstablishedActor<Test> test(loop, parent, capturedArgs);
         loop.run();
     });
-    
+
     // should not hang
     queueExecutedFuture.get();
     thread.join();
-    
+
     EXPECT_TRUE(*destroyed);
 }
 
diff --git a/test/actor/actor_ref.test.cpp b/test/actor/actor_ref.test.cpp
index 20aa1c35c1..221a220ed9 100644
--- a/test/actor/actor_ref.test.cpp
+++ b/test/actor/actor_ref.test.cpp
@@ -1,6 +1,6 @@
 #include <mbgl/actor/actor.hpp>
-#include <mbgl/util/default_thread_pool.hpp>
 
+#include <mbgl/actor/scheduler.hpp>
 #include <mbgl/test/util.hpp>
 
 #include <future>
@@ -27,11 +27,10 @@ TEST(ActorRef, CanOutliveActor) {
         }
     };
 
-    ThreadPool pool { 1 };
     bool died = false;
 
     ActorRef<Test> test = [&] () {
-        return Actor<Test>(pool, std::ref(died)).self();
+        return Actor<Test>(Scheduler::GetBackground(), std::ref(died)).self();
     }();
 
     EXPECT_TRUE(died);
@@ -54,8 +53,7 @@ TEST(ActorRef, Ask) {
         }
     };
 
-    ThreadPool pool { 1 };
-    Actor<Test> actor(pool);
+    Actor<Test> actor(Scheduler::GetBackground());
     ActorRef<Test> ref = actor.self();
 
     EXPECT_EQ(20, ref.ask(&Test::gimme).get());
@@ -76,9 +74,8 @@ TEST(ActorRef, AskVoid) {
         }
     };
     
-    ThreadPool pool { 1 };
     bool executed = false;
-    Actor<Test> actor(pool, executed);
+    Actor<Test> actor(Scheduler::GetBackground(), executed);
     ActorRef<Test> ref = actor.self();
     
     ref.ask(&Test::doIt).get();
@@ -104,8 +101,7 @@ TEST(ActorRef, AskOnDestroyedActor) {
     };
     bool died = false;
 
-    ThreadPool pool { 1 };
-    auto actor = std::make_unique<Actor<Test>>(pool, died);
+    auto actor = std::make_unique<Actor<Test>>(Scheduler::GetBackground(), died);
     ActorRef<Test> ref = actor->self();
 
     actor.reset();