Convert references to FileSystem & Co. into shared pointers (avoid use after free)

src/FileSystemJsObject.cpp

 #include <AdblockPlus/FileSystem.h>
 #include <stdexcept>
 #include <sstream>
 #include <vector>
 
 #include <AdblockPlus/JsEngine.h>
 #include <AdblockPlus/JsValue.h>
 #include "FileSystemJsObject.h"
 #include "Utils.h"
 #include "Thread.h"
 #include "Utils.h"
 
 using namespace AdblockPlus;
 
 namespace
 {
   class IoThread : public Thread
   {
   public:
     IoThread(JsEngine& jsEngine, JsValuePtr callback)
       : jsEngine(jsEngine), fileSystem(jsEngine.GetFileSystem()),
         callback(callback)
     {
     }
 
   protected:
     JsEngine& jsEngine;
-    FileSystem& fileSystem;
+    FileSystemPtr fileSystem;
     JsValuePtr callback;
   };
 
   class ReadThread : public IoThread
   {
   public:
     ReadThread(JsEngine& jsEngine, JsValuePtr callback,
                const std::string& path)
       : IoThread(jsEngine, callback), path(path)
     {
     }
 
     void Run()
     {
       std::string content;
       std::string error;
       try
       {
-        std::tr1::shared_ptr<std::istream> stream = fileSystem.Read(path);
+        std::tr1::shared_ptr<std::istream> stream = fileSystem->Read(path);
         content = Utils::Slurp(*stream);
       }
       catch (std::exception& e)
       {
         error = e.what();
       }
       catch (...)
       {
         error =  "Unknown error while reading from " + path;
       }
@@ skipping 21 matching lines @@
     {
     }
 
     void Run()
     {
       std::string error;
       try
       {
         std::tr1::shared_ptr<std::ostream> stream(new std::stringstream);
         *stream << content;
-        fileSystem.Write(path, stream);
+        fileSystem->Write(path, stream);
       }
       catch (std::exception& e)
       {
         error = e.what();
       }
       catch (...)
       {
         error = "Unknown error while writing to " + path;
       }
 
@@ skipping 17 matching lines @@
                const std::string& fromPath, const std::string& toPath)
       : IoThread(jsEngine, callback), fromPath(fromPath), toPath(toPath)
     {
     }
 
     void Run()
     {
       std::string error;
       try
       {
-        fileSystem.Move(fromPath, toPath);
+        fileSystem->Move(fromPath, toPath);
       }
       catch (std::exception& e)
       {
         error = e.what();
       }
       catch (...)
       {
         error = "Unknown error while moving " + fromPath + " to " + toPath;
       }
 
@@ skipping 17 matching lines @@
                  const std::string& path)
       : IoThread(jsEngine, callback), path(path)
     {
     }
 
     void Run()
     {
       std::string error;
       try
       {
-        fileSystem.Remove(path);
+        fileSystem->Remove(path);
       }
       catch (std::exception& e)
       {
         error = e.what();
       }
       catch (...)
       {
         error = "Unknown error while removing " + path;
       }
 
@@ skipping 17 matching lines @@
       : IoThread(jsEngine, callback), path(path)
     {
     }
 
     void Run()
     {
       std::string error;
       FileSystem::StatResult statResult;
       try
       {
-        statResult = fileSystem.Stat(path);
+        statResult = fileSystem->Stat(path);
       }
       catch (std::exception& e)
       {
         error = e.what();
       }
       catch (...)
       {
         error = "Unknown error while calling stat on " + path;
       }
 
@@ skipping 103 matching lines @@
 
 JsValuePtr FileSystemJsObject::Setup(JsEngine& 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));
   return obj;
 }