Issue 4931 - add possibility to not send data depending on connection properties

src/FilterEngine.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 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 160 matching lines @@
   : jsEngine(jsEngine), firstRun(false), updateCheckId(0)
 {
 }
 
 void FilterEngine::CreateAsync(const JsEnginePtr& jsEngine,
   const FilterEngine::OnCreatedCallback& onCreated,
   const FilterEngine::CreateParameters& params)
 {
   FilterEnginePtr filterEngine(new FilterEngine(jsEngine));
   auto sync = std::make_shared<Sync>();
-  jsEngine->SetEventCallback("_init", [jsEngine, filterEngine, onCreated, sync](JsValueList& params)
+  auto isConnectionAllowed = params.isConnectionAllowed;

[Oleksandr, 2017/03/16 14:19:53]

The naming here is highly confusing, IMO. How about isConnectionAllowedCallback?

[sergei, 2017/03/16 16:25:22]

No objections, fixed.

+  if (isConnectionAllowed)
+    jsEngine->SetIsConnectionAllowedCallback([sync, jsEngine]()->bool
+    {
+      sync->Wait();
+      return jsEngine->IsConnectionAllowed();
+    });
+  jsEngine->SetEventCallback("_init", [jsEngine, filterEngine, onCreated, sync, isConnectionAllowed](JsValueList& params)
   {
     filterEngine->firstRun = params.size() && params[0]->AsBool();
+    if (isConnectionAllowed)
+    {
+      std::weak_ptr<FilterEngine> weakFilterEngine = filterEngine;
+      jsEngine->SetIsConnectionAllowedCallback([weakFilterEngine, isConnectionAllowed]()->bool
+      {
+        auto filterEngine = weakFilterEngine.lock();
+        if (!filterEngine)
+          return false;
+        return isConnectionAllowed(filterEngine->GetAllowedConnectionType().get());
+      });
+    }
     sync->Set();
     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
@@ skipping 226 matching lines @@
   JsValueList params;
   params.push_back(jsEngine->NewValue(pref));
   return func->Call(params);
 }
 
 void FilterEngine::SetPref(const std::string& pref, JsValuePtr value)
 {
   JsValuePtr func = jsEngine->Evaluate("API.setPref");
   JsValueList params;
   params.push_back(jsEngine->NewValue(pref));
-  params.push_back(value);
+  if (value)

[Oleksandr, 2017/03/16 14:19:53]

Nit: this doesn't look related, is it?

[sergei, 2017/03/16 16:25:22]

It's related, now we can call SetPref(nullptr) and if value is nullptr then it
crashes afterwards. nullptr here means there is no value, what is undefined in
terms of JavaScript, so we either should pass undefined or not pass the
argument. I have chosen the latter.

+    params.push_back(value);
   func->Call(params);
 }
 
 std::string FilterEngine::GetHostFromURL(const std::string& url)
 {
   JsValuePtr func = jsEngine->Evaluate("API.getHostFromUrl");
   JsValueList params;
   params.push_back(jsEngine->NewValue(url));
   return func->Call(params)->AsString();
 }
@@ skipping 46 matching lines @@
 {
   jsEngine->SetEventCallback("filterChange", std::bind(&FilterEngine::FilterChanged,
       this, callback, std::placeholders::_1));
 }
 
 void FilterEngine::RemoveFilterChangeCallback()
 {
   jsEngine->RemoveEventCallback("filterChange");
 }
 
+void FilterEngine::SetAllowedConnectionType(const std::string* value)
+{
+  SetPref("allowed_connection_type", value ? jsEngine->NewValue(*value) : nullptr);
+}
+
+std::unique_ptr<std::string> FilterEngine::GetAllowedConnectionType()
+{
+   auto prefValue = GetPref("allowed_connection_type");
+   if (prefValue->IsUndefined())
+     return nullptr;
+   return std::unique_ptr<std::string>(new std::string(prefValue->AsString()));
+}
+
 void FilterEngine::FilterChanged(FilterEngine::FilterChangeCallback callback, JsValueList& params)
 {
   std::string action(params.size() >= 1 && !params[0]->IsNull() ? params[0]->AsString() : "");
   JsValuePtr item(params.size() >= 2 ? params[1] : jsEngine->NewValue(false));
   callback(action, item);
 }
 
 void FilterEngine::ShowNotification(const ShowNotificationCallback& callback,
                                          const JsValueList& params)
 {
@@ skipping 45 matching lines @@
     FilterPtr filter = GetWhitelistingFilter(currentUrl, contentTypeMask, parentUrl);
     if (filter)
     {
       return filter;
     }
     currentUrl = parentUrl;
   }
   while (urlIterator != documentUrls.end());
   return FilterPtr();
 }