Issue 5182 - fix IsConnectionAllowed

src/FilterEngine.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <algorithm>
 #include <cctype>
 #include <functional>
 #include <string>
+#include <cassert>
+#include <thread>
 
 #include <AdblockPlus.h>
 #include "JsContext.h"
 #include "Thread.h"
 #include <mutex>
 #include <condition_variable>
 
 using namespace AdblockPlus;
 
 extern std::string jsSources[];
@@ skipping 180 matching lines @@
 FilterEngine::FilterEngine(const JsEnginePtr& jsEngine)
   : jsEngine(jsEngine), firstRun(false), updateCheckId(0)
 {
 }
 
 void FilterEngine::CreateAsync(const JsEnginePtr& jsEngine,
   const FilterEngine::OnCreatedCallback& onCreated,
   const FilterEngine::CreationParameters& params)
 {
   FilterEnginePtr filterEngine(new FilterEngine(jsEngine));
-  auto sync = std::make_shared<Sync>();
-  auto isConnectionAllowedCallback = params.isConnectionAllowedCallback;
-  if (isConnectionAllowedCallback)
-    jsEngine->SetIsConnectionAllowedCallback([sync, jsEngine]()->bool
-    {
-      sync->Wait();
-      return jsEngine->IsConnectionAllowed();
-    });
-  jsEngine->SetEventCallback("_init", [jsEngine, filterEngine, onCreated, sync, isConnectionAllowedCallback](JsValueList&& params)
   {
-    filterEngine->firstRun = params.size() && params[0].AsBool();
-    if (isConnectionAllowedCallback)
-    {
-      std::weak_ptr<FilterEngine> weakFilterEngine = filterEngine;
-      jsEngine->SetIsConnectionAllowedCallback([weakFilterEngine, isConnectionAllowedCallback]()->bool
+    // TODO: replace weakFilterEngine by this when it's possible to control the
+    // execution time of the asynchronous part below.
+    std::weak_ptr<FilterEngine> weakFilterEngine = filterEngine;
+    auto isConnectionAllowedCallback = params.isConnectionAllowedCallback;
+    jsEngine->SetEventCallback("_isSubscriptionDownloadAllowed", [weakFilterEngine, isConnectionAllowedCallback](JsValueList&& params){
+      auto filterEngine = weakFilterEngine.lock();
+      if (!filterEngine)
+        return;
+      auto jsEngine = filterEngine->GetJsEngine();
+
+      // param[0] - nullable string Prefs.allowed_connection_type
+      // param[1] - function(Boolean)
+      bool areArgumentsValid = params.size() == 2 && (params[0].IsNull() || params[0].IsString()) && params[1].IsFunction();
+      assert(areArgumentsValid && "Invalid argument: there should be two args and the second one should be a function");
+      if (!areArgumentsValid)
+        return;
+      if (!isConnectionAllowedCallback)
+      {
+        params[1].Call(jsEngine->NewValue(true));
+        return;
+      }
+      auto valuesID = jsEngine->StoreJsValues(params);
+      auto callJsCallback = [weakFilterEngine, valuesID](bool isAllowed)
       {
         auto filterEngine = weakFilterEngine.lock();
         if (!filterEngine)
-          return false;
-        return isConnectionAllowedCallback(filterEngine->GetAllowedConnectionType().get());
-      });
-    }
-    sync->Set();
+          return;
+        auto jsEngine = filterEngine->GetJsEngine();
+        auto jsParams = jsEngine->TakeJsValues(valuesID);
+        jsParams[1].Call(jsEngine->NewValue(isAllowed));
+      };
+      std::shared_ptr<std::string> allowedConnectionType = params[0].IsString() ? std::make_shared<std::string>(params[0].AsString()) : nullptr;
+      // temporary hack with thread:
+      std::thread([isConnectionAllowedCallback, allowedConnectionType, callJsCallback]
+      {
+        callJsCallback(isConnectionAllowedCallback(allowedConnectionType.get()));
+      }).detach();
+    });
+  }
+  
+  jsEngine->SetEventCallback("_init", [jsEngine, filterEngine, onCreated](JsValueList&& params)
+  {
+    filterEngine->firstRun = params.size() && params[0].AsBool();
     onCreated(filterEngine);
     jsEngine->RemoveEventCallback("_init");
   });
 
   // Lock the JS engine while we are loading scripts, no timeouts should fire
   // until we are done.
   const JsContext context(*jsEngine);
-
   // Set the preconfigured prefs
   auto preconfiguredPrefsObject = jsEngine->NewObject();
   for (FilterEngine::Prefs::const_iterator it = params.preconfiguredPrefs.begin();
     it != params.preconfiguredPrefs.end(); it++)
   {
     preconfiguredPrefsObject.SetProperty(it->first, it->second);
   }
   jsEngine->SetGlobalProperty("_preconfiguredPrefs", preconfiguredPrefsObject);
   // Load adblockplus scripts
   for (int i = 0; !jsSources[i].empty(); i += 2)
@@ skipping 346 matching lines @@
     FilterPtr filter = GetWhitelistingFilter(currentUrl, contentTypeMask, parentUrl);
     if (filter)
     {
       return filter;
     }
     currentUrl = parentUrl;
   }
   while (urlIterator != documentUrls.end());
   return FilterPtr();
 }