[Java.Interop] Purge "Wrapper" from naming.

We need consistent naming, which brings us to the current naming
dictionary:

	https://developer.xamarin.com/guides/android/advanced_topics/garbage_collection/#Cross-VM_Object_Collections

Changing certain names to be consistent with Java.Interop, we have:

> There are three categories of object types.
>
> * **Managed objects**: types which do not inherit from `JavaObject`,
>     e.g. `System.String`. These are collected normally by the GC.
>
> * **Java objects**: Java types which are present within the [Java] VM
>     but not exposed to the Mono VM.
>
> * **Peer objects**: types which implement `IJavaPeerable`, e.g. all
>     `JavaObject` and `JavaException` subclasses. Instances of these
>     types have two "halfs" a *managed peer* and a *native peer*.
>     The managed peer is an instance of the managed type.
>     The native peer is an instance of a Java class within the Java VM,
>     and the managed `IJavaPeerable.PeerReference` property contains a
>     JNI global reference to the native peer.
>
> There are two types of native peers:
>
> * **Framework peers**: "Normal" Java types which know nothing of
>     Java.Interop, e.g. java.lang.String.
> * **User peers**: Java Callable Wrappers which exist for each
>     `JavaObject` subclass present within the app.

Notice a word "missing" from that terminology description? "Wrapper".

The problem with "wrapper" is that it implies something is being
"wrapped", which *is not the case* with User Peers; the "wrapper"
would be the corresponding Java instance, the *User peer*, but it's
not a wrapper, so using "Wrapper" is misleading.

Instead, Xamarin.Android uses the term "Peer" ~fairly consistently,
and Java.Interop has been following suite in some areas, e.g.
IJava**Peer**able.**Peer**Reference. ;-)

Replace all instances of "Wrapper" within Java.Interop.dll and replace
with "Peer":

* JniRuntime.JniValueManager.CreateWrapper() is now
  JniRuntime.JniValueManager.CreatePeer().

* JniTypeSignature.GetPrimitiveWrapper() is now
  JniTypeSignature.GetPrimitivePeerTypeSignature().

* JniTypeSignatureAttribute.GenerateJavaWrapper is now
  JniTypeSignatureAttribute.GenerateJavaPeer.

Author: jonpryor

src/Java.Interop/Java.Interop/JavaObjectArray.cs

@@ -17,7 +17,7 @@ static JniObjectReference _NewArray (int length)
 			if (info.SimpleReference == null)
 				info = new JniTypeSignature ("java/lang/Object", info.ArrayRank);
 			if (info.IsKeyword && info.ArrayRank == 0) {
-				info = info.GetPrimitiveWrapper ();
+				info = info.GetPrimitivePeerTypeSignature ();
 			}
 			using (var t = new JniType (info.Name)) {
 				return JniEnvironment.Arrays.NewObjectArray (length, t.PeerReference, new JniObjectReference ());

src/Java.Interop/Java.Interop/JniRuntime.JniValueManager.cs

@@ -196,30 +196,30 @@ object PeekBoxedObject (JniObjectReference reference)
 					: null;
 			}
 
-			static  readonly    KeyValuePair<Type, Type>[]      WrapperTypeMappings = new []{
+			static  readonly    KeyValuePair<Type, Type>[]      PeerTypeMappings = new []{
 				new KeyValuePair<Type, Type>(typeof (object),           typeof (JavaObject)),
 				new KeyValuePair<Type, Type>(typeof (IJavaPeerable),    typeof (JavaObject)),
 				new KeyValuePair<Type, Type>(typeof (Exception),        typeof (JavaException)),
 			};
 
-			static Type GetWrapperType (Type type)
+			static Type GetPeerType (Type type)
 			{
-				foreach (var m in WrapperTypeMappings) {
+				foreach (var m in PeerTypeMappings) {
 					if (m.Key == type)
 						return m.Value;
 				}
 				return type;
 			}
 
-			public virtual IJavaPeerable CreateWrapper (ref JniObjectReference reference, JniObjectReferenceOptions transfer, Type targetType)
+			public virtual IJavaPeerable CreatePeer (ref JniObjectReference reference, JniObjectReferenceOptions transfer, Type targetType)
 			{
 				targetType  = targetType ?? typeof (JavaObject);
-				targetType  = GetWrapperType (targetType);
+				targetType  = GetPeerType (targetType);
 
 				if (!typeof (IJavaPeerable).GetTypeInfo ().IsAssignableFrom (targetType.GetTypeInfo ()))
 					throw new ArgumentException ("targetType must implement IJavaPeerable!", "targetType");
 
-				var ctor = GetWrapperConstructor (reference, targetType);
+				var ctor = GetPeerConstructor (reference, targetType);
 				if (ctor == null)
 					throw new NotSupportedException (string.Format ("Could not find an appropriate constructable wrapper type for Java type '{0}', targetType='{1}'.",
 							JniEnvironment.Types.GetJniTypeNameFromInstance (reference), targetType));
@@ -237,7 +237,7 @@ public virtual IJavaPeerable CreateWrapper (ref JniObjectReference reference, Jn
 
 			static  readonly    Type    ByRefJniObjectReference = typeof (JniObjectReference).MakeByRefType ();
 
-			ConstructorInfo GetWrapperConstructor (JniObjectReference instance, Type fallbackType)
+			ConstructorInfo GetPeerConstructor (JniObjectReference instance, Type fallbackType)
 			{
 				var klass       = JniEnvironment.Types.GetObjectClass (instance);
 				var jniTypeName = JniEnvironment.Types.GetJniTypeNameFromClass (klass);
@@ -505,7 +505,7 @@ public override IJavaPeerable CreateGenericValue (ref JniObjectReference referen
 			var marshaler   = jvm.ValueManager.GetValueMarshaler (targetType ?? typeof(IJavaPeerable));
 			if (marshaler != Instance)
 				return (IJavaPeerable) marshaler.CreateValue (ref reference, options, targetType);
-			return jvm.ValueManager.CreateWrapper (ref reference, options, targetType);
+			return jvm.ValueManager.CreatePeer (ref reference, options, targetType);
 		}
 
 		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IJavaPeerable value, ParameterAttributes synchronize)
@@ -626,7 +626,7 @@ public override object CreateGenericValue (ref JniObjectReference reference, Jni
 				return target;
 			}
 			// Punt! Hope it's a java.lang.Object
-			return jvm.ValueManager.CreateWrapper (ref reference, options, targetType);
+			return jvm.ValueManager.CreatePeer (ref reference, options, targetType);
 		}
 
 		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (object value, ParameterAttributes synchronize)

src/Java.Interop/Java.Interop/JniTypeSignature.cs

@@ -57,7 +57,7 @@ public JniTypeSignature AddArrayRank (int rank)
 			return new JniTypeSignature (SimpleReference, ArrayRank + rank, IsKeyword);
 		}
 
-		public JniTypeSignature GetPrimitiveWrapper ()
+		public JniTypeSignature GetPrimitivePeerTypeSignature ()
 		{
 			if (!IsKeyword)
 				return this;

src/Java.Interop/Java.Interop/JniTypeSignatureAttribute.cs

@@ -33,7 +33,7 @@ public      int         ArrayRank               {
 			}
 		}
 
-		public      bool        GenerateJavaWrapper     {get; set;}
+		public      bool        GenerateJavaPeer        {get; set;}
 	}
 }