Windows specific changes. All tests passing on Windows.

src/GlobalJsObject.cpp

 #include <vector>
 #include <stdexcept>
 
 #include "GlobalJsObject.h"
 #include "Thread.h"
 
 using namespace AdblockPlus;
 
 namespace
 {
@@ skipping 32 matching lines @@
       for (Values::iterator it = functionArguments.begin();
            it != functionArguments.end(); it++)
         it->Dispose(isolate);
     }
 
     void Run()
     {
       Sleep(delay);
       const v8::Locker locker(isolate);
       const v8::HandleScope handleScope;
-      v8::Handle<v8::Value> argv = functionArguments.size() > 0 ? functionArguments[0] : v8::Handle<v8::Value>();
-      function->Call(function, functionArguments.size(), &argv);
+      v8::Handle<v8::Value> *argv = functionArguments.empty() ? 0 : &(functionArguments.front());

[Felix Dahlke, 2013/04/09 08:11:15]

Declaration type should be "v8::Handle<v8::Value>*" for consistency (just a
whitespace issue). Should also be *const, since I'm a const nazi.

Why is this necessary? size() and operator[]() should work fine...

I've seen Wladimir's comment about this in a mail but I don't see it here.
Anyway, passing a pointer here is exactly what we want, an std::vector is
guaranteed to store it's value in a single continuous array internally, so
taking the pointer to the first element is how you convert a std::vector to an
array. In constant time, too :)

+      function->Call(function, functionArguments.size(), argv);
       delete this;
     }
 
   private:
     typedef v8::Persistent<v8::Value> Value;
     typedef std::vector<Value> Values;
 
     v8::Isolate* const isolate;
     v8::Persistent<v8::Function> function;
     int delay;
@@ skipping 27 matching lines @@
   v8::HandleScope handleScope;
   const v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
   const v8::Handle<v8::ObjectTemplate> console =
     AdblockPlus::ConsoleJsObject::Create(errorCallback);
   global->Set(v8::String::New("console"), console);
   const v8::Handle<v8::FunctionTemplate> setTimeoutFunction =
     v8::FunctionTemplate::New(SetTimeoutCallback);
   global->Set(v8::String::New("setTimeout"), setTimeoutFunction);
   return handleScope.Close(global);
 }