Issue #4692 - Rewrite I/O tasks to avoid engine self-reference

src/JsEngine.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
  * 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 <AdblockPlus.h>
+#include "FileSystemJsObject.h"
 #include "GlobalJsObject.h"
 #include "JsContext.h"
 #include "JsEngineInternal.h"
 #include "JsEngineTransition.h"
 #include "JsError.h"
 #include "Scheduler.h"
 #include "Utils.h"
 #include "WebRequestJsObject.h"
 
 const AdblockPlus::ImmediateSingleUseThreadType AdblockPlus::ImmediateSingleUseThread = {};
@@ skipping 75 matching lines @@
 JsEngineInternal::JsEngineInternal(const AdblockPlus::ScopedV8IsolatePtr& isolate)
   : AdblockPlus::JsEngine(isolate),
   context(isolate->Get(),v8::Context::New(isolate->Get()))
 {
   /*
    * Enter v8 scope for our context so that we can initialize its global object.
    */
   const v8::Context::Scope contextScope(GetContextAsLocal());
   auto globalObject = GetGlobalObject();
   // Timeout
-  auto propertyName = AdblockPlus::Utils::ToV8String(GetIsolate(), "setTimeout");
-  globalObject->Set(propertyName, MakeCallback(::CallbackForSetTimeout));
+  globalObject->Set(ToV8String("setTimeout"), MakeCallback(::CallbackForSetTimeout));
   // Web request
   auto auxiliaryObject = v8::Object::New();
-  propertyName = AdblockPlus::Utils::ToV8String(GetIsolate(), "GET");
-  auxiliaryObject->Set(propertyName, MakeCallback(::GETCallback));
-  propertyName = AdblockPlus::Utils::ToV8String(GetIsolate(), "_webRequest");
-  globalObject->Set(propertyName, auxiliaryObject);
+  auxiliaryObject->Set(ToV8String("GET"), MakeCallback(::GETCallback));
+  globalObject->Set(ToV8String("_webRequest"), auxiliaryObject);
+  // File system I/O
+  auxiliaryObject = v8::Object::New();
+  auxiliaryObject->Set(ToV8String("read"), MakeCallback(::ReadCallback));
+  auxiliaryObject->Set(ToV8String("write"), MakeCallback(::WriteCallback));
+  auxiliaryObject->Set(ToV8String("move"), MakeCallback(::MoveCallback));
+  auxiliaryObject->Set(ToV8String("remove"), MakeCallback(::RemoveCallback));
+  auxiliaryObject->Set(ToV8String("stat"), MakeCallback(::StatCallback));
+  auxiliaryObject->Set(ToV8String("resolve"), MakeCallback(::ResolveCallback));
+  globalObject->Set(ToV8String("_fileSystem"), auxiliaryObject);
+
   // TODO: Move the rest of the global object initializations here
 }
 
 /**
  * \par Design Notes
  * It is technically necessary to construct JsEngine instances *only* within a factory.
  * Initialization requires that certain transient v8 scopes be set up 
  *   before initialization and torn down afterwards.
  * C++ has no syntax to use anything like a sentry object in the constructor itself.
  * Thus we need to establish v8 scope within every C++ scope that constructs an object.
@@ skipping 166 matching lines @@
 v8::Local<v8::Function> JsEngineInternal::MakeCallback(v8::InvocationCallback callback)
 {
   return v8::FunctionTemplate::New(callback, v8::External::New(this))->GetFunction();
 }
 
 JsEngineInternal* JsEngineInternal::ExtractEngine(const v8::Arguments& arguments)
 {
   return static_cast<JsEngineInternal*>(v8::Local<v8::External>::Cast(arguments.Data())->Value());
 }
 
+v8::Local<v8::String> JsEngineInternal::ToV8String(const std::string& s)
+{
+  return AdblockPlus::Utils::ToV8String(GetIsolate(), s);
+}
+
 AdblockPlus::JsValueList AdblockPlus::JsEngine::ConvertArguments(const v8::Arguments& arguments)
 {
   const JsContext context(shared_from_this());
   JsValueList list;
   for (int i = 0; i < arguments.Length(); i++)
     list.push_back(JsValuePtr(new JsValue(shared_from_this(), arguments[i])));
   return list;
 }
 
 AdblockPlus::FileSystemPtr AdblockPlus::JsEngine::GetFileSystem()
@@ skipping 66 matching lines @@
 
 JsEngineInternal* ToInternal(AdblockPlus::JsEnginePtr p)
 {
   return static_cast<JsEngineInternal*>(p.get());
 }
 
 JsEngineInternal* ToInternal(AdblockPlus::JsEngine* p)
 {
   return static_cast<JsEngineInternal*>(p);
 }