Fixed a error #65 “Memory leak using EmbedHostObject”

Author: Taritsyn

src/JavaScriptEngineSwitcher.ChakraCore/ChakraCoreJsEngine.cs

@@ -22,12 +22,7 @@ This package does not contain the native implementations of ChakraCore. Therefor
  * JavaScriptEngineSwitcher.ChakraCore.Native.osx-x64</Description>
 		<PackageIconUrl>https://raw.githubusercontent.com/Taritsyn/JavaScriptEngineSwitcher/master/Icons/JavaScriptEngineSwitcher_ChakraCore_Logo128x128.png</PackageIconUrl>
 		<PackageTags>JavaScriptEngineSwitcher;JavaScript;ECMAScript;ChakraCore</PackageTags>
-		<PackageReleaseNotes>1. ChakraCore was updated to version 1.11.4;
-2. No longer used the old ChakraCore API for Windows (Internet Explorer-like API);
-3. Added a ability to interrupt execution of the script;
-4. Added a ability to pre-compile scripts;
-5. In configuration settings of the ChakraCore JS engine was added one new property - `MaxStackSize` (default `492` or `984` KB);
-6. Added support of .NET Framework 4.7.1, .NET Standard 2.0 and .NET Core App 2.1.</PackageReleaseNotes>
+		<PackageReleaseNotes>Fixed a error #65 “Memory leak using EmbedHostObject”.</PackageReleaseNotes>
 	</PropertyGroup>
 
 	<Import Project="../../build/common.props" />

src/JavaScriptEngineSwitcher.ChakraCore/JavaScriptEngineSwitcher.ChakraCore.csproj

@@ -10,6 +10,6 @@ internal static class DefaultExternalBufferFinalizeCallback
 		/// <summary>
 		/// Gets a instance of default callback for finalization of external buffer
 		/// </summary>
-		public static readonly JsObjectFinalizeCallback Instance = Marshal.FreeHGlobal;
+		public static readonly JsFinalizeCallback Instance = Marshal.FreeHGlobal;
 	}
 }

src/JavaScriptEngineSwitcher.ChakraCore/JsRt/DefaultExternalBufferFinalizeCallback.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+
+using JavaScriptEngineSwitcher.Core.Utilities;
+
+namespace JavaScriptEngineSwitcher.ChakraCore.JsRt.Embedding
+{
+	/// <summary>
+	/// Embedded item
+	/// </summary>
+	internal abstract class EmbeddedItem : IDisposable
+	{
+		/// <summary>
+		/// Host type
+		/// </summary>
+		private Type _hostType;
+
+		/// <summary>
+		/// Instance of host type
+		/// </summary>
+		private object _hostObject;
+
+		/// <summary>
+		/// JavaScript value created from an host item
+		/// </summary>
+		private readonly JsValue _scriptValue;
+
+		/// <summary>
+		/// List of native functions, that used to access to members of host item
+		/// </summary>
+		private IList<JsNativeFunction> _nativeFunctions;
+
+		/// <summary>
+		/// Flag indicating whether this object is disposed
+		/// </summary>
+		private readonly InterlockedStatedFlag _disposedFlag = new InterlockedStatedFlag();
+
+		/// <summary>
+		/// Gets a host type
+		/// </summary>
+		public Type HostType
+		{
+			get { return _hostType; }
+		}
+
+		/// <summary>
+		/// Gets a instance of host type
+		/// </summary>
+		public object HostObject
+		{
+			get { return _hostObject; }
+		}
+
+		/// <summary>
+		/// Gets a JavaScript value created from an host item
+		/// </summary>
+		public JsValue ScriptValue
+		{
+			get { return _scriptValue; }
+		}
+
+		/// <summary>
+		/// Gets a list of native functions, that used to access to members of host item
+		/// </summary>
+		public IList<JsNativeFunction> NativeFunctions
+		{
+			get { return _nativeFunctions; }
+		}
+
+		/// <summary>
+		/// Gets a value that indicates if the host item is an instance
+		/// </summary>
+		public abstract bool IsInstance
+		{
+			get;
+		}
+
+
+		/// <summary>
+		/// Constructs an instance of the embedded item
+		/// </summary>
+		/// <param name="hostType">Host type</param>
+		/// <param name="hostObject">Instance of host type</param>
+		/// <param name="scriptValue">JavaScript value created from an host item</param>
+		/// <param name="nativeFunctions">List of native functions, that used to access to members of host item</param>
+		protected EmbeddedItem(Type hostType, object hostObject, JsValue scriptValue,
+			IList<JsNativeFunction> nativeFunctions)
+		{
+			_hostType = hostType;
+			_hostObject = hostObject;
+			_scriptValue = scriptValue;
+			_nativeFunctions = nativeFunctions;
+		}
+
+
+		#region IDisposable implementation
+
+		/// <summary>
+		/// Disposes the embedded item
+		/// </summary>
+		public void Dispose()
+		{
+			if (_disposedFlag.Set())
+			{
+				_hostType = null;
+				_hostObject = null;
+
+				IList<JsNativeFunction> nativeFunctions = _nativeFunctions;
+				if (nativeFunctions != null)
+				{
+					nativeFunctions.Clear();
+					_nativeFunctions = null;
+				}
+			}
+		}
+
+		#endregion
+	}
+}

