Initial commit of reference counting code.

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/AnyRef.cs

@@ -3,25 +3,55 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
+using System.Threading;
+using Microsoft.Win32.SafeHandles;
 
 namespace System.Runtime.InteropServices.JavaScript
 {
-    public class AnyRef
+    public abstract class AnyRef : SafeHandleMinusOneIsInvalid
     {
-        public int JSHandle { get; internal set; }
-        internal GCHandle Handle;
+        public int JSHandle
+        {
+            get => (int)handle;
+        }
+
+        private AnyRef() : base(true) { }
+
+        internal GCHandle AnyRefHandle;
 
-        internal AnyRef(int jsHandle)
+        internal AnyRef(int js_handle, bool ownsHandle) : base(ownsHandle)
         {
-            JSHandle = jsHandle;
-            Handle = GCHandle.Alloc(this);
+            SetHandle((IntPtr)js_handle);
+            this.AnyRefHandle = GCHandle.Alloc(this, ownsHandle ? GCHandleType.Weak : GCHandleType.Normal);
         }
 
-        internal AnyRef(IntPtr jsHandle)
+        internal AnyRef(IntPtr js_handle, bool ownsHandle) : base(ownsHandle)
         {
-            JSHandle = (int)jsHandle;
-            Handle = GCHandle.Alloc(this);
+            SetHandle(js_handle);
+            this.AnyRefHandle = GCHandle.Alloc(this, ownsHandle ? GCHandleType.Weak : GCHandleType.Normal);
         }
+
+        // We should not provide a finalizer - SafeHandle's critical finalizer will call ReleaseHandle inside a CER for us.
+        protected override bool ReleaseHandle() => throw new NotImplementedException();
+
+#if DEBUG_HANDLE
+        private int _refCount = 0;
+
+        public void AddRef()
+        {
+            Interlocked.Increment(ref _refCount);
+        }
+
+        public void Release()
+        {
+            Interlocked.MemoryBarrier();
+            Debug.Assert(_refCount > 0, "AnyRefSafeHandle: Release() called more times than AddRef");
+            Interlocked.Decrement(ref _refCount);
+        }
+
+        public int RefCount => _refCount;
+#endif
     }
 }

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/Array.cs

