Defended JavascriptFunction against use after a context has been disposed.

Author: oliverbock

Source/Noesis.Javascript/JavascriptFunction.cpp

@@ -41,7 +41,12 @@ JavascriptFunction::~JavascriptFunction()
 
 System::Object^ JavascriptFunction::Call(... cli::array<System::Object^>^ args)
 {
-	JavascriptScope scope(mContext);
+    if (mFuncHandle == nullptr)
+        throw gcnew JavascriptException(L"This function's owning JavascriptContext has been disposed");
+    if (!args)
+        throw gcnew System::ArgumentNullException("args");
+	
+    JavascriptScope scope(mContext);
 	v8::Isolate* isolate = mContext->GetCurrentIsolate();
 	HandleScope handleScope(isolate);
 
@@ -65,7 +70,12 @@ System::Object^ JavascriptFunction::Call(... cli::array<System::Object^>^ args)
 
 bool JavascriptFunction::operator==(JavascriptFunction^ func1, JavascriptFunction^ func2)
 {
-	if(ReferenceEquals(func2, nullptr)) {
+    if (func1->mFuncHandle == nullptr)
+        throw gcnew JavascriptException(L"'func1's owning JavascriptContext has been disposed");
+    if (func2->mFuncHandle == nullptr)
+        throw gcnew JavascriptException(L"'func2's owning JavascriptContext has been disposed");
+
+    if(ReferenceEquals(func2, nullptr)) {
 		return false;
 	}
 	Handle<Function> jsFuncPtr1 = func1->mFuncHandle->Get(func1->mContext->GetCurrentIsolate());
@@ -81,7 +91,10 @@ bool JavascriptFunction::Equals(JavascriptFunction^ other)
 
 bool JavascriptFunction::Equals(Object^ other)
 {
-	JavascriptFunction^ otherFunc = dynamic_cast<JavascriptFunction^>(other);
+    if (mFuncHandle == nullptr)
+        throw gcnew JavascriptException(L"This function's owning JavascriptContext has been disposed");
+    
+    JavascriptFunction^ otherFunc = dynamic_cast<JavascriptFunction^>(other);
 	return (otherFunc && this->Equals(otherFunc));
 }
 

Source/Noesis.Javascript/JavascriptFunction.h

@@ -17,7 +17,9 @@ namespace Noesis { namespace Javascript {
 //////////////////////////////////////////////////////////////////////////
 // JavascriptFunction
 //
-// Wraps around JS function object and allow calling it in later time
+// Wraps around a JS function when passed back to C#, allowing it to be
+// called from C#.  Callers must not dispose of their JavascriptContext
+// while they still have references to JavascriptFunctions.
 //////////////////////////////////////////////////////////////////////////
 public ref class JavascriptFunction
 {

Tests/Noesis.Javascript.Tests/JavascriptFunctionTests.cs

@@ -27,7 +27,7 @@ public void TearDown()
         public void GetFunctionExpressionFromJsContext()
         {
             _context.Run("a = function(a, b) { return a + b; }");
-            
+
             JavascriptFunction funcObj = _context.GetParameter("a") as JavascriptFunction;
             funcObj.Should().NotBeNull();
             funcObj.Call(1, 2).Should().BeOfType<int>().Which.Should().Be(3);
@@ -37,7 +37,7 @@ public void GetFunctionExpressionFromJsContext()
         public void GetNamedFunctionFromJsContext()
         {
             _context.Run("function test(a, b) { return a + b; }");
-            
+
             JavascriptFunction funcObj = _context.GetParameter("test") as JavascriptFunction;
             funcObj.Should().NotBeNull();
             funcObj.Call(1, 2).Should().BeOfType<int>().Which.Should().Be(3);
@@ -47,7 +47,7 @@ public void GetNamedFunctionFromJsContext()
         public void GetArrowFunctionExpressionFromJsContext()
         {
             _context.Run("a = (a, b) => a + b");
-            
+
             JavascriptFunction funcObj = _context.GetParameter("a") as JavascriptFunction;
             funcObj.Should().NotBeNull();
             funcObj.Call(1, 2).Should().BeOfType<int>().Which.Should().Be(3);
@@ -57,7 +57,7 @@ public void GetArrowFunctionExpressionFromJsContext()
         public void PassFunctionToMethodInManagedObjectAndUseItToFilterAList()
         {
             _context.SetParameter("collection", new CollectionWrapper());
-            
+
             var result = _context.Run("collection.Filter(x => x % 2 === 0)") as IEnumerable<int>;
             result.Should().NotBeNull();
             result.Should().BeEquivalentTo(2, 4);
@@ -73,6 +73,21 @@ public void ExceptionsAreHandledAndWrappedInAJavascriptExceptionObject()
         }
     }
 
+    [TestClass]
+    public class JavascriptFunctionTestsWithoutAutomaticContext
+    {
+        [TestMethod]
+        public void CannotUseAFunctionWhenItsContextIsDisposed()
+        {
+            JavascriptFunction function;
+            using (var context = new JavascriptContext()) {
+                function = context.Run("() => { throw new Error('test'); }") as JavascriptFunction;
+            }
+            Action action = () => function.Call();
+            action.ShouldThrowExactly<JavascriptException>().WithMessage("This function's owning JavascriptContext has been disposed");
+        }
+    }
+
     class CollectionWrapper
     {
         private IEnumerable<int> numbers = new List<int> { 1, 2, 3, 4, 5 };