Issue 5179 - Implement asynchronous executor with a controllable lifetime

src/Platform.cpp

 /*
 * This file is part of Adblock Plus <https://adblockplus.org/>,
 * Copyright (C) 2006-present eyeo GmbH
 *
 * Adblock Plus is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 *
 * Adblock Plus is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 99 matching lines @@
 }
 
 void Platform::WithLogSystem(const WithLogSystemCallback& callback)
 {
   if (logSystem && callback)
     callback(*logSystem);
 }
 
 namespace
 {
   class SharedAsyncExecutor {

[sergei, 2018/02/23 11:16:42]

It's rather a compatibility thing to simplify the updating of libadblockplus in
libadblockplus-android which will already cause a lot of work (because they will
have to figure out what to do with infinitely running operations). In
libadblockplus-android we are currently using
DefaultPlatformBuilder::GetDefaultAsyncExecutor() to obtain a scheduler
(std::function) which is used to safely run asynchronous tasks related to
FilterEngine. In general it's not a public API and under the question to be
changed later.

When DefaultPlatform is being destroyed we invalidate that asynchronous executor
and ensure that no any task is running there, so whatever scheduled by
libadblocklpus-android via the function defaultScheduler will be either able to
normally (without access violations) finish because FilterEngine is not
destroyed yet or ignored at the scheduling stage, what is also safe.

See how it's used with `defaultScheduler` and that it's "invalidated" in the
destructor.

   public:
     SharedAsyncExecutor()
       : executor(new AsyncExecutor())
     {
     }
     void Dispatch(const std::function<void()>& task) {
       std::lock_guard<std::mutex> lock(asyncExecutorMutex);
       if (!executor)
         return;
       executor->Dispatch(task);
     }
     void Invalidate() {
       std::unique_ptr<AsyncExecutor> tmp;

[sergei, 2018/02/23 11:16:42]

JIC, it's needed to prevent dead locks. If `executor` were destroyed directly
under the `lock` then it could happen that one of the tasks of the `executor` is
waiting for the lock on mutex in order to dispatch a next task and the
`executor` is waiting for the finishing of that task and is not releasing the
mutex.

       {
         std::lock_guard<std::mutex> lock(asyncExecutorMutex);
         tmp = move(executor);
       }
     }
   private:
     std::mutex asyncExecutorMutex;
     std::unique_ptr<AsyncExecutor> executor;
   };
 
   class DefaultPlatform : public Platform
   {
   public:
     typedef std::shared_ptr<SharedAsyncExecutor> AsyncExecutorPtr;
-    explicit DefaultPlatform(const std::shared_ptr<SharedAsyncExecutor>& asyncExecutor, CreationParameters&& creationParams)

[hub, 2018/02/23 22:59:35]

Since there is `typedef std::shared_ptr<SharedAsyncExecutor> AsyncExecutorPtr`
above, why isn't AsyncExecutorPtr used here. (and below line 160) ?

[sergei, 2018/03/01 11:18:37]

Fixed, I somehow forgot about it ))

+    explicit DefaultPlatform(const AsyncExecutorPtr& asyncExecutor, CreationParameters&& creationParams)
       : Platform(std::move(creationParams)), asyncExecutor(asyncExecutor)
     {
     }
     ~DefaultPlatform();
 
     void WithTimer(const WithTimerCallback&) override;
     void WithFileSystem(const WithFileSystemCallback&) override;
     void WithWebRequest(const WithWebRequestCallback&) override;
     void WithLogSystem(const WithLogSystemCallback&) override;
 
   private:
-    std::shared_ptr<SharedAsyncExecutor> asyncExecutor;
+    AsyncExecutorPtr asyncExecutor;
     std::recursive_mutex interfacesMutex;
   };
 
   DefaultPlatform::~DefaultPlatform()
   {
     asyncExecutor->Invalidate();
     LogSystemPtr tmpLogSystem;
     TimerPtr tmpTimer;
     FileSystemPtr tmpFileSystem;
     WebRequestPtr tmpWebRequest;
@@ skipping 70 matching lines @@
   if (!timer)
     CreateDefaultTimer();
   if (!fileSystem)
     CreateDefaultFileSystem();
   if (!webRequest)
     CreateDefaultWebRequest();
 
   std::unique_ptr<Platform> platform(new DefaultPlatform(sharedAsyncExecutor, std::move(*this)));
   return platform;
 }