SubscriptionPtr FilterEngine::GetSubscription(const std::string& url)
{
JsValuePtr func = jsEngine->Evaluate("API.getSubscriptionFromUrl");
JsValueList params;
params.push_back(jsEngine->NewValue(url));
return SubscriptionPtr(new Subscription(std::move(*func->Call(params))));
}
void Subscription::AddToList()
{
JsValuePtr func = jsEngine->Evaluate("API.addSubscriptionToList");
JsValueList params;
params.push_back(shared_from_this());
func->Call(params);
}
AdblockPlus::JsValuePtr AdblockPlus::JsValue::Call(const JsValueList& params, JsValuePtr thisPtr) const
{
if (!IsFunction())
throw new std::runtime_error("Attempting to call a non-function");
const JsContext context(jsEngine);
if (!thisPtr)
{
v8::Local<v8::Context> localContext = v8::Local<v8::Context>::New(jsEngine->GetIsolate(), *jsEngine->context);
thisPtr = JsValuePtr(new JsValue(jsEngine, localContext->Global()));
}
if (!thisPtr->IsObject())
throw new std::runtime_error("`this` pointer has to be an object");
v8::Local<v8::Object> thisObj = v8::Local<v8::Object>::Cast(thisPtr->UnwrapValue());
std::vector<v8::Handle<v8::Value>> argv;
for (JsValueList::const_iterator it = params.begin(); it != params.end(); ++it)
argv.push_back((*it)->UnwrapValue());
const v8::TryCatch tryCatch;
v8::Local<v8::Function> func = v8::Local<v8::Function>::Cast(UnwrapValue());
v8::Local<v8::Value> result = func->Call(thisObj, argv.size(),
argv.size() ? &argv.front() : 0);
if (tryCatch.HasCaught())
throw JsError(tryCatch.Exception(), tryCatch.Message());
return JsValuePtr(new JsValue(jsEngine, result));
}
FilterPtr FilterEngine::GetFilter(const std::string& text)
{
JsValuePtr func = jsEngine->Evaluate("API.getFilterFromText");
JsValueList params;
params.push_back(jsEngine->NewValue(text));
return FilterPtr(new Filter(std::move(*func->Call(params))));
}
bool Subscription::IsListed()
{
JsValuePtr func = jsEngine->Evaluate("API.isListedSubscription");
JsValueList params;
params.push_back(shared_from_this());
return func->Call(params)->AsBool();
}
JsValuePtr FilterEngine::GetPref(const std::string& pref) const
{
JsValuePtr func = jsEngine->Evaluate("API.getPref");
JsValueList params;
params.push_back(jsEngine->NewValue(pref));
return func->Call(params);
}
FilterEngine::FilterEngine(JsEnginePtr jsEngine,
const FilterEngine::Prefs& preconfiguredPrefs)
: jsEngine(jsEngine), initialized(false), firstRun(false), updateCheckId(0)
{
jsEngine->SetEventCallback("_init", std::bind(&FilterEngine::InitDone,
this, std::placeholders::_1));
{
// 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
JsValuePtr preconfiguredPrefsObject = jsEngine->NewObject();
for (FilterEngine::Prefs::const_iterator it = preconfiguredPrefs.begin();
it != 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)
jsEngine->Evaluate(jsSources[i + 1], jsSources[i]);
}
// TODO: This should really be implemented via a conditional variable
while (!initialized)
::Sleep(10);
}
void Subscription::UpdateFilters()
{
JsValuePtr func = jsEngine->Evaluate("API.updateSubscription");
JsValueList params;
params.push_back(shared_from_this());
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();
}
void Filter::RemoveFromList()
{
JsValuePtr func = jsEngine->Evaluate("API.removeFilterFromList");
JsValueList params;
params.push_back(shared_from_this());
func->Call(params);
}
bool Subscription::IsUpdating()
{
JsValuePtr func = jsEngine->Evaluate("API.isSubscriptionUpdating");
JsValueList params;
params.push_back(shared_from_this());
JsValuePtr result = func->Call(params);
return result->AsBool();
}
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);
func->Call(params);
}
int FilterEngine::CompareVersions(const std::string& v1, const std::string& v2)
{
JsValueList params;
params.push_back(jsEngine->NewValue(v1));
params.push_back(jsEngine->NewValue(v2));
JsValuePtr func = jsEngine->Evaluate("API.compareVersions");
return func->Call(params)->AsInt();
}
std::vector<SubscriptionPtr> FilterEngine::FetchAvailableSubscriptions() const
{
JsValuePtr func = jsEngine->Evaluate("API.getRecommendedSubscriptions");
JsValueList values = func->Call()->AsList();
std::vector<SubscriptionPtr> result;
for (JsValueList::iterator it = values.begin(); it != values.end(); it++)
result.push_back(SubscriptionPtr(new Subscription(std::move(**it))));
return result;
}
std::vector<FilterPtr> FilterEngine::GetListedFilters() const
{
JsValuePtr func = jsEngine->Evaluate("API.getListedFilters");
JsValueList values = func->Call()->AsList();
std::vector<FilterPtr> result;
for (JsValueList::iterator it = values.begin(); it != values.end(); it++)
result.push_back(FilterPtr(new Filter(std::move(**it))));
return result;
}
NotificationPtr FilterEngine::GetNextNotificationToShow(const std::string& url)
{
JsValuePtr func = jsEngine->Evaluate("API.getNextNotificationToShow");
JsValueList params;
if (!url.empty())
{
params.push_back(jsEngine->NewValue(url));
}
return Notification::JsValueToNotification(func->Call(params));
}
void FilterEngine::ShowNextNotification(const std::string& url)
{
JsValuePtr func = jsEngine->Evaluate("API.showNextNotification");
JsValueList params;
if (!url.empty())
{
params.push_back(jsEngine->NewValue(url));
}
func->Call(params);
}
std::vector<std::string> FilterEngine::GetElementHidingSelectors(const std::string& domain) const
{
JsValuePtr func = jsEngine->Evaluate("API.getElementHidingSelectors");
JsValueList params;
params.push_back(jsEngine->NewValue(domain));
JsValueList result = func->Call(params)->AsList();
std::vector<std::string> selectors;
for (JsValueList::iterator it = result.begin(); it != result.end(); ++it)
selectors.push_back((*it)->AsString());
return selectors;
}
void FilterEngine::ForceUpdateCheck(FilterEngine::UpdaterCallback callback)
{
std::string eventName = "updateCheckDone";
eventName += ++updateCheckId;
jsEngine->SetEventCallback(eventName, std::tr1::bind(&FilterEngine::UpdateCheckDone,
this, eventName, callback, std::tr1::placeholders::_1));
JsValuePtr func = jsEngine->Evaluate("API.forceUpdateCheck");
JsValueList params;
params.push_back(jsEngine->NewValue(eventName));
func->Call(params);
}
AdblockPlus::FilterPtr FilterEngine::CheckFilterMatch(const std::string& url,
ContentType contentType,
const std::string& documentUrl) const
{
JsValuePtr func = jsEngine->Evaluate("API.checkFilterMatch");
JsValueList params;
params.push_back(jsEngine->NewValue(url));
params.push_back(jsEngine->NewValue(ContentTypeToString(contentType)));
params.push_back(jsEngine->NewValue(documentUrl));
JsValuePtr result = func->Call(params);
if (!result->IsNull())
return FilterPtr(new Filter(std::move(*result)));
else
return FilterPtr();
}
std::vector<std::string> Notification::GetLinks() const
{
std::vector<std::string> retValue;
JsValuePtr jsLinks = GetProperty("links");
if (!jsLinks->IsArray())
{
return retValue;
}
JsValueList urlLinksList = jsLinks->AsList();
for (JsValueList::const_iterator linkIterator = urlLinksList.begin();
linkIterator != urlLinksList.end(); ++linkIterator)
{
retValue.push_back((*linkIterator)->AsString());
}
return retValue;
}
NotificationTexts Notification::GetTexts() const
{
JsValuePtr jsTexts = jsEngine->Evaluate("API.getNotificationTexts")->Call(*this);
NotificationTexts notificationTexts;
JsValuePtr jsTitle = jsTexts->GetProperty("title");
if (jsTitle->IsString())
{
notificationTexts.title = jsTitle->AsString();
}
JsValuePtr jsMessage = jsTexts->GetProperty("message");
if (jsMessage->IsString())
{
notificationTexts.message = jsMessage->AsString();
}
return notificationTexts;
}
JsValuePtr FileSystemJsObject::Setup(JsEnginePtr jsEngine, JsValuePtr obj)
{
obj->SetProperty("read", jsEngine->NewCallback(::ReadCallback));
obj->SetProperty("write", jsEngine->NewCallback(::WriteCallback));
obj->SetProperty("move", jsEngine->NewCallback(::MoveCallback));
obj->SetProperty("remove", jsEngine->NewCallback(::RemoveCallback));
obj->SetProperty("stat", jsEngine->NewCallback(::StatCallback));
obj->SetProperty("resolve", jsEngine->NewCallback(::ResolveCallback));
return obj;
}
JsValuePtr GlobalJsObject::Setup(JsEnginePtr jsEngine, const AppInfo& appInfo,
JsValuePtr obj)
{
obj->SetProperty("setTimeout", jsEngine->NewCallback(::SetTimeoutCallback));
obj->SetProperty("_triggerEvent", jsEngine->NewCallback(::TriggerEventCallback));
obj->SetProperty("_fileSystem",
FileSystemJsObject::Setup(jsEngine, jsEngine->NewObject()));
obj->SetProperty("_webRequest",
WebRequestJsObject::Setup(jsEngine, jsEngine->NewObject()));
obj->SetProperty("console",
ConsoleJsObject::Setup(jsEngine, jsEngine->NewObject()));
obj->SetProperty("_appInfo",
AppInfoJsObject::Setup(jsEngine, appInfo, jsEngine->NewObject()));
return obj;
}
void AdblockPlus::JsValue::SetProperty(const std::string& name, const JsValuePtr& val)
{
const JsContext context(jsEngine);
SetProperty(name, val->UnwrapValue());
}