src/JavaScriptEngineSwitcher.ChakraCore/JsRt/Embedding/EmbeddedItem.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+
+namespace JavaScriptEngineSwitcher.ChakraCore.JsRt.Embedding
+{
+	/// <summary>
+	/// Embedded object
+	/// </summary>
+	internal sealed class EmbeddedObject : EmbeddedItem
+	{
+		/// <summary>
+		/// Constructs an instance of the embedded object
+		/// </summary>
+		/// <param name="hostObject">Instance of host type</param>
+		/// <param name="scriptValue">JavaScript value created from an host object</param>
+		public EmbeddedObject(object hostObject, JsValue scriptValue)
+			: base(hostObject.GetType(), hostObject, scriptValue, new List<JsNativeFunction>())
+		{ }
+
+		/// <summary>
+		/// Constructs an instance of the embedded object
+		/// </summary>
+		/// <param name="hostObject">Instance of host type</param>
+		/// <param name="scriptValue">JavaScript value created from an host object</param>
+		/// <param name="nativeFunctions">List of native functions, that used to access to members of host object</param>
+		public EmbeddedObject(object hostObject, JsValue scriptValue,
+			IList<JsNativeFunction> nativeFunctions)
+			: base(hostObject.GetType(), hostObject, scriptValue, nativeFunctions)
+		{ }
+
+		#region EmbeddedItem overrides
+
+		/// <summary>
+		/// Gets a value that indicates if the host item is an instance
+		/// </summary>
+		public override bool IsInstance
+		{
+			get { return true; }
+		}
+
+		#endregion
+	}
+}

