# HG changeset patch # User Andrew John Hughes # Date 1378229989 -3600 # Node ID ab73a2646f3c73867785bc4b87c8412626509a70 # Parent 44c41a07b14dcf7152524b22b2301517bb7c089b Fix TCK regression caused by backport of 7162902. 2013-08-28 Andrew John Hughes * Makefile.am: (ICEDTEA_PATCHES): Add new backport. * patches/openjdk/6893617-cnctx_always_uses_default_orb.patch: Fixes TCK regression caused by 7162902. diff -r 44c41a07b14d -r ab73a2646f3c ChangeLog --- a/ChangeLog Tue Sep 03 18:37:53 2013 +0100 +++ b/ChangeLog Tue Sep 03 18:39:49 2013 +0100 @@ -1,3 +1,10 @@ +2013-08-28 Andrew John Hughes + + * Makefile.am: + (ICEDTEA_PATCHES): Add new backport. + * patches/openjdk/6893617-cnctx_always_uses_default_orb.patch: + Fixes TCK regression caused by 7162902. + 2013-08-06 Andrew John Hughes * 8013196-TimeZone_getDefault_throws_exception.patch: diff -r 44c41a07b14d -r ab73a2646f3c Makefile.am --- a/Makefile.am Tue Sep 03 18:37:53 2013 +0100 +++ b/Makefile.am Tue Sep 03 18:39:49 2013 +0100 @@ -656,7 +656,8 @@ patches/openjdk/7022999-fastlocking_compiler1_only.patch \ patches/openjdk/7196533-timezone_bottleneck.patch \ patches/openjdk/6636370-appcontext_simplification.patch \ - patches/openjdk/6636331-appcontext_concurrentmodificationexception.patch + patches/openjdk/6636331-appcontext_concurrentmodificationexception.patch \ + patches/openjdk/6893617-cnctx_always_uses_default_orb.patch if WITH_RHINO ICEDTEA_PATCHES += \ diff -r 44c41a07b14d -r ab73a2646f3c patches/openjdk/6893617-cnctx_always_uses_default_orb.patch --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/patches/openjdk/6893617-cnctx_always_uses_default_orb.patch Tue Sep 03 18:39:49 2013 +0100 @@ -0,0 +1,234 @@ +# HG changeset patch +# User coffeys +# Date 1340827826 -3600 +# Wed Jun 27 21:10:26 2012 +0100 +# Node ID 83f8283e47917f97b838257db5711e37be9b715e +# Parent 352fad83e8447dec768064f60dc85934db32ef27 +6893617: JDK 6 CNCtx always uses the default ORB +Reviewed-by: lancea + +diff --git a/src/share/classes/com/sun/jndi/cosnaming/CNCtx.java b/src/share/classes/com/sun/jndi/cosnaming/CNCtx.java +--- openjdk/jdk/src/share/classes/com/sun/jndi/cosnaming/CNCtx.java ++++ openjdk/jdk/src/share/classes/com/sun/jndi/cosnaming/CNCtx.java +@@ -1,5 +1,5 @@ + /* +- * Copyright (c) 1999, 2005, Oracle and/or its affiliates. All rights reserved. ++ * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it +@@ -59,8 +59,22 @@ + + private final static boolean debug = false; + ++ /* ++ * Implement one shared ORB among all CNCtx. However, there is a public constructor ++ * accepting an ORB, so we need the option of using a given ORB. ++ */ ++ private static ORB _defaultOrb; + ORB _orb; // used by ExceptionMapper and RMI/IIOP factory + public NamingContext _nc; // public for accessing underlying NamingContext ++ ++ private synchronized static ORB getDefaultOrb() { ++ if (_defaultOrb == null) { ++ _defaultOrb = CorbaUtils.getOrb(null, -1, ++ new Hashtable()); ++ } ++ return _defaultOrb; ++ } ++ + private NameComponent[] _name = null; + + Hashtable _env; // used by ExceptionMapper +@@ -113,8 +127,9 @@ + // rest is the INS name + // Return the parsed form to prevent subsequent lookup + // from parsing the string as a composite name +- // The caller should be aware that a toString() of the name +- // will yield its INS syntax, rather than a composite syntax ++ // The caller should be aware that a toString() of the name, ++ // which came from the environment will yield its INS syntax, ++ // rather than a composite syntax + return new ResolveResult(ctx, parser.parse(rest)); + } + +@@ -134,10 +149,10 @@ + if (orb == null || nctx == null) + throw new ConfigurationException( + "Must supply ORB or NamingContext"); +- _orb = orb; +- orbTracker = tracker; +- if (orbTracker != null) { +- orbTracker.incRefCount(); ++ if (orb != null) { ++ _orb = orb; ++ } else { ++ _orb = getDefaultOrb(); + } + _nc = nctx; + _env = env; +@@ -211,10 +226,13 @@ + org.omg.CORBA.ORB inOrb = null; + String ncIor = null; + +- if (env != null) { ++ if (inOrb == null && env != null) { + inOrb = (org.omg.CORBA.ORB) env.get("java.naming.corba.orb"); + } + ++ if (inOrb == null) ++ inOrb = getDefaultOrb(); // will create a default ORB if none exists ++ + // Extract PROVIDER_URL from environment + String provUrl = null; + if (env != null) { +@@ -225,13 +243,6 @@ + // Initialize the root naming context by using the IOR supplied + // in the PROVIDER_URL + ncIor = getStringifiedIor(provUrl); +- +- if (inOrb == null) { +- +- // no ORB instance specified; create one using env and defaults +- inOrb = CorbaUtils.getOrb(null, -1, env); +- orbTracker = new OrbReuseTracker(inOrb); +- } + setOrbAndRootContext(inOrb, ncIor); + } else if (provUrl != null) { + // Initialize the root naming context by using the URL supplied +@@ -257,14 +268,8 @@ + } + } else { + // No PROVIDER_URL supplied; initialize using defaults +- if (inOrb == null) { +- +- // No ORB instance specified; create one using env and defaults +- inOrb = CorbaUtils.getOrb(null, -1, env); +- orbTracker = new OrbReuseTracker(inOrb); +- if (debug) { +- System.err.println("Getting default ORB: " + inOrb + env); +- } ++ if (debug) { ++ System.err.println("Getting default ORB: " + inOrb + env); + } + setOrbAndRootContext(inOrb, (String)null); + } +@@ -285,6 +290,10 @@ + */ + private String initUsingIiopUrl(ORB defOrb, String url, Hashtable env) + throws NamingException { ++ ++ if (defOrb == null) ++ defOrb = getDefaultOrb(); ++ + try { + IiopUrl parsedUrl = new IiopUrl(url); + +@@ -296,19 +305,17 @@ + addr = (IiopUrl.Address)addrs.elementAt(i); + + try { +- if (defOrb != null) { +- try { +- String tmpUrl = "corbaloc:iiop:" + addr.host +- + ":" + addr.port + "/NameService"; +- if (debug) { +- System.err.println("Using url: " + tmpUrl); +- } +- org.omg.CORBA.Object rootCtx = +- defOrb.string_to_object(tmpUrl); +- setOrbAndRootContext(defOrb, rootCtx); +- return parsedUrl.getStringName(); +- } catch (Exception e) {} // keep going +- } ++ try { ++ String tmpUrl = "corbaloc:iiop:" + addr.host ++ + ":" + addr.port + "/NameService"; ++ if (debug) { ++ System.err.println("Using url: " + tmpUrl); ++ } ++ org.omg.CORBA.Object rootCtx = ++ defOrb.string_to_object(tmpUrl); ++ setOrbAndRootContext(defOrb, rootCtx); ++ return parsedUrl.getStringName(); ++ } catch (Exception e) {} // keep going + + // Get ORB + if (debug) { +@@ -316,12 +323,8 @@ + + " and port " + addr.port); + } + +- // Get ORB +- ORB orb = CorbaUtils.getOrb(addr.host, addr.port, env); +- orbTracker = new OrbReuseTracker(orb); +- + // Assign to fields +- setOrbAndRootContext(orb, (String)null); ++ setOrbAndRootContext(defOrb, (String)null); + return parsedUrl.getStringName(); + + } catch (NamingException ne) { +@@ -343,18 +346,16 @@ + */ + private String initUsingCorbanameUrl(ORB orb, String url, Hashtable env) + throws NamingException { ++ ++ if (orb == null) ++ orb = getDefaultOrb(); ++ + try { + CorbanameUrl parsedUrl = new CorbanameUrl(url); + + String corbaloc = parsedUrl.getLocation(); + String cosName = parsedUrl.getStringName(); + +- if (orb == null) { +- +- // No ORB instance specified; create one using env and defaults +- orb = CorbaUtils.getOrb(null, -1, env); +- orbTracker = new OrbReuseTracker(orb); +- } + setOrbAndRootContext(orb, corbaloc); + + return parsedUrl.getStringName(); +@@ -1115,9 +1116,6 @@ + } + + synchronized public void incEnumCount() { +- if (orbTracker == null) { +- return; +- } + enumCount++; + if (debug) { + System.out.println("incEnumCount, new count:" + enumCount); +@@ -1126,9 +1124,6 @@ + + synchronized public void decEnumCount() + throws NamingException { +- if (orbTracker == null) { +- return; +- } + enumCount--; + if (debug) { + System.out.println("decEnumCount, new count:" + enumCount + +@@ -1140,14 +1135,15 @@ + } + + synchronized public void close() throws NamingException { +- if (orbTracker == null) { +- return; +- } ++ + if (enumCount > 0) { + isCloseCalled = true; + return; + } +- orbTracker.decRefCount(); ++ ++ // Never destroy an orb in CNCtx. ++ // The orb we have is either the shared/default orb, or one passed in to a constructor ++ // from elsewhere, so that orb is somebody else's reponsibility. + } + + protected void finalize() {