src/share/classes/java/lang/reflect/Constructor.java

rev 3746 : [mq]: cr6565585.ao

*** 72,89 ****
      // generic info repository; lazily initialized
      private transient ConstructorRepository genericInfo;
      private byte[]              annotations;
      private byte[]              parameterAnnotations;
  
-     // For non-public members or members in package-private classes,
-     // it is necessary to perform somewhat expensive security checks.
-     // If the security check succeeds for a given class, it will
-     // always succeed (it is not affected by the granting or revoking
-     // of permissions); we speed up the check in the common case by
-     // remembering the last Class for which the check succeeded.
-     private volatile Class<?> securityCheckCache;
- 
      // Generics infrastructure
      // Accessor for factory
      private GenericsFactory getFactory() {
          // create scope and factory
          return CoreReflectionFactory.make(this, ConstructorScope.make(this));
--- 72,81 ----
*** 516,535 ****
                 IllegalArgumentException, InvocationTargetException
      {
          if (!override) {
              if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                  Class<?> caller = Reflection.getCallerClass(2);
!                 if (securityCheckCache != caller) {
!                     Reflection.ensureMemberAccess(caller, clazz, null, modifiers);
!                     securityCheckCache = caller;
!                 }
              }
          }
          if ((clazz.getModifiers() & Modifier.ENUM) != 0)
              throw new IllegalArgumentException("Cannot reflectively create enum objects");
!         if (constructorAccessor == null) acquireConstructorAccessor();
!         return (T) constructorAccessor.newInstance(initargs);
      }
  
      /**
       * Returns {@code true} if this constructor was declared to take
       * a variable number of arguments; returns {@code false}
--- 508,528 ----
                 IllegalArgumentException, InvocationTargetException
      {
          if (!override) {
              if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                  Class<?> caller = Reflection.getCallerClass(2);
! 
!                 checkAccess(caller, clazz, null, modifiers);
              }
          }
          if ((clazz.getModifiers() & Modifier.ENUM) != 0)
              throw new IllegalArgumentException("Cannot reflectively create enum objects");
!         ConstructorAccessor ca = constructorAccessor;   // read volatile
!         if (ca == null) {
!             ca = acquireConstructorAccessor();
!         }
!         return (T) ca.newInstance(initargs);
      }
  
      /**
       * Returns {@code true} if this constructor was declared to take
       * a variable number of arguments; returns {@code false}
*** 558,581 ****
      // NOTE that there is no synchronization used here. It is correct
      // (though not efficient) to generate more than one
      // ConstructorAccessor for a given Constructor. However, avoiding
      // synchronization will probably make the implementation more
      // scalable.
!     private void acquireConstructorAccessor() {
          // First check to see if one has been created yet, and take it
          // if so.
          ConstructorAccessor tmp = null;
          if (root != null) tmp = root.getConstructorAccessor();
          if (tmp != null) {
              constructorAccessor = tmp;
!             return;
!         }
          // Otherwise fabricate one and propagate it up to the root
          tmp = reflectionFactory.newConstructorAccessor(this);
          setConstructorAccessor(tmp);
      }
  
      // Returns ConstructorAccessor for this Constructor object, not
      // looking up the chain to the root
      ConstructorAccessor getConstructorAccessor() {
          return constructorAccessor;
      }
--- 551,576 ----
      // NOTE that there is no synchronization used here. It is correct
      // (though not efficient) to generate more than one
      // ConstructorAccessor for a given Constructor. However, avoiding
      // synchronization will probably make the implementation more
      // scalable.
!     private ConstructorAccessor acquireConstructorAccessor() {
          // First check to see if one has been created yet, and take it
          // if so.
          ConstructorAccessor tmp = null;
          if (root != null) tmp = root.getConstructorAccessor();
          if (tmp != null) {
              constructorAccessor = tmp;
!         } else {
              // Otherwise fabricate one and propagate it up to the root
              tmp = reflectionFactory.newConstructorAccessor(this);
              setConstructorAccessor(tmp);
          }
  
+         return tmp;
+     }
+ 
      // Returns ConstructorAccessor for this Constructor object, not
      // looking up the chain to the root
      ConstructorAccessor getConstructorAccessor() {
          return constructorAccessor;
      }