src/JavaScriptEngineSwitcher.ChakraCore/JsRt/Embedding/EmbeddedObject.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+using JavaScriptEngineSwitcher.ChakraCore.Resources;
+
+namespace JavaScriptEngineSwitcher.ChakraCore.JsRt.Embedding
+{
+	/// <summary>
+	/// Key for storage of embedded objects
+	/// </summary>
+	internal struct EmbeddedObjectKey : IEquatable<EmbeddedObjectKey>, IStructuralEquatable,
+		IComparable, IComparable<EmbeddedObjectKey>, IStructuralComparable
+	{
+		/// <summary>
+		/// Name of host type
+		/// </summary>
+		public readonly string HostTypeName;
+
+		/// <summary>
+		/// Instance of host type
+		/// </summary>
+		public readonly object HostObject;
+
+
+		/// <summary>
+		/// Constructs an instance of the key for storage of embedded objects
+		/// </summary>
+		/// <param name="hostObject">Instance of host type</param>
+		public EmbeddedObjectKey(object hostObject)
+		{
+			HostTypeName = hostObject.GetType().AssemblyQualifiedName;
+			HostObject = hostObject;
+		}
+
+
+		private static int CombineHashCodes(int h1, int h2)
+		{
+			return ((h1 << 5) + h1) ^ h2;
+		}
+
+		#region IEquatable<EmbeddedObjectKey> implementation
+
+		public bool Equals(EmbeddedObjectKey other)
+		{
+			return EqualityComparer<string>.Default.Equals(HostTypeName, other.HostTypeName)
+				&& EqualityComparer<object>.Default.Equals(HostObject, other.HostObject);
+		}
+
+		#endregion
+
+		#region IStructuralEquatable implementation
+
+		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
+		{
+			if (other == null || !(other is EmbeddedObjectKey))
+			{
+				return false;
+			}
+
+			var embeddedObjectKey = (EmbeddedObjectKey)other;
+
+			return comparer.Equals(HostTypeName, embeddedObjectKey.HostTypeName)
+				&& comparer.Equals(HostObject, embeddedObjectKey.HostObject);
+		}
+
+		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
+		{
+			return CombineHashCodes(comparer.GetHashCode(HostTypeName), comparer.GetHashCode(HostObject));
+		}
+
+		#endregion
+
+		#region IComparable implementation
+
+		int IComparable.CompareTo(object other)
+		{
+			if (other == null)
+			{
+				return 1;
+			}
+
+			if (!(other is EmbeddedObjectKey))
+			{
+				throw new ArgumentException(
+					string.Format(Strings.Common_ArgumentHasIncorrectType, nameof(other), other.GetType().Name),
+					nameof(other)
+				);
+			}
+
+			return CompareTo((EmbeddedObjectKey)other);
+		}
+
+		#endregion
+
+		#region IComparable<EmbeddedObjectKey> implementation
+
+		public int CompareTo(EmbeddedObjectKey other)
+		{
+			int c = Comparer<string>.Default.Compare(HostTypeName, other.HostTypeName);
+			if (c != 0)
+			{
+				return c;
+			}
+
+			return Comparer<object>.Default.Compare(HostObject, other.HostObject);
+		}
+
+		#endregion
+
+		#region IStructuralComparable implementation
+
+		int IStructuralComparable.CompareTo(object other, IComparer comparer)
+		{
+			if (other == null)
+			{
+				return 1;
+			}
+
+			if (!(other is EmbeddedObjectKey))
+			{
+				throw new ArgumentException(
+					string.Format(Strings.Common_ArgumentHasIncorrectType, nameof(other), other.GetType().Name),
+					nameof(other)
+				);
+			}
+
+			var embeddedObjectKey = (EmbeddedObjectKey)other;
+
+			int c = comparer.Compare(HostTypeName, embeddedObjectKey.HostTypeName);
+			if (c != 0)
+			{
+				return c;
+			}
+
+			return comparer.Compare(HostObject, embeddedObjectKey.HostObject);
+		}
+
+		#endregion
+
+		#region Object overrides
+
+		public override bool Equals(object obj)
+		{
+			return obj is EmbeddedObjectKey && Equals((EmbeddedObjectKey)obj);
+		}
+
+		public override int GetHashCode()
+		{
+			return CombineHashCodes(EqualityComparer<string>.Default.GetHashCode(HostTypeName),
+				EqualityComparer<object>.Default.GetHashCode(HostObject));
+		}
+
+		public override string ToString()
+		{
+			return "(" + HostTypeName?.ToString() + ", " + HostObject?.ToString() + ")";
+		}
+
+		#endregion
+	}
+}

src/JavaScriptEngineSwitcher.ChakraCore/JsRt/Embedding/EmbeddedObjectKey.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+
+namespace JavaScriptEngineSwitcher.ChakraCore.JsRt.Embedding
+{
+	/// <summary>
+	/// Embedded type
+	/// </summary>
+	internal sealed class EmbeddedType : EmbeddedItem
+	{
+		/// <summary>
+		/// Constructs an instance of the embedded type
+		/// </summary>
+		/// <param name="hostType">Host type</param>
+		/// <param name="scriptValue">JavaScript value created from an host type</param>
+		public EmbeddedType(Type hostType, JsValue scriptValue)
+			: base(hostType, null, scriptValue, new List<JsNativeFunction>())
+		{ }
+
+		/// <summary>
+		/// Constructs an instance of the embedded type
+		/// </summary>
+		/// <param name="hostType">Host type</param>
+		/// <param name="scriptValue">JavaScript value created from an host type</param>
+		/// <param name="nativeFunctions">List of native functions, that used to access to members of type</param>
+		public EmbeddedType(Type hostType, JsValue scriptValue, IList<JsNativeFunction> nativeFunctions)
+			: base(hostType, null, scriptValue, nativeFunctions)
+		{ }
+
+		#region EmbeddedItem overrides
+
+		/// <summary>
+		/// Gets a value that indicates if the host item is an instance
+		/// </summary>
+		public override bool IsInstance
+		{
+			get { return false; }
+		}
+
+		#endregion
+	}
+}