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);

[Wladimir Palant, 2013/04/09 05:47:07]

No, this isn't right. You *copy* the first argument and then use the pointer to
this copy. What if there is more than one argument?

Ideally we would use functionArguments.data() here but that's C++11 again. So if
you really want to handle empty vectors properly I would go with:

  v8::Handle<v8::Value> *argv = functionArguments.empty() ? 0 :
&(functionArguments.front());

[Oleksandr, 2013/04/09 05:54:21]

Ah. You're right. My bad. 

It's not that I *wanted* to explicitly handle the empty vectors case, its just
that the test fails otherwise.

 
On 2013/04/09 05:47:07, Wladimir Palant wrote:

[Felix Dahlke, 2013/04/09 08:18:06]

Ah, just saw the original change here, didn't show up in the other diff so I
thought you had just replaced size() with empty() and the copy with a pointer.

We can actually just pass 0 here if it's empty, so I vote for:

function->Call(function, functionArguments.size(), functionArguments.size() ?
functionArguments[0] : 0);

+      v8::Handle<v8::Value>* argv = functionArguments.empty() ? 0 : &(functionArguments.front());
+      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);
 }