[Java.Runtime.Environment] Permit identityHashCode collisions

Fixes: #5

java.lang.System.identityHashCode() returns a 32-bit integer.

MonoRuntimeValueManager was using this as value as the key to map JNI
handles to managed peer instances.

What happens if two different Java instances have the same
identityHashCode() value? [0]

:-)

The answer is "you get the wrong managed peer", and things promptly
go weird.

(Is there a way to test this? Not easily.)

Change MonoRuntimeValueManager so that instead of using a:

	Dictionary<int, WeakReference<IJavaPeerable>>

which can support only one managed peer per identityHashCode() value,
instead use a:

	Dictionary<int, List<WeakReference<IJavaPeerable>>>

This allows each identityHashCode() "key" to refer to *multiple*
managed peers, allowing things to stay (reasonably) sane.

[0]:  You may ask "How likely is that?", but (1) with 64-bit processes,
      *all bets are off* for *32-bit* values, and (2) this can happen
			on Android [1, 2].
[1]: https://bugzilla.xamarin.com/show_bug.cgi?id=27408
[2]: https://github.com/xamarin/monodroid/commit/ea65174bcdb4cf5d32ef5f566275877333f4e09c

Author: jonpryor

src/Java.Runtime.Environment/Java.Interop/MonoRuntimeValueManager.cs

@@ -73,24 +73,30 @@ protected override void Dispose (bool disposing)
 			if (RegisteredInstances == null)
 				return;
 
-			foreach (var o in RegisteredInstances.Values) {
-				IJavaPeerable t;
-				if (!o.TryGetTarget (out t))
-					continue;
-				t.Dispose ();
+			lock (RegisteredInstances) {
+				foreach (var o in RegisteredInstances.Values) {
+					foreach (var r in o) {
+						IJavaPeerable t;
+						if (!r.TryGetTarget (out t))
+							continue;
+						t.Dispose ();
+					}
+				}
+				RegisteredInstances.Clear ();
 			}
-			RegisteredInstances.Clear ();
 		}
 
-		Dictionary<int, WeakReference<IJavaPeerable>>  RegisteredInstances = new Dictionary<int, WeakReference<IJavaPeerable>>();
+		Dictionary<int, List<WeakReference<IJavaPeerable>>>     RegisteredInstances = new Dictionary<int, List<WeakReference<IJavaPeerable>>>();
 
 
 		public override List<JniSurfacedPeerInfo> GetSurfacedPeers ()
 		{
 			lock (RegisteredInstances) {
 				var peers = new List<JniSurfacedPeerInfo> (RegisteredInstances.Count);
 				foreach (var e in RegisteredInstances) {
-					peers.Add (new JniSurfacedPeerInfo (e.Key, e.Value));
+					foreach (var p in e.Value) {
+						peers.Add (new JniSurfacedPeerInfo (e.Key, p));
+					}
 				}
 				return peers;
 			}
@@ -111,26 +117,52 @@ public override void Add (IJavaPeerable value)
 			}
 			int key = value.JniIdentityHashCode;
 			lock (RegisteredInstances) {
-				WeakReference<IJavaPeerable>    existing;
-				IJavaPeerable     target;
-				if (RegisteredInstances.TryGetValue (key, out existing) && existing.TryGetTarget (out target) && !Replaceable (target))
-					Runtime.ObjectReferenceManager.WriteGlobalReferenceLine (
-							"Warning: Not registering PeerReference={0} IdentityHashCode=0x{1} Instance={2} Instance.Type={3} Java.Type={4}; " +
-							"keeping previously registered PeerReference={5} Instance={6} Instance.Type={7} Java.Type={8}.",
-							value.PeerReference.ToString (),
-							key.ToString ("x"),
-							RuntimeHelpers.GetHashCode (value).ToString ("x"),
-							value.GetType ().FullName,
-							JniEnvironment.Types.GetJniTypeNameFromInstance (value.PeerReference),
-							target.PeerReference.ToString (),
-							RuntimeHelpers.GetHashCode (target).ToString ("x"),
-							target.GetType ().FullName,
-							JniEnvironment.Types.GetJniTypeNameFromInstance (target.PeerReference));
-				else
-					RegisteredInstances [key] = new WeakReference<IJavaPeerable> (value, trackResurrection: true);
+				List<WeakReference<IJavaPeerable>> peers;
+				if (!RegisteredInstances.TryGetValue (key, out peers)) {
+					peers = new List<WeakReference<IJavaPeerable>> () {
+						new WeakReference<IJavaPeerable>(value, trackResurrection: true),
+					};
+					RegisteredInstances.Add (key, peers);
+					return;
+				}
+
+				for (int i = peers.Count - 1; i >= 0; i--) {
+					var wp = peers [i];
+					IJavaPeerable   p;
+					if (!wp.TryGetTarget (out p)) {
+						// Peer was collected
+						peers.RemoveAt (i);
+						continue;
+					}
+					if (!JniEnvironment.Types.IsSameObject (p.PeerReference, value.PeerReference))
+						continue;
+					if (Replaceable (p)) {
+						peers [i] = new WeakReference<IJavaPeerable>(value, trackResurrection: true);
+					} else {
+						WarnNotReplacing (key, value, p);
+					}
+					return;
+				}
+				peers.Add (new WeakReference<IJavaPeerable> (value, trackResurrection: true));
 			}
 		}
 
