Implement File API

src/FileSystemJsObject.cpp

 #include <AdblockPlus/FileSystem.h>
 #include <stdexcept>
 #include <sstream>
 #include <vector>
 
 #include "FileSystemJsObject.h"
 #include "Utils.h"
 #include "Thread.h"
 #include "Utils.h"
 
@@ skipping 34 matching lines @@
       : IoThread(fileSystem, callback), path(path)
     {
     }
 
     void Run()
     {
       std::string content;
       std::string error;
       try
       {
-        std::auto_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 20 matching lines @@
                 const std::string& path, const std::string& content)
       : IoThread(fileSystem, callback), path(path), content(content)
     {
     }
 
     void Run()
     {
       std::string error;
       try
       {
-        fileSystem.Write(path, content);
+        std::tr1::shared_ptr<std::ostream> stream(new std::stringstream);
+        *stream << content;
+        fileSystem.Write(path, stream);
       }
       catch (std::exception& e)
       {
         error = e.what();
       }
       catch (...)
       {
         error = "Unknown error while writing to " + path;
       }
 
@@ skipping 128 matching lines @@
                      reinterpret_cast<v8::Handle<v8::Value>*>(&result));
       delete this;
     }
 
   private:
     std::string path;
   };
 
   v8::Handle<v8::Value> ReadCallback(const v8::Arguments& arguments)
   {
-    std::vector<std::string> requiredTypes;
-    requiredTypes.push_back("string");
-    requiredTypes.push_back("function");

[Wladimir Palant, 2013/04/16 06:50:13]

requiredTypes is no longer used - and arguments.Length() isn't being checked
(same in all other callbacks).

-    v8::TryCatch tryCatch;

[Wladimir Palant, 2013/04/16 06:50:13]

If you are using TryCatch then you might want to be consistent and have it in
all callbacks...

-    const v8::Handle<const v8::External> external =
-      v8::Handle<const v8::External>::Cast(arguments.Data());
-    FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
+    const v8::Handle<const v8::External> external =
+      v8::Handle<const v8::External>::Cast(arguments.Data());
+    FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
+    if (arguments.Length() != 2)
+      return v8::ThrowException(v8::String::New(
+        "_fileSystem.read requires 2 parameters"));
     const std::string path = Utils::FromV8String(arguments[0]);
     v8::Handle<v8::Value> callbackValue = arguments[1];
     if (!callbackValue->IsFunction())
       return v8::ThrowException(v8::String::New(
         "Second argument to _fileSystem.read must be a function"));
     v8::Handle<v8::Function> callback =
       v8::Handle<v8::Function>::Cast(callbackValue);
     ReadThread* const readThread = new ReadThread(*fileSystem, callback, path);
     readThread->Start();
-    if (tryCatch.HasCaught())
-      return tryCatch.Exception();
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> WriteCallback(const v8::Arguments& arguments)
   {
     const v8::Handle<const v8::External> external =
       v8::Handle<const v8::External>::Cast(arguments.Data());
     FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
+    if (arguments.Length() != 3)
+      return v8::ThrowException(v8::String::New(
+        "_fileSystem.write requires 3 parameters"));
     const std::string path = Utils::FromV8String(arguments[0]);
     const std::string content = Utils::FromV8String(arguments[1]);
     v8::Handle<v8::Value> callbackValue = arguments[2];
     if (!callbackValue->IsFunction())
       return v8::ThrowException(v8::String::New(
         "Third argument to _fileSystem.write must be a function"));
     v8::Handle<v8::Function> callback =
       v8::Handle<v8::Function>::Cast(callbackValue);
     WriteThread* const writeThread = new WriteThread(*fileSystem, callback,
                                                      path, content);
     writeThread->Start();
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> MoveCallback(const v8::Arguments& arguments)
   {
     const v8::Handle<const v8::External> external =
       v8::Handle<const v8::External>::Cast(arguments.Data());
     FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
+    if (arguments.Length() != 3)
+      return v8::ThrowException(v8::String::New(
+        "_fileSystem.move requires 3 parameters"));
     const std::string fromPath = Utils::FromV8String(arguments[0]);
     const std::string toPath = Utils::FromV8String(arguments[1]);
     v8::Handle<v8::Value> callbackValue = arguments[2];
     if (!callbackValue->IsFunction())
       return v8::ThrowException(v8::String::New(
         "Third argument to _fileSystem.move must be a function"));
     v8::Handle<v8::Function> callback =
       v8::Handle<v8::Function>::Cast(callbackValue);
     MoveThread* const moveThread = new MoveThread(*fileSystem, callback,
                                                   fromPath, toPath);
     moveThread->Start();
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> RemoveCallback(const v8::Arguments& arguments)
   {
     const v8::Handle<const v8::External> external =
       v8::Handle<const v8::External>::Cast(arguments.Data());
     FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
+    if (arguments.Length() != 2)
+      return v8::ThrowException(v8::String::New(
+        "_fileSystem.remove requires 2 parameters"));
     const std::string path = Utils::FromV8String(arguments[0]);
     v8::Handle<v8::Value> callbackValue = arguments[1];
     if (!callbackValue->IsFunction())
       return v8::ThrowException(v8::String::New(
         "Second argument to _fileSystem.remove must be a function"));
     v8::Handle<v8::Function> callback =
       v8::Handle<v8::Function>::Cast(callbackValue);
     RemoveThread* const removeThread = new RemoveThread(*fileSystem, callback,
                                                         path);
     removeThread->Start();
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> StatCallback(const v8::Arguments& arguments)
   {
     const v8::Handle<const v8::External> external =
       v8::Handle<const v8::External>::Cast(arguments.Data());
     FileSystem* const fileSystem = static_cast<FileSystem*>(external->Value());
+    if (arguments.Length() != 2)
+      return v8::ThrowException(v8::String::New(
+        "_fileSystem.stat requires 2 parameters"));
     const std::string path = Utils::FromV8String(arguments[0]);
     v8::Handle<v8::Value> callbackValue = arguments[1];
     if (!callbackValue->IsFunction())
       return v8::ThrowException(v8::String::New(
         "Second argument to _fileSystem.stat must be a function"));
     v8::Handle<v8::Function> callback =
       v8::Handle<v8::Function>::Cast(callbackValue);
     StatThread* const statThread = new StatThread(*fileSystem, callback, path);
     statThread->Start();
     return v8::Undefined();
@@ skipping 13 matching lines @@
   file->Set(v8::String::New("write"),
             v8::FunctionTemplate::New(WriteCallback, fileSystemExternal));
   file->Set(v8::String::New("move"),
             v8::FunctionTemplate::New(MoveCallback, fileSystemExternal));
   file->Set(v8::String::New("remove"),
             v8::FunctionTemplate::New(RemoveCallback, fileSystemExternal));
   file->Set(v8::String::New("stat"),
             v8::FunctionTemplate::New(StatCallback, fileSystemExternal));
   return handleScope.Close(file);
 }