Merge lp:~abreu-alexandre/v8-cpp/call-to-v8-with-custom-receiver into lp:v8-cpp

[Alexandre Abreu]

Allow call to v8 be with a different object receiver than global

Allow call to v8 be with a different object receiver than global

[Marcus Tomlinson (marcustomlinson)]

+1

review: Approve

=== modified file 'src/call.h'
--- src/call.h	2015-08-05 18:57:44 +0000
+++ src/call.h	2015-09-18 18:43:09 +0000
@@ -27,7 +27,7 @@
 
 // Call a V8 function from C++
 template <typename... Args>
-v8::Local<v8::Value> call_v8(v8::Isolate* isolate, v8::Local<v8::Function> func, Args... args)
+v8::Local<v8::Value> call_v8_with_receiver(v8::Isolate* isolate, v8::Local<v8::Object> receiver, v8::Local<v8::Function> func, Args... args)
 {
     v8::EscapableHandleScope scope(isolate);
 
@@ -36,9 +36,16 @@
     // +1 for when arg_count == 0
     v8::Local<v8::Value> v8_args[arg_count + 1] = {to_v8(isolate, args)...};
 
-    v8::Local<v8::Value> result = func->Call(isolate->GetCurrentContext()->Global(), arg_count, v8_args);
+    v8::Local<v8::Value> result = func->Call(receiver, arg_count, v8_args);
 
     return scope.Escape(result);
 }
 
+// Call a V8 function from C++
+template <typename... Args>
+v8::Local<v8::Value> call_v8(v8::Isolate* isolate, v8::Local<v8::Function> func, Args... args)
+{
+  return call_v8_with_receiver(isolate, isolate->GetCurrentContext()->Global(), func, args...);
+}
+
 }  // namespace v8cpp
 
=== modified file 'tests/functions/module.cpp'
--- tests/functions/module.cpp	2015-08-05 18:57:44 +0000
+++ tests/functions/module.cpp	2015-09-18 18:43:09 +0000
@@ -31,12 +31,19 @@
     v8cpp::Class<TestCaller> testcaller(isolate);
     testcaller
             .set_constructor<Local<Function>>()
+            .add_method("get_shared", &TestCaller::get_shared)
+            .add_method("call_me_with_shared", &TestCaller::call_me_with_shared)
             .add_method("call_me", &TestCaller::call_me);
 
+    // Prepare Shared binding
+    v8cpp::Class<Shared> shared(isolate);
+    shared.add_method("get_value", &Shared::get_value);
+    
     // Prepare module
     v8cpp::Module module(isolate);
 
     module.add_class("TestCaller", testcaller);
+    module.add_class("Shared", shared);
     module.add_function("simple_function", &simple_function);
     module.add_function("complex_function", &complex_function);
 
 
=== modified file 'tests/functions/test.cpp'
--- tests/functions/test.cpp	2015-07-08 09:29:21 +0000
+++ tests/functions/test.cpp	2015-09-18 18:43:09 +0000
@@ -43,6 +43,23 @@
     EXPECT_EQ(callback_result, "hello world");
 }
 
+TEST(Test, call_to_js_with_self)
+{
+    auto callback_result = v8cpp::run_script<std::string>(
+    R"(
+        var module = require("./test-functions-module");
+
+        var caller = new module.TestCaller(function() {})
+
+        var s = caller.get_shared()
+        caller.call_me_with_shared(s, function() {
+            return this.get_value()
+        });
+    )");
+
+    EXPECT_EQ(callback_result, "hello");
+}
+
 TEST(Test, call_from_js)
 {
     auto result = v8cpp::run_script<std::string>(
 
=== modified file 'tests/functions/test.h'
--- tests/functions/test.h	2015-07-08 06:20:26 +0000
+++ tests/functions/test.h	2015-09-18 18:43:09 +0000
@@ -22,6 +22,15 @@
 
 #include <v8-cpp.h>
 
+class Shared
+{
+public:
+    std::string get_value() const
+    {
+      return std::string("hello");
+    }
+};
+
 class TestCaller
 {
 public:
@@ -37,6 +46,19 @@
         return v8cpp::from_v8<std::string>(v8::Isolate::GetCurrent(), result);
     }
 
+    std::shared_ptr<Shared> get_shared()
+    {
+        auto s = std::shared_ptr<Shared>(new Shared());
+        return s;
+    }
+
+    v8::Local<v8::Value>
+      call_me_with_shared(v8::Local<v8::Object> receiver,
+                          v8::Local<v8::Function> to_be_called_with_shared)
+    {
+        return v8cpp::call_v8_with_receiver(v8::Isolate::GetCurrent(), receiver, to_be_called_with_shared);
+    }
+
 private:
     v8::Persistent<v8::Function> cb_;
 };