+		void WarnNotReplacing (int key, IJavaPeerable ignoreValue, IJavaPeerable keepValue)
+		{
+			Runtime.ObjectReferenceManager.WriteGlobalReferenceLine (
+					"Warning: Not registering PeerReference={0} IdentityHashCode=0x{1} Instance={2} Instance.Type={3} Java.Type={4}; " +
+					"keeping previously registered PeerReference={5} Instance={6} Instance.Type={7} Java.Type={8}.",
+					ignoreValue.PeerReference.ToString (),
+					key.ToString ("x"),
+					RuntimeHelpers.GetHashCode (ignoreValue).ToString ("x"),
+					ignoreValue.GetType ().FullName,
+					JniEnvironment.Types.GetJniTypeNameFromInstance (ignoreValue.PeerReference),
+					keepValue.PeerReference.ToString (),
+					RuntimeHelpers.GetHashCode (keepValue).ToString ("x"),
+					keepValue.GetType ().FullName,
+					JniEnvironment.Types.GetJniTypeNameFromInstance (keepValue.PeerReference));
+		}
+
 		static bool Replaceable (IJavaPeerable peer)
 		{
 			if (peer == null)
@@ -140,13 +172,28 @@ static bool Replaceable (IJavaPeerable peer)
 
 		public override void Remove (IJavaPeerable value)
 		{
+			if (value == null)
+				throw new ArgumentNullException (nameof (value));
+
 			int key = value.JniIdentityHashCode;
 			lock (RegisteredInstances) {
-				WeakReference<IJavaPeerable>  wv;
-				IJavaPeerable                 t;
-				if (RegisteredInstances.TryGetValue (key, out wv) &&
-						wv.TryGetTarget (out t) &&
-						object.ReferenceEquals (value, t))
+				List<WeakReference<IJavaPeerable>> peers;
+				if (!RegisteredInstances.TryGetValue (key, out peers))
+					return;
+
+				for (int i = peers.Count - 1; i >= 0; i--) {
+					var wp = peers [i];
+					IJavaPeerable   p;
+					if (!wp.TryGetTarget (out p)) {
+						// Peer was collected
+						peers.RemoveAt (i);
+						continue;
+					}
+					if (object.ReferenceEquals (value, p)) {
+						peers.RemoveAt (i);
+					}
+				}
+				if (peers.Count == 0)
 					RegisteredInstances.Remove (key);
 			}
 		}
@@ -159,13 +206,23 @@ public override IJavaPeerable PeekPeer (JniObjectReference reference)
 			int key = GetJniIdentityHashCode (reference);
 
 			lock (RegisteredInstances) {
-				WeakReference<IJavaPeerable>    wv;
-				if (RegisteredInstances.TryGetValue (key, out wv)) {
-					IJavaPeerable target;
-					if (wv.TryGetTarget (out target))
-						return target;
+				List<WeakReference<IJavaPeerable>> peers;
+				if (!RegisteredInstances.TryGetValue (key, out peers))
+					return null;
+
+				for (int i = peers.Count - 1; i >= 0; i--) {
+					var wp = peers [i];
+					IJavaPeerable   p;
+					if (!wp.TryGetTarget (out p)) {
+						// Peer was collected
+						peers.RemoveAt (i);
+						continue;
+					}
+					if (JniEnvironment.Types.IsSameObject (reference, p.PeerReference))
+						return p;
 				}
-				RegisteredInstances.Remove (key);
+				if (peers.Count == 0)
+					RegisteredInstances.Remove (key);
 			}
 			return null;
 		}