Issue #4692 - Move responsibility for engine reference from tasks to scheduler

src/WebRequestJsObject.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 12 matching lines @@
 #include "JsEngineTransition.h"
 #include "Utils.h"
 #include "Scheduler.h"
 #include "V8Upgrade.h"
 #include "Value.h"
 #include "WebRequestJsObject.h"
 
 namespace
 {
   class WebRequestTask
+    : public TaskFunctionInterface
   {
   public:
     WebRequestTask(
       JsEngineInternal *engine,
       std::string url,
       AdblockPlus::HeaderList headers,
       V8PersistentNG<v8::Function> callbackFunction
     )
-      : jsEngine(engine->shared_from_this()),
+      : engine(engine),
       url(url), headers(headers), callbackFunction(callbackFunction)
     {}
 
-    void operator()()
+    void operator()() override
     {
-      auto engine = ToInternal(jsEngine); // temporary statement while task keeps its own engine alive
       /*
        * Synchronous HTTP GET request is arbitrary-duration and not interruptible
        */
       AdblockPlus::ServerResponse result = engine->GetWebRequest()->GET(url, headers);
       /*
        * Instantiate our scope after the long-lived operation above.
        */
       V8ExecutionScope sentry(engine);
       auto isolate = engine->GetIsolate();
 
@@ skipping 12 matching lines @@
       // Call the callback
       auto args = AllocatedArray<v8::Local<v8::Value>>(1);
       args[0] = response;
       engine->ApplyFunction(callbackFunction.Get(isolate), std::move(args));
     }
 
   private:
     /**
      * Engine pointer keeps engine in existence across thread boundary
      */
-    AdblockPlus::JsEnginePtr jsEngine;
+    JsEngineInternal *engine;
     std::string url;
     AdblockPlus::HeaderList headers;
     V8PersistentNG<v8::Function> callbackFunction;
   };
 }
 
 /**
  * Implementing function for JS "<global>._webrequest.GET()".
  * 
  * Used in "compat.js" to implement "XMLHttpRequest.send()" for GET requests.
  *
  * \par JavaScript arguments
  * 1. url.
  *   The URL of the resource to which the request will be sent.
  * 2. requestHeaders. 
  *   An object whose properties represent HTTP GET request headers.
  *   These properties are added to the GET request.
  * 3. readyCallback.
  *   A function to be executed when the GET response is ready.
  *   The argument of this call is an object encoding the GET response.
  */
 v8::Handle<v8::Value> GETCallback(const v8::Arguments& arguments)
 {
   auto engine = JsEngineInternal::ExtractEngine(arguments);
   V8ExecutionScope sentry(engine);
 
   /*
    * Factory block for WebRequest tasks.
    */
-  std::shared_ptr<WebRequestTask> task;
   try
   {
     std::string url;
     if (arguments.Length() != 3u)
     {
       throw std::runtime_error("GET requires exactly 3 arguments");
     }
     bool b;
     std::tie(b, url) = ConvertString(arguments[0]);
     if (!b)
@@ skipping 24 matching lines @@
       {
         headers.push_back(std::make_pair(propertyName, propertyValue));
       }
     }
 
     auto callbackArg = arguments[2];
     if (!callbackArg->IsFunction())
     {
       throw std::runtime_error("Third argument to GET must be a function");
     }
-    task = std::make_shared<WebRequestTask>(engine, url, headers, 
+    WebRequestTask task(engine, url, headers,
       V8PersistentNG<v8::Function>(engine->GetIsolate(), v8::Local<v8::Function>::Cast(arguments[2])));
+    /*
+    * Run the task
+    */
+    engine->ScheduleTask(std::move(task), ImmediateSingleUseThread);
+    return v8::Undefined();
   }
   catch (const std::exception& e)
   {
     using AdblockPlus::Utils::ToV8String;
     v8::Isolate* isolate = arguments.GetIsolate();
     return v8::ThrowException(ToV8String(isolate, e.what()));
   }
-  /*
-   * Run the task
-   */
-  engine->Schedule(AdblockPlus::MakeHeapFunction(task), AdblockPlus::ImmediateSingleUseThread);
-  return v8::Undefined();
 }