Bye-bye ReflectiveAccess, introducing PropertyMaster, see #1750

- PropertyMaster is the only place in Akka which calls
  ClassLoader.getClass (apart from kernel, which might be special)
- all PropertyMaster methods (there are only three) take a ClassManifest
  of what is to be constructed, and they verify that the obtained object
  is actually compatible with the required type

Other stuff:
- noticed that I had forgotten to change to ExtendedActorSystem when
  constructing Extensions by ExtensionKey (damn you, reflection!)
- moved Serializer.currentSystem into JavaSerializer, because that’s the
  only one needing it (it’s only used in readResolve() methods)
- Serializers are constructed now with one-arg constructor taking
  ExtendedActorSystem (if that exists, otherwise no-arg as before), to
  allow JavaSerializer to do its magic; possibly necessary for others as
  well
- Removed all Option[ClassLoader] signatures
- made it so that the ActorSystem will try context class loader, then
  the class loader which loaded the class actually calling into
  ActorSystem.apply, then the loader which loaded ActorSystemImpl
- for the second of the above I added a (reflectively accessed hopefully
  safe) facility for getting caller Class[_] objects by using
  sun.reflect.Reflection; this is optional an defaults to None, e.g. on
  Android, which means that getting the caller’s classloader is done on
  a best effort basis (there’s nothing we can do because a StackTrace
  does not contain actual Class[_] objects).
- refactored DurableMailbox to contain the owner val and use that
  instead of declaring that in all subclasses

akka-actor/src/main/scala/akka/serialization/Serialization.scala

@@ -5,30 +5,16 @@
 package akka.serialization
 
 import akka.AkkaException
-import akka.util.ReflectiveAccess
 import scala.util.DynamicVariable
 import com.typesafe.config.Config
 import akka.config.ConfigurationException
-import akka.actor.{ Extension, ActorSystem, ExtendedActorSystem, Address }
+import akka.actor.{ Extension, ExtendedActorSystem, Address }
 import java.util.concurrent.ConcurrentHashMap
 import akka.event.Logging
 
 case class NoSerializerFoundException(m: String) extends AkkaException(m)
 
 object Serialization {
-  /**
-   * This holds a reference to the current ActorSystem (the surrounding context)
-   * during serialization and deserialization.
-   *
-   * If you are using Serializers yourself, outside of SerializationExtension,
-   * you'll need to surround the serialization/deserialization with:
-   *
-   * currentSystem.withValue(system) {
-   *   ...code...
-   * }
-   */
-  val currentSystem = new DynamicVariable[ActorSystem](null)
-
   /**
    * This holds a reference to the current transport address to be inserted
    * into local actor refs during serialization.
@@ -74,7 +60,8 @@ class Serialization(val system: ExtendedActorSystem) extends Extension {
    * to either an Array of Bytes or an Exception if one was thrown.
    */
   def serialize(o: AnyRef): Either[Exception, Array[Byte]] =
-    try { Right(findSerializerFor(o).toBinary(o)) } catch { case e: Exception ⇒ Left(e) }
+    try Right(findSerializerFor(o).toBinary(o))
+    catch { case e: Exception ⇒ Left(e) }
 
   /**
    * Deserializes the given array of bytes using the specified serializer id,
@@ -83,26 +70,18 @@ class Serialization(val system: ExtendedActorSystem) extends Extension {
    */
   def deserialize(bytes: Array[Byte],
                   serializerId: Int,
-                  clazz: Option[Class[_]],
-                  classLoader: ClassLoader): Either[Exception, AnyRef] =
-    try {
-      currentSystem.withValue(system) {
-        Right(serializerByIdentity(serializerId).fromBinary(bytes, clazz, Some(classLoader)))
-      }
-    } catch { case e: Exception ⇒ Left(e) }
+                  clazz: Option[Class[_]]): Either[Exception, AnyRef] =
+    try Right(serializerByIdentity(serializerId).fromBinary(bytes, clazz))
+    catch { case e: Exception ⇒ Left(e) }
 
   /**
    * Deserializes the given array of bytes using the specified type to look up what Serializer should be used.
    * You can specify an optional ClassLoader to load the object into.
    * Returns either the resulting object or an Exception if one was thrown.
    */
-  def deserialize(
-    bytes: Array[Byte],
-    clazz: Class[_],
-    classLoader: Option[ClassLoader]): Either[Exception, AnyRef] =
-    try {
-      currentSystem.withValue(system) { Right(serializerFor(clazz).fromBinary(bytes, Some(clazz), classLoader)) }
-    } catch { case e: Exception ⇒ Left(e) }
+  def deserialize(bytes: Array[Byte], clazz: Class[_]): Either[Exception, AnyRef] =
+    try Right(serializerFor(clazz).fromBinary(bytes, Some(clazz)))
+    catch { case e: Exception ⇒ Left(e) }
 
   /**
    * Returns the Serializer configured for the given object, returns the NullSerializer if it's null,
@@ -149,8 +128,11 @@ class Serialization(val system: ExtendedActorSystem) extends Extension {
   /**
    * Tries to load the specified Serializer by the FQN
    */
-  def serializerOf(serializerFQN: String): Either[Exception, Serializer] =
-    ReflectiveAccess.createInstance(serializerFQN, ReflectiveAccess.noParams, ReflectiveAccess.noArgs)
+  def serializerOf(serializerFQN: String): Either[Throwable, Serializer] = {
+    val pm = system.propertyMaster
+    pm.getInstanceFor[Serializer](serializerFQN, Seq(classOf[ExtendedActorSystem] -> system))
+      .fold(_ ⇒ pm.getInstanceFor[Serializer](serializerFQN, Seq()), Right(_))
+  }
 
   /**
    * A Map of serializer from alias to implementation (class implementing akka.serialization.Serializer)