@@ -22,7 +22,8 @@ public Array(params object[] _params) : base(Interop.Runtime.New<Array>(_params)
         /// Initializes a new instance of the Array/> class.
         /// </summary>
         /// <param name="jsHandle">Js handle.</param>
-        internal Array(IntPtr jsHandle) : base(jsHandle)
+        /// <param name="ownsHandle">Whether or not the handle is owned by the clr or not.</param>
+        internal Array(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
         { }
 
         /// <summary>

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/ArrayBuffer.cs

@@ -25,7 +25,8 @@ public ArrayBuffer(int length) : base(Interop.Runtime.New<ArrayBuffer>(length))
         /// Initializes a new instance of the JavaScript Core ArrayBuffer class.
         /// </summary>
         /// <param name="jsHandle">Js handle.</param>
-        internal ArrayBuffer(IntPtr jsHandle) : base(jsHandle)
+        /// <param name="ownsHandle">Whether or not the handle is owned by the clr or not.</param>
+        internal ArrayBuffer(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
         { }
 
         /// <summary>

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/CoreObject.cs

@@ -22,14 +22,14 @@ namespace System.Runtime.InteropServices.JavaScript
     /// </remarks>
     public abstract class CoreObject : JSObject
     {
-        protected CoreObject(int jsHandle) : base(jsHandle)
+        protected CoreObject(int jsHandle) : base(jsHandle, true)
         {
-            object result = Interop.Runtime.BindCoreObject(jsHandle, (int)(IntPtr)Handle, out int exception);
+            object result = Interop.Runtime.BindCoreObject(jsHandle, (int)(IntPtr)AnyRefHandle, out int exception);
             if (exception != 0)
                 throw new JSException($"CoreObject Error binding: {result}");
         }
 
-        internal CoreObject(IntPtr js_handle) : base(js_handle)
+        internal CoreObject(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
         { }
     }
 }

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/DataView.cs

@@ -63,8 +63,9 @@ public DataView(SharedArrayBuffer buffer, int byteOffset, int byteLength) : base
         /// <summary>
         /// Initializes a new instance of the DataView class.
         /// </summary>
-        /// <param name="js_handle">Js handle.</param>
-        internal DataView(IntPtr js_handle) : base(js_handle)
+        /// <param name="jsHandle">Js handle.</param>
+        /// <param name="ownsHandle">Managed owned</param>
+        internal DataView(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
         { }
         /// <summary>
         /// Gets the length (in bytes) of this view from the start of its ArrayBuffer. Fixed at construction time and thus read only.

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/Float32Array.cs

@@ -25,7 +25,8 @@ public Float32Array(SharedArrayBuffer buffer, int byteOffset) : base(buffer, byt
 
         public Float32Array(SharedArrayBuffer buffer, int byteOffset, int length) : base(buffer, byteOffset, length) { }
 
-        internal Float32Array(IntPtr js_handle) : base(js_handle) { }
+        internal Float32Array(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
+        { }
 
         /// <summary>
         /// Defines an implicit conversion of Float32Array class to a float

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/Float64Array.cs

@@ -25,7 +25,8 @@ public Float64Array(SharedArrayBuffer buffer, int byteOffset) : base(buffer, byt
 
         public Float64Array(SharedArrayBuffer buffer, int byteOffset, int length) : base(buffer, byteOffset, length) { }
 
-        internal Float64Array(IntPtr js_handle) : base(js_handle) { }
+        internal Float64Array(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
+        { }
 
         /// <summary>
         /// Defines an implicit conversion of Float64Array class to a double

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/Function.cs

@@ -20,7 +20,7 @@ public class Function : CoreObject
         public Function(params object[] args) : base(Interop.Runtime.New<Function>(args))
         { }
 
-        internal Function(IntPtr jHandle) : base(jHandle)
+        internal Function(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
         { }
 
         /// <summary>

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/HostObject.cs

@@ -28,14 +28,14 @@ public HostObject(string hostName, params object[] _params) : base(Interop.Runti
 
     public abstract class HostObjectBase : JSObject, IHostObject
     {
-        protected HostObjectBase(int jHandle) : base(jHandle)
+        protected HostObjectBase(int jHandle) : base(jHandle, true)
         {
-            object result = Interop.Runtime.BindHostObject(jHandle, (int)(IntPtr)Handle, out int exception);
+            object result = Interop.Runtime.BindHostObject(jHandle, (int)(IntPtr)AnyRefHandle, out int exception);
             if (exception != 0)
                 throw new JSException($"HostObject Error binding: {result}");
         }
 
-        internal HostObjectBase(IntPtr js_handle) : base(js_handle)
+        internal HostObjectBase(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
         { }
     }
 }

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/Int16Array.cs

@@ -25,7 +25,7 @@ public Int16Array(SharedArrayBuffer buffer, int byteOffset) : base(buffer, byteO
 
         public Int16Array(SharedArrayBuffer buffer, int byteOffset, int length) : base(buffer, byteOffset, length) { }
 
-        internal Int16Array(IntPtr js_handle) : base(js_handle)
+        internal Int16Array(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
         { }
 
         /// <summary>

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/Int32Array.cs

@@ -25,7 +25,8 @@ public Int32Array(SharedArrayBuffer buffer, int byteOffset) : base(buffer, byteO
 
         public Int32Array(SharedArrayBuffer buffer, int byteOffset, int length) : base(buffer, byteOffset, length) { }
 
-        internal Int32Array(IntPtr js_handle) : base(js_handle) { }
+        internal Int32Array(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
+        { }
 
         /// <summary>
         /// Defines an implicit conversion of Int32Array class to a int

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/Int8Array.cs

@@ -34,7 +34,7 @@ public Int8Array(SharedArrayBuffer buffer, int byteOffset) : base(buffer, byteOf
         public Int8Array(SharedArrayBuffer buffer, int byteOffset, int length) : base(buffer, byteOffset, length)
         { }
 
-        internal Int8Array(IntPtr js_handle) : base(js_handle)
+        internal Int8Array(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
         { }
 
         /// <summary>

src/libraries/System.Runtime.InteropServices.JavaScript/src/System/Runtime/InteropServices/JavaScript/JSObject.cs

@@ -11,6 +11,7 @@ public interface IJSObject
         int JSHandle { get; }
         int Length { get; }
     }
+
     /// <summary>
     ///   JSObjects are wrappers for a native JavaScript object, and
     ///   they retain a reference to the JavaScript object for the lifetime of this C# object.
@@ -19,28 +20,50 @@ public class JSObject : AnyRef, IJSObject, IDisposable
     {
         internal object? RawObject;
 
+        // Right now this is used for Delegates
+        internal WeakReference? WeakRawObject;
+
         // to detect redundant calls
         public bool IsDisposed { get; internal set; }
 
-        public JSObject() : this(Interop.Runtime.New<object>())
+        public JSObject() : this(Interop.Runtime.New<object>(), true)
         {
-            object result = Interop.Runtime.BindCoreObject(JSHandle, (int)(IntPtr)Handle, out int exception);
+            object result = Interop.Runtime.BindCoreObject(JSHandle, (int)(IntPtr)AnyRefHandle, out int exception);
             if (exception != 0)
                 throw new JSException($"JSObject Error binding: {result}");
 
         }
 
-        internal JSObject(IntPtr js_handle) : base(js_handle)
+        internal JSObject(IntPtr jsHandle, bool ownsHandle) : base(jsHandle, ownsHandle)
         { }
 
-        internal JSObject(int js_handle) : base((IntPtr)js_handle)
+        internal JSObject(int jsHandle, bool ownsHandle) : base((IntPtr)jsHandle, ownsHandle)
         { }
 
-        internal JSObject(int js_handle, object raw_obj) : base(js_handle)
+        internal JSObject(int jsHandle, object rawObj) : base(jsHandle, false)
         {
-            RawObject = raw_obj;
+            RawObject = rawObj;
         }
 
+        /// <summary>
+        ///   Invoke a named method of the object, or throws a JSException on error.
+        /// </summary>
+        /// <param name="method">The name of the method to invoke.</param>
+        /// <param name="args">The argument list to pass to the invoke command.</param>
+        /// <returns>
+        ///   <para>
+        ///     The return value can either be a primitive (string, int, double), a JSObject for JavaScript objects, a
+        ///     System.Threading.Tasks.Task(object) for JavaScript promises, an array of
+        ///     a byte, int or double (for Javascript objects typed as ArrayBuffer) or a
+        ///     System.Func to represent JavaScript functions.  The specific version of
+        ///     the Func that will be returned depends on the parameters of the Javascript function
+        ///     and return value.
+        ///   </para>
+        ///   <para>
+        ///     The value of a returned promise (The Task(object) return) can in turn be any of the above
+        ///     valuews.
+        ///   </para>
+        /// </returns>
         public object Invoke(string method, params object?[] args)
         {
             object res = Interop.Runtime.InvokeJSWithArgs(JSHandle, method, args, out int exception);
@@ -49,25 +72,52 @@ public object Invoke(string method, params object?[] args)
             return res;
         }
 
+        /// <summary>
+        ///   Returns the named property from the object, or throws a JSException on error.
+        /// </summary>
+        /// <param name="name">The name of the property to lookup</param>
+        /// <remarks>
+        ///   This method can raise a JSException if fetching the property in Javascript raises an exception.
+        /// </remarks>
+        /// <returns>
+        ///   <para>
+        ///     The return value can either be a primitive (string, int, double), a
+        ///     JSObject for JavaScript objects, a
+        ///     System.Threading.Tasks.Task (object) for JavaScript promises, an array of
+        ///     a byte, int or double (for Javascript objects typed as ArrayBuffer) or a
+        ///     System.Func to represent JavaScript functions.  The specific version of
+        ///     the Func that will be returned depends on the parameters of the Javascript function
+        ///     and return value.
+        ///   </para>
+        ///   <para>
+        ///     The value of a returned promise (The Task(object) return) can in turn be any of the above
+        ///     valuews.
+        ///   </para>
+        /// </returns>
         public object GetObjectProperty(string name)
         {
-
             object propertyValue = Interop.Runtime.GetObjectProperty(JSHandle, name, out int exception);
-
             if (exception != 0)
                 throw new JSException((string)propertyValue);
-
             return propertyValue;
-
         }
 
+        /// <summary>
+        ///   Sets the named property to the provided value.
+        /// </summary>
+        /// <remarks>
+        /// </remarks>
+        /// <param name="name">The name of the property to lookup</param>
+        /// <param name="value">The value can be a primitive type (int, double, string, bool), an
+        /// array that will be surfaced as a typed ArrayBuffer (byte[], sbyte[], short[], ushort[],
+        /// float[], double[]) </param>
+        /// <param name="createIfNotExists">Defaults to <see langword="true"/> and creates the property on the javascript object if not found, if set to <see langword="false"/> it will not create the property if it does not exist.  If the property exists, the value is updated with the provided value.</param>
+        /// <param name="hasOwnProperty"></param>
         public void SetObjectProperty(string name, object value, bool createIfNotExists = true, bool hasOwnProperty = false)
         {
-
             object setPropResult = Interop.Runtime.SetObjectProperty(JSHandle, name, value, createIfNotExists, hasOwnProperty, out int exception);
             if (exception != 0)
-                throw new JSException($"Error setting {name} on (js-obj js '{JSHandle}' .NET '{(IntPtr)Handle} raw '{RawObject != null})");
-
+                throw new JSException($"Error setting {name} on (js-obj js '{JSHandle}' .NET '{(IntPtr)AnyRefHandle} raw '{RawObject != null})");
         }
 
         /// <summary>
@@ -96,9 +146,7 @@ public int Length
 
         protected void FreeHandle()
         {
-            Interop.Runtime.ReleaseHandle(JSHandle, out int exception);
-            if (exception != 0)
-                throw new JSException($"Error releasing handle on (js-obj js '{JSHandle}' .NET '{(IntPtr)Handle} raw '{RawObject != null})");
+            Runtime.ReleaseJSObject(this);
         }
 
         public override bool Equals(object? obj) => obj is JSObject other && JSHandle == other.JSHandle;
@@ -108,44 +156,35 @@ public override int GetHashCode()
             return JSHandle;
         }
 
-        ~JSObject()
+        // We should not provide a finalizer - SafeHandle's critical finalizer will call ReleaseHandle inside a CER for us.
+        protected override bool ReleaseHandle()
         {
-            Dispose(false);
-        }
-
-        public void Dispose()
-        {
-            // Dispose of unmanaged resources.
-            Dispose(true);
-            // Suppress finalization.
-            GC.SuppressFinalize(this);
-        }
-
-        // Protected implementation of Dispose pattern.
-        protected virtual void Dispose(bool disposing)
-        {
-
-            if (!IsDisposed)
-            {
-                if (disposing)
-                {
-
-                    // Free any other managed objects here.
-                    //
-                    RawObject = null;
-                }
-
-                IsDisposed = true;
-
-                // Free any unmanaged objects here.
-                FreeHandle();
-
-            }
+            bool ret = false;
+
+#if DEBUG_HANDLE
+			Console.WriteLine ($"Release Handle handle:{handle}");
+			try {
+#endif
+            FreeHandle();
+
+#if DEBUG_HANDLE
+			} catch (Exception exception) {
+				Console.WriteLine ($"ReleaseHandle: {exception.Message}");
+				ret = true;  // Avoid a second assert.
+				throw;
+			} finally {
+				if (!ret) {
+					Console.WriteLine ($"ReleaseHandle failed. handle:{handle}");
+				}
+			}
+			//Runtime.DumpExistingObjects();
+#endif
+            return ret;
         }
 
         public override string ToString()
         {
-            return $"(js-obj js '{JSHandle}' .NET '{(IntPtr)Handle} raw '{RawObject != null})";
+            return $"(js-obj js '{(IntPtr)AnyRefHandle}' raw '{RawObject != null}' weak_raw '{WeakRawObject != null}')";
         }
 
     }